name string | code string | asm string | file string |
|---|---|---|---|
multipart_size | static curl_off_t multipart_size(curl_mime *mime)
{
curl_off_t size;
curl_off_t boundarysize;
curl_mimepart *part;
if(!mime)
return 0; /* Not present -> empty. */
boundarysize = 4 + MIME_BOUNDARY_LEN + 2;
size = boundarysize; /* Final boundary - CRLF after headers. */
for(part = mime->fi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6701d
movq $0x0, -0x8(%rbp)
jmp 0x6708b
movq $0x34, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x67083
movq -0x28(%r... | /AraHaan[P]curl/lib/mime.c |
curl_mvsnprintf | int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format,
va_list ap_save)
{
int retcode;
struct nsprintf info;
info.buffer = buffer;
info.length = 0;
info.max = maxlength;
retcode = formatf(&info, addbyter, format, ap_save);
if(info.max) {
/* we terminate this with... | 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), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
le... | /AraHaan[P]curl/lib/mprintf.c |
addbyter | static int addbyter(unsigned char outc, void *f)
{
struct nsprintf *infop = f;
if(infop->length < infop->max) {
/* only do this if we have not reached max length yet */
*infop->buffer++ = (char)outc; /* store */
infop->length++; /* we are now one byte larger */
return 0; /* fputc() returns like ... | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x685c7
movb -0x5(%rbp), %cl
movq -0x18(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1... | /AraHaan[P]curl/lib/mprintf.c |
curl_mvaprintf | char *curl_mvaprintf(const char *format, va_list ap_save)
{
struct asprintf info;
struct dynbuf dyn;
info.b = &dyn;
Curl_dyn_init(info.b, DYN_APRINTF);
info.merr = MERR_OK;
(void)formatf(&info, alloc_addbyter, format, ap_save);
if(info.merr) {
Curl_dyn_free(info.b);
return NULL;
}
if(Curl_dyn... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x7a1200, %esi # imm = 0x7A1200
callq 0x35140
movb $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0xa... | /AraHaan[P]curl/lib/mprintf.c |
curl_maprintf | char *curl_maprintf(const char *format, ...)
{
va_list ap_save;
char *s;
va_start(ap_save, format);
s = curl_mvaprintf(format, ap_save);
va_end(ap_save);
return s;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x68838
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp... | /AraHaan[P]curl/lib/mprintf.c |
curl_msprintf | int curl_msprintf(char *buffer, const char *format, ...)
{
va_list ap_save; /* argument pointer */
int retcode;
va_start(ap_save, format);
retcode = formatf(&buffer, storebuffer, format, ap_save);
va_end(ap_save);
*buffer = 0; /* we terminate this with a zero byte */
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x688db
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp... | /AraHaan[P]curl/lib/mprintf.c |
curl_mfprintf | int curl_mfprintf(FILE *whereto, const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = formatf(whereto, fputc_wrapper, format, ap_save);
va_end(ap_save);
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x68ac8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp... | /AraHaan[P]curl/lib/mprintf.c |
mqtt_do | static CURLcode mqtt_do(struct Curl_easy *data, bool *done)
{
struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
CURLcode result = CURLE_OK;
*done = FALSE; /* unconditionally */
if(!mq)
return CURLE_FAILED_INIT;
mq->lastTime = Curl_now();
mq->pingsent = FALSE;
result = mqtt_connect(data);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5eabb(%rip), %rsi # 0xc8846
callq 0x37ae0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x69db5
movl $0x2, -0x4(%rbp)
jmp 0x69e3... | /AraHaan[P]curl/lib/mqtt.c |
mqtt_verify_connack | static CURLcode mqtt_verify_connack(struct Curl_easy *data)
{
struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
CURLcode result;
char *ptr;
DEBUGASSERT(mq);
if(!mq)
return CURLE_FAILED_INIT;
result = mqtt_recv_atleast(data, MQTT_CONNACK_LEN);
if(result)
goto fail;
/* verify CONNACK ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5d8ef(%rip), %rsi # 0xc8846
callq 0x37ae0
movq %rax, -0x18(%rbp)
jmp 0x6af62
cmpq $0x0, -0x18(%rbp)
jne 0x6af75
movl $0x2, -0x4(%rbp)
jmp 0x6b027
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6b870
movl %eax, -0x1c(%rb... | /AraHaan[P]curl/lib/mqtt.c |
curl_multi_add_handle | CURLMcode curl_multi_add_handle(CURLM *m, CURL *d)
{
CURLMcode rc;
struct Curl_multi *multi = m;
struct Curl_easy *data = d;
/* First, make some basic checks that the CURLM handle is a good handle */
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
/* Verify that we got a somewhat good easy handl... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6bfa3
movq -0x28(%rbp), %rax
cmpl $0xbab1e, (%rax) # imm = 0xBAB1E
je 0x6bfaf
movl $0x1, -0x4(%rbp)
jmp... | /AraHaan[P]curl/lib/multi.c |
curl_multi_cleanup | CURLMcode curl_multi_cleanup(CURLM *m)
{
struct Curl_multi *multi = m;
if(GOOD_MULTI_HANDLE(multi)) {
void *entry;
unsigned int mid;
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
/* First remove all remaining easy handles,
* close internal ones. admin handle is special */
i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6c628
movq -0x18(%rbp), %rax
cmpl $0xbab1e, (%rax) # imm = 0xBAB1E
jne 0x6c628
movq -0x18(%rbp), %rax
movb 0x271(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
c... | /AraHaan[P]curl/lib/multi.c |
Curl_update_timer | CURLMcode Curl_update_timer(struct Curl_multi *multi)
{
struct curltime expire_ts;
long timeout_ms;
int rc;
bool set_value = FALSE;
if(!multi->timer_cb || multi->dead)
return CURLM_OK;
if(multi_timeout(multi, &expire_ts, &timeout_ms)) {
return CURLM_OK;
}
if(timeout_ms < 0 && multi->last_timeo... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x2d(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x238(%rax)
je 0x6c835
movq -0x10(%rbp), %rax
movb 0x271(%rax), %al
shrb $0x4, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x6c841
movl $0x0, -0x4(%rbp)
jmp 0x6c971
movq -0x10(%rbp), %r... | /AraHaan[P]curl/lib/multi.c |
Curl_expire_clear | bool Curl_expire_clear(struct Curl_easy *data)
{
struct Curl_multi *multi = data->multi;
struct curltime *nowp = &data->state.expiretime;
/* this is only interesting while there is still an associated multi struct
remaining! */
if(!multi)
return FALSE;
if(nowp->tv_sec || nowp->tv_usec) {
/* Sin... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0xc00, %rax # imm = 0xC00
addq $0x190, %rax # imm = 0x190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6d1ac
movb $0x0, -0x1(%r... | /AraHaan[P]curl/lib/multi.c |
process_pending_handles | static void process_pending_handles(struct Curl_multi *multi)
{
unsigned int mid;
if(Curl_uint_bset_first(&multi->pending, &mid)) {
do {
struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
DEBUGASSERT(data);
if(data)
move_pending_to_connect(multi, data);
}
while(Curl_uint... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0x99fb0
testb $0x1, %al
jne 0x6d3b3
jmp 0x6d3f7
jmp 0x6d3b5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6e120
movq %rax, -0x18(%rbp)
jmp 0x6d3c7
cmpq $0x0, -0x18(%rbp)
je 0x6d3db
... | /AraHaan[P]curl/lib/multi.c |
Curl_attach_connection | void Curl_attach_connection(struct Curl_easy *data,
struct connectdata *conn)
{
DEBUGASSERT(data);
DEBUGASSERT(!data->conn);
DEBUGASSERT(conn);
data->conn = conn;
Curl_uint_spbset_add(&conn->xfers_attached, data->mid);
if(conn->handler && conn->handler->attach)
conn->handler-... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x6d452
jmp 0x6d454
jmp 0x6d456
jmp 0x6d458
jmp 0x6d45a
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
addq $0x410, %rdi # imm = 0x410
movq -0x8(%rbp), %rax
movl 0x10(%rax),... | /AraHaan[P]curl/lib/multi.c |
domore_getsock | static int domore_getsock(struct Curl_easy *data, curl_socket_t *socks)
{
struct connectdata *conn = data->conn;
if(!conn)
return GETSOCK_BLANK;
if(conn->handler->domore_getsock)
return conn->handler->domore_getsock(data, conn, socks);
else if(conn->sockfd != CURL_SOCKET_BAD) {
/* Default is that we... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6dd4c
movl $0x0, -0x4(%rbp)
jmp 0x6ddaf
movq -0x20(%rbp), %rax
movq 0x3e8(%rax), %rax
cmpq $0x0, 0x50(%rax)
je 0x6dd80
movq -0x20(%rb... | /AraHaan[P]curl/lib/multi.c |
curl_multi_fdset | CURLMcode curl_multi_fdset(CURLM *m,
fd_set *read_fd_set, fd_set *write_fd_set,
fd_set *exc_fd_set, int *max_fd)
{
/* Scan through all the easy handles to get the file descriptors set.
Some easy handles may not have connected to the remote host yet,
and ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x6df31
movq -0x40(%rbp), %rax
cmpl $0xba... | /AraHaan[P]curl/lib/multi.c |
curl_multi_waitfds | CURLMcode curl_multi_waitfds(CURLM *m,
struct curl_waitfd *ufds,
unsigned int size,
unsigned int *fd_count)
{
struct Curl_waitfds cwfds;
CURLMcode result = CURLM_OK;
struct Curl_multi *multi = m;
unsigned int need = 0, mid;
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6e270
cmpl $0x0, -0x1c(%rbp)
jne 0x6e264
cmpq $0x0, -0x28(%rbp)... | /AraHaan[P]curl/lib/multi.c |
move_pending_to_connect | static void move_pending_to_connect(struct Curl_multi *multi,
struct Curl_easy *data)
{
DEBUGASSERT(data->mstate == MSTATE_PENDING);
/* Remove this node from the pending set, add into process set */
Curl_uint_bset_remove(&multi->pending, data->mid);
Curl_uint_bset_add(&multi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x6fdb2
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x99ef0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x99e90
movq -0x10(%rbp), %rdi
... | /AraHaan[P]curl/lib/multi.c |
multi_xfer_bufs_free | static void multi_xfer_bufs_free(struct Curl_multi *multi)
{
DEBUGASSERT(multi);
Curl_safefree(multi->xfer_buf);
multi->xfer_buf_len = 0;
multi->xfer_buf_borrowed = FALSE;
Curl_safefree(multi->xfer_ulbuf);
multi->xfer_ulbuf_len = 0;
multi->xfer_ulbuf_borrowed = FALSE;
Curl_safefree(multi->xfer_sockbuf);... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x6ff4e
jmp 0x6ff50
leaq 0x7d381(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x100(%rax)
movq -0x8(%rbp), %rax
movb 0... | /AraHaan[P]curl/lib/multi.c |
curl_multi_info_read | CURLMsg *curl_multi_info_read(CURLM *m, int *msgs_in_queue)
{
struct Curl_message *msg;
struct Curl_multi *multi = m;
*msgs_in_queue = 0; /* default to none */
if(GOOD_MULTI_HANDLE(multi) &&
!multi->in_callback &&
Curl_llist_count(&multi->msglist)) {
/* there is one or more messages in the list ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x700f5
movq -0x28(%rbp), %rax
cmpl $0xbab1e, (%rax) # imm = 0xBAB1E
jne 0x700f5
movq -0x28(%rbp), %rax
movb 0... | /AraHaan[P]curl/lib/multi.c |
curl_multi_setopt | CURLMcode curl_multi_setopt(CURLM *m,
CURLMoption option, ...)
{
CURLMcode res = CURLM_OK;
va_list param;
unsigned long uarg;
struct Curl_multi *multi = m;
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
testb %al, %al
je 0x701fe
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(... | /AraHaan[P]curl/lib/multi.c |
Curl_expire_ex | void Curl_expire_ex(struct Curl_easy *data,
const struct curltime *nowp,
timediff_t milli, expire_id id)
{
struct Curl_multi *multi = data->multi;
struct curltime *curr_expire = &data->state.expiretime;
struct curltime set;
/* this is only interesting while there is stil... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0xc00, %rax # imm = 0xC00
addq $0x190, %rax # imm = 0x190
movq %rax,... | /AraHaan[P]curl/lib/multi.c |
multi_deltimeout | static void
multi_deltimeout(struct Curl_easy *data, expire_id eid)
{
struct Curl_llist_node *e;
struct Curl_llist *timeoutlist = &data->state.timeoutlist;
/* find and remove the specific node from the list */
for(e = Curl_llist_head(timeoutlist); e; e = Curl_node_next(e)) {
struct time_node *n = Curl_node_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0xc00, %rax # imm = 0xC00
addq $0x1d8, %rax # imm = 0x1D8
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x61a90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7114c
movq -0... | /AraHaan[P]curl/lib/multi.c |
curl_multi_get_handles | CURL **curl_multi_get_handles(CURLM *m)
{
struct Curl_multi *multi = m;
void *entry;
unsigned int count = Curl_uint_tbl_count(&multi->xfers);
CURL **a = malloc(sizeof(struct Curl_easy *) * (count + 1));
if(a) {
unsigned int i = 0, mid;
if(Curl_uint_tbl_first(&multi->xfers, &mid, &entry)) {
do {... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x9b170
movl %eax, -0x1c(%rbp)
leaq 0x7bee5(%rip), %rax # 0xed2d0
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl %ecx, %edi
shlq ... | /AraHaan[P]curl/lib/multi.c |
Curl_multi_xfer_ulbuf_borrow | CURLcode Curl_multi_xfer_ulbuf_borrow(struct Curl_easy *data,
char **pbuf, size_t *pbuflen)
{
DEBUGASSERT(data);
DEBUGASSERT(data->multi);
*pbuf = NULL;
*pbuflen = 0;
if(!data->multi) {
failf(data, "transfer has no multi handle");
return CURLE_FAILED_INIT;
}
i... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x71726
jmp 0x71728
jmp 0x7172a
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x71769
movq -0x10(%rbp), %rdi
leaq 0x57... | /AraHaan[P]curl/lib/multi.c |
multi_done_locked | static void multi_done_locked(struct connectdata *conn,
struct Curl_easy *data,
void *userdata)
{
struct multi_done_ctx *mdctx = userdata;
Curl_detach_connection(data);
CURL_TRC_M(data, "multi_done_locked, in use=%u",
Curl_uint_spbset_coun... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6d300
cmpq $0x0, -0x10(%rbp)
je 0x71c6f
movq -0x10(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x1e, %rax
andq $0x1, %rax
cmpl $0x0, %... | /AraHaan[P]curl/lib/multi.c |
state_resolving | static CURLMcode state_resolving(struct Curl_multi *multi,
struct Curl_easy *data,
bool *stream_errorp,
CURLcode *resultp)
{
struct Curl_dns_entry *dns = NULL;
CURLcode result;
CURLMcode rc = CURLM_OK;
result = C... | 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 $0x0, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4b560
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x72311
movq -0x18(%rbp), %ra... | /AraHaan[P]curl/lib/multi.c |
protocol_connecting | static CURLcode protocol_connecting(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
if(conn && conn->handler->connecting) {
*done = FALSE;
result = conn->handler->connecting(data, done);
}
else
*done = TRUE;
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x72521
movq -0x20(%rbp), %rax
movq 0x3e8(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x72521
movq -0x10(%rbp), %rax
movb ... | /AraHaan[P]curl/lib/multi.c |
state_ratelimiting | static CURLMcode state_ratelimiting(struct Curl_easy *data,
struct curltime *nowp,
CURLcode *resultp)
{
CURLcode result = CURLE_OK;
CURLMcode rc = CURLM_OK;
DEBUGASSERT(data->conn);
/* if both rates are within spec, resume transfer */
if(... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x729e4
movq -0x8(%rbp), %rdi
callq 0x798f0
cmpl $0x0, %eax
je 0x729fb
movl $0x2a, -0x1c(%rbp)
jmp 0x72a11
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (... | /AraHaan[P]curl/lib/multi.c |
multi_do | static CURLcode multi_do(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
DEBUGASSERT(conn);
DEBUGASSERT(conn->handler);
if(conn->handler->do_it)
result = conn->handler->do_it(data, done);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x730d5
jmp 0x730d7
jmp 0x730d9
movq -0x20(%rbp), %rax
movq 0x3e8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x73107
movq -0x20(%rbp), %rax
mov... | /AraHaan[P]curl/lib/multi.c |
multi_run_expired | static CURLMcode multi_run_expired(struct multi_run_ctx *mrc)
{
struct Curl_multi *multi = mrc->multi;
struct Curl_easy *data = NULL;
struct Curl_tree *t = NULL;
CURLMcode result = CURLM_OK;
/*
* The loop following here will go on as long as there are expire-times left
* to process (compared to mrc->no... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf0(%rcx), %rdx
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
leaq -0x20(%... | /AraHaan[P]curl/lib/multi.c |
mev_forget_socket | static CURLMcode mev_forget_socket(struct Curl_multi *multi,
struct Curl_easy *data,
curl_socket_t s,
const char *cause)
{
struct mev_sh_entry *entry = mev_sh_entry_get(&multi->ev.sh_entries, s);
int rc = 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x128, %rdi # imm = 0x128
movl -0x1c(%rbp), %esi
callq 0x734d0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x73638
... | /AraHaan[P]curl/lib/multi_ev.c |
mev_add_new_conn_pollset | static struct easy_pollset*
mev_add_new_conn_pollset(struct connectdata *conn)
{
struct easy_pollset *ps;
ps = calloc(1, sizeof(*ps));
if(!ps)
return NULL;
if(Curl_conn_meta_set(conn, CURL_META_MEV_POLLSET, ps, mev_pollset_dtor))
return NULL;
return ps;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
leaq 0x79923(%rip), %rax # 0xed2f0
callq *(%rax)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x739e4
movq $0x0, -0x8(%rbp)
jmp 0x73a16
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x557db(%rip), %rsi ... | /AraHaan[P]curl/lib/multi_ev.c |
mev_add_new_xfer_pollset | static struct easy_pollset*
mev_add_new_xfer_pollset(struct Curl_easy *data)
{
struct easy_pollset *ps;
ps = calloc(1, sizeof(*ps));
if(!ps)
return NULL;
if(Curl_meta_set(data, CURL_META_MEV_POLLSET, ps, mev_pollset_dtor))
return NULL;
return ps;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
leaq 0x798b3(%rip), %rax # 0xed2f0
callq *(%rax)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x73a54
movq $0x0, -0x8(%rbp)
jmp 0x73a86
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5576b(%rip), %rsi ... | /AraHaan[P]curl/lib/multi_ev.c |
mev_pollset_diff | static CURLMcode mev_pollset_diff(struct Curl_multi *multi,
struct Curl_easy *data,
struct connectdata *conn,
struct easy_pollset *ps,
struct easy_pollset *prev_ps)
{
struct mev_sh_e... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0x73ab1
jmp 0x73ab3
jmp 0x73ab5
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x73d9f
movb $0x0, -0x4a(%rbp)
... | /AraHaan[P]curl/lib/multi_ev.c |
mev_sh_entry_conn_add | static bool mev_sh_entry_conn_add(struct mev_sh_entry *e,
struct connectdata *conn)
{
/* detect weird values */
DEBUGASSERT(mev_sh_entry_user_count(e) < 100000);
DEBUGASSERT(!e->conn);
if(e->conn)
return FALSE;
e->conn = conn;
return TRUE;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x741de
jmp 0x741e0
jmp 0x741e2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x741f3
movb $0x0, -0x1(%rbp)
jmp 0x74203
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1,... | /AraHaan[P]curl/lib/multi_ev.c |
Curl_getdate_capped | time_t Curl_getdate_capped(const char *p)
{
time_t parsed = -1;
int rc = parsedate(p, &parsed);
switch(rc) {
case PARSEDATE_OK:
if(parsed == (time_t)-1)
/* avoid returning -1 for a working scenario */
parsed++;
return parsed;
case PARSEDATE_LATER:
/* this returns the maximum time valu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $-0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x75a90
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x7604a
jmp 0x76040
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x76067
jmp 0x7607... | /AraHaan[P]curl/lib/parsedate.c |
checkmonth | static int checkmonth(const char *check, size_t len)
{
int i;
const char * const *what = &Curl_month[0];
if(len != 3)
return -1; /* not a month */
for(i = 0; i < 12; i++) {
if(strncasecompare(check, what[0], 3))
return i;
what++;
}
return -1; /* return the offset or -1, no real offset is ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x74689(%rip), %rax # 0xea900
movq %rax, -0x28(%rbp)
cmpq $0x3, -0x18(%rbp)
je 0x7628b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x762d8
movl $0x0, -0x1c(%rbp)
cmpl $0xc, -0x1c(%rbp)
jge 0x762d1
movq -0x10(%rbp)... | /AraHaan[P]curl/lib/parsedate.c |
checktz | static int checktz(const char *check, size_t len)
{
unsigned int i;
const struct tzinfo *what = tz;
if(len > 4) /* longer than any valid timezone */
return -1;
for(i = 0; i < CURL_ARRAYSIZE(tz); i++) {
size_t ilen = strlen(what->name);
if((ilen == len) &&
strncasecompare(check, what->name, l... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x53169(%rip), %rax # 0xc9470
movq %rax, -0x28(%rbp)
cmpq $0x4, -0x18(%rbp)
jbe 0x7631b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x76383
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x45, %rax
jae 0x7637... | /AraHaan[P]curl/lib/parsedate.c |
Curl_pp_statemach | CURLcode Curl_pp_statemach(struct Curl_easy *data,
struct pingpong *pp, bool block,
bool disconnecting)
{
struct connectdata *conn = data->conn;
curl_socket_t sock = conn->sock[FIRSTSOCKET];
int rc;
timediff_t interval_ms;
timediff_t timeout_ms = Curl_pp_s... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x270(%rax), %eax
movl %eax, -0x... | /AraHaan[P]curl/lib/pingpong.c |
Curl_pp_init | void Curl_pp_init(struct pingpong *pp)
{
DEBUGASSERT(!pp->initialised);
pp->nread_resp = 0;
pp->response = Curl_now(); /* start response time-out now! */
pp->pending_resp = TRUE;
Curl_dyn_init(&pp->sendbuf, DYN_PINGPPONG_CMD);
Curl_dyn_init(&pp->recvbuf, DYN_PINGPPONG_CMD);
pp->initialised = TRUE;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x7697e
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x97950
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movl %edx, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%r... | /AraHaan[P]curl/lib/pingpong.c |
Curl_pp_vsendf | CURLcode Curl_pp_vsendf(struct Curl_easy *data,
struct pingpong *pp,
const char *fmt,
va_list args)
{
size_t bytes_written = 0;
size_t write_len;
char *s;
CURLcode result;
struct connectdata *conn = data->conn;
#ifdef HAVE_GSSAPI
enum ... | 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, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x76a3e
jmp 0x76a40
jmp 0x76a42
jmp 0x76a44
jmp 0x76a46
cmpq $0x0, -0x50(%rbp)
jne 0x76a5... | /AraHaan[P]curl/lib/pingpong.c |
Curl_pp_getsock | int Curl_pp_getsock(struct Curl_easy *data,
struct pingpong *pp, curl_socket_t *socks)
{
struct connectdata *conn = data->conn;
socks[0] = conn->sock[FIRSTSOCKET];
if(pp->sendleft) {
/* write mode */
return GETSOCK_WRITESOCK(0);
}
/* read mode */
return GETSOCK_READSOCK(0);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x270(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x770a0
movl $0x10000... | /AraHaan[P]curl/lib/pingpong.c |
Curl_pp_flushsend | CURLcode Curl_pp_flushsend(struct Curl_easy *data,
struct pingpong *pp)
{
/* we have a piece of a command still left to send */
size_t written;
CURLcode result;
if(!Curl_pp_needs_flush(data, pp))
return CURLE_OK;
result = Curl_conn_send(data, FIRSTSOCKET,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x770b0
testb $0x1, %al
jne 0x770fd
movl $0x0, -0x4(%rbp)
jmp 0x771d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
addq 0x18(%rax), %... | /AraHaan[P]curl/lib/pingpong.c |
pop3_multi_statemach | static CURLcode pop3_multi_statemach(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct pop3_conn *pop3c = &conn->proto.pop3c;
result = Curl_pp_statemach(data, &pop3c->pp, FALSE, FALSE);
*done = (pop3c->state == POP3_STOP);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %e... | /AraHaan[P]curl/lib/pop3.c |
pop3_disconnect | static CURLcode pop3_disconnect(struct Curl_easy *data,
struct connectdata *conn, bool dead_connection)
{
struct pop3_conn *pop3c = &conn->proto.pop3c;
(void)data;
/* We cannot send quit unconditionally. If this connection is stale or
bad in any way, sending quit and waiting ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x77669
movq -0x10(%rbp), %rax
movq 0x3e0(%rax), %rax
shrq $0xd... | /AraHaan[P]curl/lib/pop3.c |
pop3_state_servergreet_resp | static CURLcode pop3_state_servergreet_resp(struct Curl_easy *data,
int pop3code,
pop3state instate)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct pop3_conn *pop3c = &conn->proto.pop3c;
const ch... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq... | /AraHaan[P]curl/lib/pop3.c |
pop3_state_starttls_resp | static CURLcode pop3_state_starttls_resp(struct Curl_easy *data,
struct connectdata *conn,
int pop3code,
pop3state instate)
{
CURLcode result = CURLE_OK;
(void)instate; /* no use for this yet *... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x785f8
movl $0x8, -0x4(%rbp)
jmp 0x78650
cmpl $0x2b, -0x1c(%rbp)
je 0x7863c
movq -0x10(%r... | /AraHaan[P]curl/lib/pop3.c |
pop3_state_apop_resp | static CURLcode pop3_state_apop_resp(struct Curl_easy *data, int pop3code,
pop3state instate)
{
CURLcode result = CURLE_OK;
(void)instate; /* no use for this yet */
if(pop3code != '+') {
failf(data, "Authentication failed: %d", pop3code);
result = CURLE_LOGIN_DENIED;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2b, -0xc(%rbp)
je 0x787bd
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x51109(%rip), %rsi # 0xc98b6
movb $0x0, %al
callq 0x2f5c0
movl $0x43, -0x14(%rbp)
jmp 0x787c8
movq... | /AraHaan[P]curl/lib/pop3.c |
pop3_state_pass_resp | static CURLcode pop3_state_pass_resp(struct Curl_easy *data, int pop3code,
pop3state instate)
{
CURLcode result = CURLE_OK;
(void)instate; /* no use for this yet */
if(pop3code != '+') {
failf(data, "Access denied. %c", pop3code);
result = CURLE_LOGIN_DENIED;
}
el... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2b, -0xc(%rbp)
je 0x788ed
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x4f359(%rip), %rsi # 0xc7c36
movb $0x0, %al
callq 0x2f5c0
movl $0x43, -0x14(%rbp)
jmp 0x788f8
movq... | /AraHaan[P]curl/lib/pop3.c |
pop3_perform_capa | static CURLcode pop3_perform_capa(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct pop3_conn *pop3c = &conn->proto.pop3c;
pop3c->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanisms yet */
pop3c->sasl.authused = SASL_AUTH_NONE; /... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movw $0x0, 0xd0(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0xd4(%rax)
movq -0x20(%rbp), %rax
movb 0... | /AraHaan[P]curl/lib/pop3.c |
pop3_perform_apop | static CURLcode pop3_perform_apop(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct pop3_conn *pop3c = &conn->proto.pop3c;
size_t i;
struct MD5_context *ctxt;
unsigned char digest[MD5_DIGEST_LEN];
char secret[2 * MD5_DIGEST_LEN + 1];
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1390(%rax)
jne 0x78d7c
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x77fd0
movl -... | /AraHaan[P]curl/lib/pop3.c |
pop3_perform_auth | static CURLcode pop3_perform_auth(struct Curl_easy *data,
const char *mech,
const struct bufref *initresp)
{
CURLcode result = CURLE_OK;
struct pop3_conn *pop3c = &data->conn->proto.pop3c;
const char *ir = (const char *) Curl_bufref_ptr(initresp)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15ea0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x3... | /AraHaan[P]curl/lib/pop3.c |
pop3_parse_custom_request | static CURLcode pop3_parse_custom_request(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct POP3 *pop3 = data->req.p.pop3;
const char *custom = data->set.str[STRING_CUSTOMREQUEST];
/* URL decode the custom request */
if(custom)
result = Curl_urldecode(custom, 0, &pop3->custom, NULL, REJECT_CTR... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x7b8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x792e9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x10, %rdx... | /AraHaan[P]curl/lib/pop3.c |
pop3_perform_command | static CURLcode pop3_perform_command(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct POP3 *pop3 = data->req.p.pop3;
const char *command = NULL;
/* Calculate the default command */
if(pop3->id[0] == '\0' || data->set.list_only) {
command = "LIST";
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0,... | /AraHaan[P]curl/lib/pop3.c |
pop3_is_multiline | static bool pop3_is_multiline(const char *cmdline)
{
size_t i;
for(i = 0; i < CURL_ARRAYSIZE(pop3cmds); ++i) {
if(strncasecompare(pop3cmds[i].name, cmdline, pop3cmds[i].nlen)) {
if(!cmdline[pop3cmds[i].nlen])
return pop3cmds[i].multiline;
else if(cmdline[pop3cmds[i].nlen] == ' ')
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x12, -0x18(%rbp)
jae 0x79708
movq -0x18(%rbp), %rcx
leaq 0x714f6(%rip), %rax # 0xeab20
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq 0x714dd(%rip), %rax # 0xeab... | /AraHaan[P]curl/lib/pop3.c |
pop3_init | static CURLcode pop3_init(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct POP3 *pop3;
pop3 = data->req.p.pop3 = calloc(1, sizeof(struct POP3));
if(!pop3)
result = CURLE_OUT_OF_MEMORY;
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, %edi
movl $0x18, %esi
leaq 0x73acc(%rip), %rax # 0xed2f0
callq *(%rax)
movq -0x8(%rbp), %rcx
movq %rax, 0x180(%rcx)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x79843
movl $0x1b, -0xc(%rbp)
movl -0xc(%rbp), %ea... | /AraHaan[P]curl/lib/pop3.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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xbf8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x97950
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movl %edx, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0xb18(%rax)
movq -0x10(%rbp), %... | /AraHaan[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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
addq $0xa50, %rax # imm = 0xA50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
movq 0xc8(%rax), %rdx
movl 0... | /AraHaan[P]curl/lib/progress.c |
randit | static CURLcode randit(struct Curl_easy *data, unsigned int *rnd,
bool env_override)
{
#ifdef DEBUGBUILD
if(env_override) {
char *force_entropy = getenv("CURL_ENTROPY");
if(force_entropy) {
static unsigned int randseed;
static bool seeded = FALSE;
if(!seeded) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0xbb000
addq $0x20, %rsp
popq %rbp
retq
nop
| /AraHaan[P]curl/lib/rand.c |
Curl_rand_hex | CURLcode Curl_rand_hex(struct Curl_easy *data, unsigned char *rnd,
size_t num)
{
CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
unsigned char buffer[128];
DEBUGASSERT(num > 1);
#ifdef __clang_analyzer__
/* This silences a scan-build warning about accessing this buffer with
uninitial... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x2b, -0x24(%rbp)
jmp 0x7b0e0
movq -0x20(%rbp), %rax
shrq %rax
cmpq $0x80, %rax
jae 0x7b0fd
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x7b10a
jmp 0x7b0ff
jmp 0x7b101
movl $0x2b, -0x4(%... | /AraHaan[P]curl/lib/rand.c |
Curl_rand_alnum | CURLcode Curl_rand_alnum(struct Curl_easy *data, unsigned char *rnd,
size_t num)
{
CURLcode result = CURLE_OK;
const unsigned int alnumspace = sizeof(alnum) - 1;
unsigned int r;
DEBUGASSERT(num > 1);
num--; /* save one for null-termination */
while(num) {
do {
result = r... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x3e, -0x28(%rbp)
jmp 0x7b194
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7b20d
jmp 0x7b1a9
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp)... | /AraHaan[P]curl/lib/rand.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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x106f0
leaq 0x71b01(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xc8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0xc8(%rax)
jmp ... | /AraHaan[P]curl/lib/request.c |
Curl_req_free | void Curl_req_free(struct SingleRequest *req, struct Curl_easy *data)
{
/* 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);
if(req->sendbuf_init)
Curl_bufq_free(&req->sendbuf);
Curl_client_cleanup(da... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x717d1(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xc8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0xc8(%rax)
jmp 0x7bb28
leaq 0x717a9(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq ... | /AraHaan[P]curl/lib/request.c |
Curl_req_want_send | bool Curl_req_want_send(struct Curl_easy *data)
{
/* Not done and
* - KEEP_SEND and not PAUSEd.
* - or request has buffered data to send
* - or transfer connection has pending data to send */
return !data->req.done &&
(((data->req.keepon & KEEP_SENDBITS) == KEEP_SEND) ||
!Curl_req_sendb... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x189(%rax), %ecx
shrl %ecx
andl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jne 0x7c075
movq -0x8(%rbp), %rax
movl 0x104(%rax), %ecx
andl $0x2a, %ecx
movb $0x1, %al
cmpl $0x2, %ecx
movb %al, -0xa(%rbp)
je 0... | /AraHaan[P]curl/lib/request.c |
Curl_req_abort_sending | CURLcode Curl_req_abort_sending(struct Curl_easy *data)
{
if(!data->req.upload_done) {
Curl_bufq_reset(&data->req.sendbuf);
data->req.upload_aborted = TRUE;
/* no longer KEEP_SEND and KEEP_SEND_PAUSE */
data->req.keepon &= ~KEEP_SENDBITS;
return req_set_upload_done(data);
}
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x189(%rax), %eax
shrl $0x8, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x7c1c2
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
addq $0x68, %rdi
callq 0x14950
movq -0x10(%rbp), %rax
movl 0x189(%rax), %ecx
andl $0xfffffdff, %ecx #... | /AraHaan[P]curl/lib/request.c |
req_set_upload_done | static CURLcode req_set_upload_done(struct Curl_easy *data)
{
DEBUGASSERT(!data->req.upload_done);
data->req.upload_done = TRUE;
data->req.keepon &= ~(KEEP_SEND|KEEP_SEND_TIMED); /* we are done sending */
Curl_pgrsTime(data, TIMER_POSTRANSFER);
Curl_creader_done(data, data->req.upload_aborted);
if(data->r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x7c1ee
movq -0x8(%rbp), %rax
movl 0x189(%rax), %ecx
andl $0xfffffeff, %ecx # imm = 0xFFFFFEFF
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x189(%rax)
movq -0x8(%rbp), %rax
movl 0x104(%rax), %ecx
andl $-0x43, %ecx
movl %ecx, 0x104(%rax... | /AraHaan[P]curl/lib/request.c |
rtsp_setup_connection | static CURLcode rtsp_setup_connection(struct Curl_easy *data,
struct connectdata *conn)
{
struct rtsp_conn *rtspc = &conn->proto.rtspc;
struct RTSP *rtsp;
(void)conn;
if(!rtspc->initialised) {
Curl_dyn_init(&rtspc->buf, MAX_RTP_BUFFERSIZE);
rtspc->initialised = TRU... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x34(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7c5df
movq -0x20(%rbp), %rdi
movl ... | /AraHaan[P]curl/lib/rtsp.c |
Curl_rtsp_parseheader | CURLcode Curl_rtsp_parseheader(struct Curl_easy *data, const char *header)
{
if(checkprefix("CSeq:", header)) {
curl_off_t CSeq = 0;
struct RTSP *rtsp = data->req.p.rtsp;
const char *p = &header[5];
Curl_str_passblanks(&p);
if(Curl_str_number(&p, &CSeq, LONG_MAX)) {
failf(data, "Unable to re... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4c2fa(%rip), %rsi # 0xc9c35
movl $0x5, %edx
callq 0x105e0
cmpl $0x0, %eax
je 0x7d9d8
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %... | /AraHaan[P]curl/lib/rtsp.c |
rtsp_parse_transport | static
CURLcode rtsp_parse_transport(struct Curl_easy *data, const char *transport)
{
/* If we receive multiple Transport response-headers, the linterleaved
channels of each response header is recorded and used together for
subsequent data validity checks.*/
/* e.g.: ' RTP/AVP/TCP;unicast;interleaved=5-6'... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x51(%rbp)
je 0x7dbb4
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
... | /AraHaan[P]curl/lib/rtsp.c |
Curl_wait_ms | int Curl_wait_ms(timediff_t timeout_ms)
{
int r = 0;
if(!timeout_ms)
return 0;
if(timeout_ms < 0) {
SET_SOCKERRNO(SOCKEINVAL);
return -1;
}
#if defined(MSDOS)
delay((unsigned int)timeout_ms);
#elif defined(_WIN32)
/* prevent overflow, timeout_ms is typecast to ULONG/DWORD. */
#if TIMEDIFF_T_MAX... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7e5c3
movl $0x0, -0x4(%rbp)
jmp 0x7e630
cmpq $0x0, -0x10(%rbp)
jge 0x7e5de
callq 0x100c0
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7e630
movq -0x10(%rbp), %rsi
leaq -0x28... | /AraHaan[P]curl/lib/select.c |
Curl_socket_check | int Curl_socket_check(curl_socket_t readfd0, /* two sockets to read from */
curl_socket_t readfd1,
curl_socket_t writefd, /* socket to write to */
timediff_t timeout_ms) /* milliseconds to wait */
{
struct pollfd pfd[3];
int num;
int r;
if((read... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $-0x1, -0x8(%rbp)
jne 0x7e678
cmpl $-0x1, -0xc(%rbp)
jne 0x7e678
cmpl $-0x1, -0x10(%rbp)
jne 0x7e678
movq -0x18(%rbp), %rdi
callq 0x7e5a0
movl %eax, -0x4(%rbp)
jmp 0x7e80b
movl $0x0... | /AraHaan[P]curl/lib/select.c |
Curl_poll | int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
{
#ifdef HAVE_POLL
int pending_ms;
#else
fd_set fds_read;
fd_set fds_write;
fd_set fds_err;
curl_socket_t maxfd;
#endif
bool fds_none = TRUE;
unsigned int i;
int r;
if(ufds) {
for(i = 0; i < nfds; i++) {
if(ufds[i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x1, -0x25(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7e86f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x7e86d
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,... | /AraHaan[P]curl/lib/select.c |
cpfds_increase | static CURLcode cpfds_increase(struct curl_pollfds *cpfds, unsigned int inc)
{
struct pollfd *new_fds;
unsigned int new_count = cpfds->count + inc;
new_fds = calloc(new_count, sizeof(struct pollfd));
if(!new_fds)
return CURLE_OUT_OF_MEMORY;
memcpy(new_fds, cpfds->pfds, cpfds->count * sizeof(struct pollf... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq 0x6e47d(%rip), %rax # 0xed2f0
movq (%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edi
movl $0x8, %esi
callq *%rax
movq %rax, -0x20... | /AraHaan[P]curl/lib/select.c |
Curl_client_write | CURLcode Curl_client_write(struct Curl_easy *data,
int type, const char *buf, size_t blen)
{
CURLcode result;
/* it is one of those, at least */
DEBUGASSERT(type & (CLIENTWRITE_BODY|CLIENTWRITE_HEADER|CLIENTWRITE_INFO));
/* BODY is only BODY (with optional EOS) */
DEBUGASSERT(!(typ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0x7ef29
jmp 0x7ef2b
jmp 0x7ef2d
jmp 0x7ef2f
jmp 0x7ef31
movq -0x10(%rbp), %rax
cmpq $0x0, 0x110(%rax)
jne 0x7ef62
movq -0x10(%rbp), %rdi
callq 0x7f000
movl %eax, -0x2c(%rbp)
cmpl $... | /AraHaan[P]curl/lib/sendf.c |
do_init_writer_stack | static CURLcode do_init_writer_stack(struct Curl_easy *data)
{
struct Curl_cwriter *writer;
CURLcode result;
DEBUGASSERT(!data->req.writer_stack);
result = Curl_cwriter_create(&data->req.writer_stack,
data, &Curl_cwt_out, CURL_CW_CLIENT);
if(result)
return result;
/* Thi... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x7f00e
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
leaq 0x68cb8(%rip), %rdx # 0xe7ce0
movl $0x4, %ecx
callq 0x7f630
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7f046
movl -0x1c(%rbp), %eax
movl %eax, -... | /AraHaan[P]curl/lib/sendf.c |
Curl_client_start | CURLcode Curl_client_start(struct Curl_easy *data)
{
if(data->req.rewind_read) {
struct Curl_creader *r = data->req.reader_stack;
CURLcode result = CURLE_OK;
CURL_TRC_READ(data, "client start, rewind readers");
while(r) {
result = r->crt->rewind(data, r);
if(result) {
failf(data, ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x189(%rax), %eax
shrl $0x7, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7f548
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7f4c8
movq -0x10(%rbp), %rax... | /AraHaan[P]curl/lib/sendf.c |
Curl_cwriter_create | CURLcode Curl_cwriter_create(struct Curl_cwriter **pwriter,
struct Curl_easy *data,
const struct Curl_cwtype *cwt,
Curl_cwriter_phase phase)
{
struct Curl_cwriter *writer = NULL;
CURLcode result = CURLE_OUT_OF_M... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x1b, -0x2c(%rbp)
jmp 0x7f658
leaq 0x6dc91(%rip), %rax # 0xed2f0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rsi
movl $0x1, %edi
callq *%... | /AraHaan[P]curl/lib/sendf.c |
Curl_cwriter_add | CURLcode Curl_cwriter_add(struct Curl_easy *data,
struct Curl_cwriter *writer)
{
CURLcode result;
struct Curl_cwriter **anchor = &data->req.writer_stack;
if(!*anchor) {
result = do_init_writer_stack(data);
if(result)
return result;
}
/* Insert the writer as first in i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0xb8, %rax
addq $0x58, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7f7f8
movq -0x10(%rbp), %rdi
callq 0x7f000
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7f7f6
mov... | /AraHaan[P]curl/lib/sendf.c |
do_init_reader_stack | static CURLcode do_init_reader_stack(struct Curl_easy *data,
struct Curl_creader *r)
{
CURLcode result = CURLE_OK;
curl_off_t clen;
DEBUGASSERT(r);
DEBUGASSERT(r->crt);
DEBUGASSERT(r->phase == CURL_CR_CLIENT);
DEBUGASSERT(!data->req.reader_stack);
data->req.reader_st... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
jmp 0x7fe09
jmp 0x7fe0b
jmp 0x7fe0d
jmp 0x7fe0f
jmp 0x7fe11
jmp 0x7fe13
jmp 0x7fe15
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x28(%ra... | /AraHaan[P]curl/lib/sendf.c |
Curl_creader_set | CURLcode Curl_creader_set(struct Curl_easy *data, struct Curl_creader *r)
{
CURLcode result;
DEBUGASSERT(r);
DEBUGASSERT(r->crt);
DEBUGASSERT(r->phase == CURL_CR_CLIENT);
cl_reset_reader(data);
result = do_init_reader_stack(data, r);
if(result)
Curl_creader_free(data, r);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x7ff72
jmp 0x7ff74
jmp 0x7ff76
jmp 0x7ff78
jmp 0x7ff7a
movq -0x8(%rbp), %rdi
callq 0x7f210
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7fdf0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x7ffa6
movq -0x8(%rbp), %r... | /AraHaan[P]curl/lib/sendf.c |
Curl_client_read | CURLcode Curl_client_read(struct Curl_easy *data, char *buf, size_t blen,
size_t *nread, bool *eos)
{
CURLcode result;
DEBUGASSERT(buf);
DEBUGASSERT(blen);
DEBUGASSERT(nread);
DEBUGASSERT(eos);
if(!data->req.reader_stack) {
result = Curl_creader_set_fread(data, data->state.in... | 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)
jmp 0x7ffce
jmp 0x7ffd0
jmp 0x7ffd2
jmp 0x7ffd4
jmp 0x7ffd6
jmp 0x7ffd8
jmp 0x7ffda
movq -0x10(%rbp), %rax
cmpq $0x0, 0x118(%rax)
jne 0x80016
movq -0x10(%rbp), %r... | /AraHaan[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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x80189
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
testb $0x1, %al
jne 0x80111
j... | /AraHaan[P]curl/lib/sendf.c |
Curl_creader_set_null | CURLcode Curl_creader_set_null(struct Curl_easy *data)
{
struct Curl_creader *r;
CURLcode result;
result = Curl_creader_create(&r, data, &cr_null, CURL_CR_CLIENT);
if(result)
return result;
cl_reset_reader(data);
return do_init_reader_stack(data, r);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
leaq 0x6ab85(%rip), %rdx # 0xead40
movl $0x4, %ecx
callq 0x7fbf0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x801d6
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x801ef
movq -0x10(%rbp), %rdi
c... | /AraHaan[P]curl/lib/sendf.c |
Curl_creader_set_buf | CURLcode Curl_creader_set_buf(struct Curl_easy *data,
const char *buf, size_t blen)
{
CURLcode result;
struct Curl_creader *r;
struct cr_buf_ctx *ctx;
result = Curl_creader_create(&r, data, &cr_buf, CURL_CR_CLIENT);
if(result)
goto out;
ctx = r->ctx;
ctx->buf = buf;
c... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq 0x6ab7d(%rip), %rdx # 0xeada0
movl $0x4, %ecx
callq 0x7fbf0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x80238
jmp 0x80281
movq -0x28(%rbp), %rax
mo... | /AraHaan[P]curl/lib/sendf.c |
Curl_creader_client_length | curl_off_t Curl_creader_client_length(struct Curl_easy *data)
{
struct Curl_creader *r = data->req.reader_stack;
while(r && r->phase != CURL_CR_CLIENT)
r = r->next;
return r ? r->crt->total_length(data, r) : -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x80395
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al... | /AraHaan[P]curl/lib/sendf.c |
Curl_creader_unpause | CURLcode Curl_creader_unpause(struct Curl_easy *data)
{
struct Curl_creader *reader = data->req.reader_stack;
CURLcode result = CURLE_OK;
while(reader) {
result = reader->crt->unpause(data, reader);
if(result)
break;
reader = reader->next;
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x804d7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax... | /AraHaan[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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x50(%rbp)
movl -0x1c(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
xorb ... | /AraHaan[P]curl/lib/sendf.c |
cr_in_resume_from | static CURLcode cr_in_resume_from(struct Curl_easy *data,
struct Curl_creader *reader,
curl_off_t offset)
{
struct cr_in_ctx *ctx = reader->ctx;
int seekerr = CURL_SEEKFUNC_CANTSEEK;
DEBUGASSERT(data->conn);
/* already started reading? */
if... | pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp # imm = 0x1060
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x2, -0x2c(%rbp)
jmp 0x811dc
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x811f3
movl $0x1a, -0x4(%rbp... | /AraHaan[P]curl/lib/sendf.c |
cr_lc_read | static CURLcode cr_lc_read(struct Curl_easy *data,
struct Curl_creader *reader,
char *buf, size_t blen,
size_t *pnread, bool *peos)
{
struct cr_lc_ctx *ctx = reader->ctx;
CURLcode result;
size_t nread, i, start, n;
bool eos;
if(... | 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 %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb 0x60(%rax), %al
shrb %al
andb $0x1, %al
movz... | /AraHaan[P]curl/lib/sendf.c |
cr_null_read | static CURLcode cr_null_read(struct Curl_easy *data,
struct Curl_creader *reader,
char *buf, size_t blen,
size_t *pnread, bool *peos)
{
(void)data;
(void)reader;
(void)buf;
(void)blen;
*pnread = 0;
*peos = TRUE;
return ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /AraHaan[P]curl/lib/sendf.c |
httpauth | static CURLcode httpauth(struct Curl_easy *data, bool proxy,
unsigned long auth)
{
if(auth != CURLAUTH_NONE) {
int bitcheck = 0;
bool authbits = FALSE;
/* the DIGEST_IE bit is only used to set a special marker, for all the
rest we need to handle it as normal DIGEST */
b... | pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8751a
movl $0x0, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
movq -0x20(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
mo... | /AraHaan[P]curl/lib/setopt.c |
protocol2num | static CURLcode protocol2num(const char *str, curl_prot_t *val)
{
/*
* We are asked to cherry-pick protocols, so play it safe and disallow all
* protocols to start with, and re-add the wanted ones back in.
*/
*val = 0;
if(!str)
return CURLE_BAD_FUNCTION_ARGUMENT;
if(curl_strequal(str, "all")) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x8772d
movl $0x2b, -0x4(%rbp)
jmp 0x87826
movq -0x10(%rbp), %rdi
leaq 0x3b704(%rip), %rsi # 0xc2e3c
callq 0x11780
cmpl $0x0, %eax
je 0x87758
movq -0x18(%rbp)... | /AraHaan[P]curl/lib/setopt.c |
curl_share_setopt | CURLSHcode
curl_share_setopt(CURLSH *sh, CURLSHoption option, ...)
{
va_list param;
int type;
curl_lock_function lockfunc;
curl_unlock_function unlockfunc;
void *ptr;
CURLSHcode res = CURLSHE_OK;
struct Curl_share *share = sh;
if(!GOOD_SHARE_HANDLE(share))
return CURLSHE_INVALID;
if(share->dirty... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
testb %al, %al
je 0x87aa1
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/share.c |
curl_share_cleanup | CURLSHcode
curl_share_cleanup(CURLSH *sh)
{
struct Curl_share *share = sh;
if(!GOOD_SHARE_HANDLE(share))
return CURLSHE_INVALID;
if(share->lockfunc)
share->lockfunc(NULL, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE,
share->clientdata);
if(share->dirty) {
if(share->unlockfunc)... | 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 0x87ff7
movq -0x18(%rbp), %rax
cmpl $0x7e117a1e, (%rax) # imm = 0x7E117A1E
je 0x88003
movl $0x3, -0x4(%rbp)
jmp 0x88149
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8802e
m... | /AraHaan[P]curl/lib/share.c |
curl_slist_append | struct curl_slist *curl_slist_append(struct curl_slist *list,
const char *data)
{
char *dupdata = strdup(data);
if(!dupdata)
return NULL;
list = Curl_slist_append_nodup(list, dupdata);
if(!list)
free(dupdata);
return list;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x64f81(%rip), %rax # 0xed2e8
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x88385
movq $0x0, -0x8(%rbp)
jmp 0x883b5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
... | /AraHaan[P]curl/lib/slist.c |
curl_slist_free_all | void curl_slist_free_all(struct curl_slist *list)
{
struct curl_slist *next;
struct curl_slist *item;
if(!list)
return;
item = list;
do {
next = item->next;
Curl_safefree(item->data);
free(item);
item = next;
} while(next);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x88455
jmp 0x884a6
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x64e68(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rd... | /AraHaan[P]curl/lib/slist.c |
smb_connect | static CURLcode smb_connect(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
struct smb_conn *smbc = &conn->proto.smbc;
char *slash;
(void) done;
/* Check we have a username and password to authenticate with */
if(!data->state.aptr.user)
return CURLE_LOGIN_DENIED;
/* Ini... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1390(%rax)
jne 0x885a4
movl $0x43, -0... | /AraHaan[P]curl/lib/smb.c |
smb_request_state | static CURLcode smb_request_state(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
struct smb_request *req = data->req.p.smb;
struct smb_header *h;
struct smb_conn *smbc = &conn->proto.smbc;
enum smb_req_state next_state = SMB_DONE;
unsigned short len;
unsigned short off;
CUR... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x38(%rbp)
movl... | /AraHaan[P]curl/lib/smb.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.