name string | code string | asm string | file string |
|---|---|---|---|
ftp_regular_transfer | static
CURLcode ftp_regular_transfer(struct Curl_easy *data,
bool *dophase_done)
{
CURLcode result = CURLE_OK;
bool connected = FALSE;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
data->req.size = -1; /* make sure this is unknown at this point... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, -0x1d(%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/ftp.c |
ftp_quit | static CURLcode ftp_quit(struct Curl_easy *data, struct connectdata *conn)
{
CURLcode result = CURLE_OK;
if(conn->proto.ftpc.ctl_valid) {
CURL_TRC_FTP(data, "sending QUIT to close session");
result = Curl_pp_sendf(data, &conn->proto.ftpc.pp, "%s", "QUIT");
if(result) {
failf(data, "Failure sendin... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb 0x58a(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x44dea
jmp 0x44ce4
cmpq $0x0, -0x10(%rbp)
je 0x44d41
movq -0x10(%rbp), %rax
movq 0xa2c(%rax), %... | /AraHaan[P]curl/lib/ftp.c |
ftp_block_statemach | static CURLcode ftp_block_statemach(struct Curl_easy *data,
struct connectdata *conn)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
CURLcode result = CURLE_OK;
while(ftpc->state != FTP_STOP) {
if(ftpc->shutdown)
CURL_TRC_FTP(data, "i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10e(%rax), %eax
cmpl $0x0, %eax
je 0x44ed... | /AraHaan[P]curl/lib/ftp.c |
ftp_pl_insert_finfo | static CURLcode ftp_pl_insert_finfo(struct Curl_easy *data,
struct fileinfo *infop)
{
curl_fnmatch_callback compare;
struct WildcardData *wc = data->wildcard;
struct ftp_wc *ftpwc = wc->ftpwc;
struct Curl_llist *llist = &wc->filelist;
struct ftp_parselist_data *parser = ftp... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x13c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%r... | /AraHaan[P]curl/lib/ftplistparser.c |
GetEnv | static char *GetEnv(const char *variable)
{
#if defined(CURL_WINDOWS_UWP) || defined(UNDER_CE) || \
defined(__ORBIS__) || defined(__PROSPERO__) /* PlayStation 4 and 5 */
(void)variable;
return NULL;
#elif defined(_WIN32)
/* This uses Windows API instead of C runtime getenv() to get the environment
variable... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10fd0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x46cf2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x46cf2
leaq 0xa6605(%rip), %rax # 0xed2e8
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax... | /AraHaan[P]curl/lib/getenv.c |
getinfo_char | static CURLcode getinfo_char(struct Curl_easy *data, CURLINFO info,
const char **param_charp)
{
switch(info) {
case CURLINFO_EFFECTIVE_URL:
*param_charp = data->state.url ? data->state.url : "";
break;
case CURLINFO_EFFECTIVE_METHOD: {
const char *m = data->set.str[STRING_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0xffefffff, %eax # imm = 0xFFEFFFFF
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3d, %eax
ja 0x475b5
movq -0x30(%rbp), %rax
leaq 0x7e6ff(%rip), %rcx # 0xc5ad0
movslq (%rcx,%rax,4), %r... | /AraHaan[P]curl/lib/getinfo.c |
gopher_do | static CURLcode gopher_do(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
char *gopherpath;
char *path = data->state.up.path;
char *query = data->state.up.query;
char *sel = NULL;
char *sel_org = NUL... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x270(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x1218(%rax), %rax
movq %rax, -0x40(%rbp)
... | /AraHaan[P]curl/lib/gopher.c |
Curl_hash_add2 | void *Curl_hash_add2(struct Curl_hash *h, void *key, size_t key_len, void *p,
Curl_hash_elem_dtor dtor)
{
struct Curl_hash_element *he, **slot;
DEBUGASSERT(h);
DEBUGASSERT(h->slots);
DEBUGASSERT(h->init == HASHINIT);
if(!h->table) {
h->table = calloc(h->slots, sizeof(struct Curl_hash... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0x483de
jmp 0x483e0
jmp 0x483e2
jmp 0x483e4
jmp 0x483e6
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4842c
leaq 0xa4ef9(%rip), %rax # 0xed2f0
movq (%rax... | /AraHaan[P]curl/lib/hash.c |
Curl_hash_pick | void *
Curl_hash_pick(struct Curl_hash *h, void *key, size_t key_len)
{
DEBUGASSERT(h);
DEBUGASSERT(h->init == HASHINIT);
if(h->table) {
struct Curl_hash_element *he;
DEBUGASSERT(h->slots);
he = CURL_HASH_SLOT(h, key, key_len);
while(he) {
if(h->comp_func(he->key, he->key_len, key, key_len))... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x48836
jmp 0x48838
jmp 0x4883a
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x488cc
jmp 0x4884a
jmp 0x4884c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8... | /AraHaan[P]curl/lib/hash.c |
Curl_hash_destroy | void
Curl_hash_destroy(struct Curl_hash *h)
{
DEBUGASSERT(h->init == HASHINIT);
if(h->table) {
Curl_hash_clean(h);
Curl_safefree(h->table);
}
DEBUGASSERT(h->size == 0);
h->slots = 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x488ee
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x48921
movq -0x8(%rbp), %rdi
callq 0x48940
leaq 0xa49d0(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x... | /AraHaan[P]curl/lib/hash.c |
Curl_hash_clean | void Curl_hash_clean(struct Curl_hash *h)
{
if(h && h->table) {
struct Curl_hash_element *he, **he_anchor;
size_t i;
DEBUGASSERT(h->init == HASHINIT);
for(i = 0; i < h->slots; ++i) {
he_anchor = &h->table[i];
while(*he_anchor) {
he = *he_anchor;
hash_elem_unlink(h, he_ancho... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x489d8
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x489d8
jmp 0x48963
jmp 0x48965
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x489d6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq... | /AraHaan[P]curl/lib/hash.c |
Curl_hash_str | size_t Curl_hash_str(void *key, size_t key_length, size_t slots_num)
{
const char *key_str = (const char *) key;
const char *end = key_str + key_length;
size_t h = 5381;
while(key_str < end) {
size_t j = (size_t)*key_str++;
h += h << 5;
h ^= j;
}
return (h % slots_num);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x1505, -0x30(%rbp) # imm = 0x1505
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x48b4b
movq -0x2... | /AraHaan[P]curl/lib/hash.c |
Curl_hash_start_iterate | void Curl_hash_start_iterate(struct Curl_hash *hash,
struct Curl_hash_iterator *iter)
{
DEBUGASSERT(hash->init == HASHINIT);
iter->hash = hash;
iter->slot_index = 0;
iter->current = NULL;
#ifdef DEBUGBUILD
iter->init = ITERINIT;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x48bce
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /AraHaan[P]curl/lib/hash.c |
curl_easy_header | CURLHcode curl_easy_header(CURL *easy,
const char *name,
size_t nameindex,
unsigned int type,
int request,
struct curl_header **hout)
{
struct Curl_llist_node *e;
struct Curl_llist_... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
m... | /AraHaan[P]curl/lib/headers.c |
copy_header_external | static void copy_header_external(struct Curl_header_store *hs,
size_t index,
size_t amount,
struct Curl_llist_node *e,
struct curl_header *hout)
{
struct curl_header *h = hout;
h->name... | 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 -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq ... | /AraHaan[P]curl/lib/headers.c |
curl_easy_nextheader | struct curl_header *curl_easy_nextheader(CURL *easy,
unsigned int type,
int request,
struct curl_header *prev)
{
struct Curl_easy *data = easy;
struct Curl_llist_node *pick;
struct Curl_llist... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movl -0x18(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc70(%rcx), %eax
jle 0x4904a
movq $0x0, ... | /AraHaan[P]curl/lib/headers.c |
Curl_headers_push | CURLcode Curl_headers_push(struct Curl_easy *data, const char *header,
unsigned char type)
{
char *value = NULL;
char *name = NULL;
char *end;
size_t hlen; /* length of the incoming header */
struct Curl_header_store *hs;
CURLcode result = CURLE_OUT_OF_MEMORY;
if((header[0] == ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x1b, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x49244
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, ... | /AraHaan[P]curl/lib/headers.c |
Curl_headers_init | CURLcode Curl_headers_init(struct Curl_easy *data)
{
struct Curl_cwriter *writer;
CURLcode result;
if(data->conn && (data->conn->handler->protocol & PROTO_FAMILY_HTTP)) {
/* avoid installing it twice */
if(Curl_cwriter_get_by_name(data, hds_cw_collect.name))
return CURLE_OK;
result = Curl_cwri... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x49870
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x3e8(%rax), %rax
movl 0x94(%rax), %eax
andl $0xc0000003, %eax # imm = 0xC0000003
cmpl $0x0, %eax
je 0x49870
movq -0x10(%rbp), %rdi
movq 0xa0... | /AraHaan[P]curl/lib/headers.c |
Curl_headers_cleanup | CURLcode Curl_headers_cleanup(struct Curl_easy *data)
{
struct Curl_llist_node *e;
struct Curl_llist_node *n;
for(e = Curl_llist_head(&data->state.httphdrs); e; e = n) {
struct Curl_header_store *hs = Curl_node_elem(e);
n = Curl_node_next(e);
free(hs);
}
headers_reset(data);
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc00, %rdi # imm = 0xC00
addq $0x678, %rdi # imm = 0x678
callq 0x61a90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x498e2
movq -0x10(%rbp), %rdi
callq 0x61ad0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp... | /AraHaan[P]curl/lib/headers.c |
Curl_HMAC_init | struct HMAC_context *
Curl_HMAC_init(const struct HMAC_params *hashparams,
const unsigned char *key,
unsigned int keylen)
{
size_t i;
struct HMAC_context *ctxt;
unsigned char *hkey;
unsigned char b;
/* Create HMAC context. */
i = sizeof(*ctxt) + 2 * hashparams->ctxtsize + hash... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
shll %eax
movl %eax, %eax
addq $0x18, %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
leaq 0xa3819(%rip), %rax # 0xed... | /AraHaan[P]curl/lib/hmac.c |
Curl_dnscache_prune | void Curl_dnscache_prune(struct Curl_easy *data)
{
struct Curl_dnscache *dnscache = dnscache_get(data);
time_t now;
/* the timeout may be set -1 (forever) */
int timeout = data->set.dns_cache_timeout;
if(!dnscache)
/* NULL hostcache means we cannot do it */
return;
dnscache_lock(data, dnscache);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49f90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x688(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x49eff
jmp 0x49f7d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4a000
xorl %eax, %eax
movl ... | /AraHaan[P]curl/lib/hostip.c |
Curl_dnscache_get | struct Curl_dns_entry *
Curl_dnscache_get(struct Curl_easy *data,
const char *hostname,
int port,
int ip_version)
{
struct Curl_dnscache *dnscache = dnscache_get(data);
struct Curl_dns_entry *dns = NULL;
dnscache_lock(data, dnscache);
dns = fetch_addr(data... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49f90
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4a000
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi... | /AraHaan[P]curl/lib/hostip.c |
Curl_shuffle_addr | UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
struct Curl_addrinfo **addr)
{
CURLcode result = CURLE_OK;
const int num_addrs = num_addresses(*addr);
if(num_addrs > 1) {
struct Curl_addrinfo **nodes;
infof(data, "Shuffling %i addresses", num_addrs);
n... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4c4a0
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jle 0x4a807
jmp 0x4a5d2
cmpq $0x0, -0x8(%rbp)
je 0x4a625
movq -0x8(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq ... | /AraHaan[P]curl/lib/hostip.c |
Curl_dnscache_add | CURLcode Curl_dnscache_add(struct Curl_easy *data,
struct Curl_dns_entry *entry)
{
struct Curl_dnscache *dnscache = dnscache_get(data);
char id[MAX_HOSTCACHE_LEN];
size_t idlen;
if(!dnscache)
return CURLE_FAILED_INIT;
/* Create an entry id, based upon the hostname and port */
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49f90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4a843
movl $0x2, -0x4(%rbp)
jmp 0x4a8db
movq -0x18(%rbp), %rdi
addq $0x1c, %rdi
movq -0x18(%rbp), %rax
movl 0x18(%r... | /AraHaan[P]curl/lib/hostip.c |
create_dnscache_id | static size_t
create_dnscache_id(const char *name,
size_t nlen, /* 0 or actual name length */
int port, char *ptr, size_t buflen)
{
size_t len = nlen ? nlen : strlen(name);
DEBUGASSERT(buflen >= MAX_HOSTCACHE_LEN);
if(len > (buflen - 7))
len = buflen - 7;
/* store and l... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4a91c
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4a929
movq -0x8(%rbp), %rdi
callq 0x10540
movq %rax, -0x38(%rbp)
movq -0x38(%... | /AraHaan[P]curl/lib/hostip.c |
Curl_ipv6works | bool Curl_ipv6works(struct Curl_easy *data)
{
if(data) {
/* the nature of most system is that IPv6 status does not come and go
during a program's lifetime so we only probe the first time and then we
have the info kept for fast reuse */
DEBUGASSERT(data);
DEBUGASSERT(data->multi);
if(data... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4aa0c
jmp 0x4a9a5
jmp 0x4a9a7
jmp 0x4a9a9
jmp 0x4a9ab
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movzbl 0x270(%rax), %eax
cmpl $0x0, %eax
jne 0x4a9f0
xorl %eax, %eax
movl %eax, %edi
callq 0x4a990
andb $0x1, %al
movb %al, -0... | /AraHaan[P]curl/lib/hostip.c |
Curl_host_is_ipnum | bool Curl_host_is_ipnum(const char *hostname)
{
struct in_addr in;
#ifdef USE_IPV6
struct in6_addr in6;
#endif
if(curlx_inet_pton(AF_INET, hostname, &in) > 0
#ifdef USE_IPV6
|| curlx_inet_pton(AF_INET6, hostname, &in6) > 0
#endif
)
return TRUE;
return FALSE;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x2, %edi
leaq -0x14(%rbp), %rdx
callq 0x117c0
cmpl $0x0, %eax
jg 0x4aa9a
movq -0x10(%rbp), %rsi
movl $0xa, %edi
leaq -0x24(%rbp), %rdx
callq 0x117c0
cmpl $0x0, %eax
jle 0x4aaa0
movb $0x1, -0x1(%rbp)
jmp 0x4aaa4
movb $0x0, -... | /AraHaan[P]curl/lib/hostip.c |
Curl_resolv_check | CURLcode Curl_resolv_check(struct Curl_easy *data,
struct Curl_dns_entry **dns)
{
CURLcode result;
/* If async resolving is ongoing, this must be set */
if(!data->state.async.hostname)
return CURLE_FAILED_INIT;
/* check if we have the name resolved by now (from someone else) */
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd48(%rax)
jne 0x4b58a
movl $0x2, -0x4(%rbp)
jmp 0x4b6c1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xd48(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xd50(%rax), %edx
movq -0x10(%rbp), %rax
... | /AraHaan[P]curl/lib/hostip.c |
Curl_resolv_timeout | CURLcode Curl_resolv_timeout(struct Curl_easy *data,
const char *hostname,
int port,
int ip_version,
struct Curl_dns_entry **entry,
timediff_t timeoutms)
{
#ifdef USE_ALARM_TI... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x30(%rbp)
jge 0x4b859
movl $0x1c, -0x4(%rbp)
jmp 0x4b87f
movq -0x10(%rbp), %rdi
movq -... | /AraHaan[P]curl/lib/hostip.c |
dnscache_entry_free | static void dnscache_entry_free(struct Curl_dns_entry *dns)
{
Curl_freeaddrinfo(dns->addr);
#ifdef USE_HTTPSRR
if(dns->hinfo) {
Curl_httpsrr_cleanup(dns->hinfo);
free(dns->hinfo);
}
#endif
free(dns);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2c810
leaq 0xa1a29(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
| /AraHaan[P]curl/lib/hostip.c |
Curl_loadhostpairs | CURLcode Curl_loadhostpairs(struct Curl_easy *data)
{
struct Curl_dnscache *dnscache = dnscache_get(data);
struct curl_slist *hostp;
if(!dnscache)
return CURLE_FAILED_INIT;
/* Default is no wildcard found */
data->state.wildcard_resolve = FALSE;
for(hostp = data->state.resolve; hostp; hostp = hostp->... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49f90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b98f
movl $0x2, -0x4(%rbp)
jmp 0x4c154
movq -0x10(%rbp), %rax
movl 0x13be(%rax), %ecx
andl $0xfffbffff, %ecx # imm = 0xFFFBFFFF
orl... | /AraHaan[P]curl/lib/hostip.c |
hsts_out | static CURLcode hsts_out(struct stsentry *sts, FILE *fp)
{
struct tm stamp;
if(sts->expires != TIME_T_MAX) {
CURLcode result = Curl_gmtime((time_t)sts->expires, &stamp);
if(result)
return result;
fprintf(fp, "%s%s \"%d%02d%02d %02d:%02d:%02d\"\n",
sts->includeSubDomains ? ".": "", sts-... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x28(%rax)
je 0x4d00d
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x58(%rbp), %rsi
callq 0x76090
movl %eax, -0x5c(%rb... | /AraHaan[P]curl/lib/hsts.c |
hsts_load | static CURLcode hsts_load(struct hsts *h, const char *file)
{
CURLcode result = CURLE_OK;
FILE *fp;
/* we need a private copy of the filename so that the hsts cache file
name survives an easy handle reset */
free(h->filename);
h->filename = strdup(file);
if(!h->filename)
return CURLE_OUT_OF_MEMORY... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0xa00ca(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
leaq 0xa00c6(%rip), %rax # 0xed2e8
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
m... | /AraHaan[P]curl/lib/hsts.c |
Curl_http | CURLcode Curl_http(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
CURLcode result = CURLE_OK;
Curl_HttpReq httpreq;
const char *te = ""; /* transfer-encoding */
const char *request;
const char *httpstring;
struct dynbuf req;
char *altused = NULL;
const char *p_accept; ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
leaq 0x81d48(%rip), %rax # 0xcf4de
movq %rax, -0x58(%r... | /AraHaan[P]curl/lib/http.c |
Curl_http_write_resp | CURLcode Curl_http_write_resp(struct Curl_easy *data,
const char *buf, size_t blen,
bool is_eos)
{
CURLcode result;
size_t consumed;
int flags;
result = Curl_http_write_resp_hds(data, buf, blen, &consumed);
if(result || data->req.done)
goto out;... | 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)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x52ec0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x... | /AraHaan[P]curl/lib/http.c |
pickoneauth | static bool pickoneauth(struct auth *pick, unsigned long mask)
{
bool picked;
/* only deal with authentication we want */
unsigned long avail = pick->avail & pick->want & mask;
picked = TRUE;
/* The order of these checks is highly relevant, as this will be the order
of preference in case of the existenc... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
andq (%rcx), %rax
andq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x20(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x4f686
movq -0x8(%rbp), %rax
movq $0... | /AraHaan[P]curl/lib/http.c |
http_should_fail | static bool http_should_fail(struct Curl_easy *data, int httpcode)
{
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
/*
** If we have not been asked to fail on error,
** do not fail.
*/
if(!data->set.http_fail_on_error)
return FALSE;
/*
** Any code < 400 is never terminal.
*/
if(httpcode < 400)
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
jmp 0x4fa7d
jmp 0x4fa7f
jmp 0x4fa81
movq -0x10(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x16, %rax
andq $0x1, %rax
cmpl $0x0, %eax
jne 0x4faa2
movb $0x0, -0x1(%rbp)
jmp 0x4fb60
cmpl $0x190, -0x14(%rbp) # imm = 0x190
jge 0x4fab4
movb $0x0, -0x1... | /AraHaan[P]curl/lib/http.c |
Curl_http_output_auth | CURLcode
Curl_http_output_auth(struct Curl_easy *data,
struct connectdata *conn,
const char *request,
Curl_HttpReq httpreq,
const char *path,
bool proxytunnel) /* TRUE if this is the request setting
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movl $0x0, -0x38(%rbp)
jmp 0x4fb9c
movq -0x10(%rbp), %rax
addq $0xc00, %rax # imm = 0xC00
addq $0xf... | /AraHaan[P]curl/lib/http.c |
auth_basic | static CURLcode auth_basic(struct Curl_easy *data,
struct auth *authp,
unsigned long *availp)
{
*availp |= CURLAUTH_BASIC;
authp->avail |= CURLAUTH_BASIC;
if(authp->picked == CURLAUTH_BASIC) {
/* We asked for Basic authentication but got a 40X back
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
orq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x50... | /AraHaan[P]curl/lib/http.c |
Curl_compareheader | bool
Curl_compareheader(const char *headerline, /* line to check */
const char *header, /* header keyword _with_ colon */
const size_t hlen, /* len of the keyword in bytes */
const char *content, /* content string to find */
const size_t cle... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0x5098e
jmp 0x50990
jmp 0x50992
jmp 0x50994
jmp 0x50996
jmp 0x50998
jmp 0x5099a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1... | /AraHaan[P]curl/lib/http.c |
Curl_http_method | void Curl_http_method(struct Curl_easy *data, struct connectdata *conn,
const char **method, Curl_HttpReq *reqp)
{
Curl_HttpReq httpreq = (Curl_HttpReq)data->state.httpreq;
const char *request;
if((conn->handler->protocol&(PROTO_FAMILY_HTTP|CURLPROTO_FTP)) &&
data->state.upload)
htt... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x13bc(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
movl 0x94(%rax), %eax
andl $0xc0000007, %eax # imm = 0xC0000007
cmpl $0x0, %eax... | /AraHaan[P]curl/lib/http.c |
http_target | static CURLcode http_target(struct Curl_easy *data,
struct connectdata *conn,
struct dynbuf *r)
{
CURLcode result = CURLE_OK;
const char *path = data->state.up.path;
const char *query = data->state.up.query;
if(data->set.str[STRING_TARGET]) {
path = d... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x1218(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x1220(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8c8(%rax... | /AraHaan[P]curl/lib/http.c |
http_req_complete | static CURLcode http_req_complete(struct Curl_easy *data,
struct dynbuf *r, int httpversion,
Curl_HttpReq httpreq)
{
CURLcode result = CURLE_OK;
curl_off_t req_clen;
bool announced_exp100 = FALSE;
DEBUGASSERT(data->conn);
if(data->req.upload... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movb $0x0, -0x31(%rbp)
jmp 0x524a3
movq -0x10(%rbp), %rax
movl 0x189(%rax), %eax
shrl $0xf, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x524d7
movq -0x10(%rbp), %rd... | /AraHaan[P]curl/lib/http.c |
http_parse_headers | static CURLcode http_parse_headers(struct Curl_easy *data,
const char *buf, size_t blen,
size_t *pconsumed)
{
struct connectdata *conn = data->conn;
CURLcode result = CURLE_OK;
struct SingleRequest *k = &data->req;
char *end_ptr;
bool lefto... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x49(%rbp)
movq -0... | /AraHaan[P]curl/lib/http.c |
Curl_http_req_make | CURLcode Curl_http_req_make(struct httpreq **preq,
const char *method, size_t m_len,
const char *scheme, size_t s_len,
const char *authority, size_t a_len,
const char *path, size_t p_len)
{
struct httpreq *... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x1b, -0x3c(%rbp)
jmp 0x53535
leaq 0x99db4(%rip), %rax # 0xed2f0
... | /AraHaan[P]curl/lib/http.c |
req_assign_url_path | static CURLcode req_assign_url_path(struct httpreq *req, CURLU *url)
{
char *path, *query;
struct dynbuf buf;
CURLUcode uc;
CURLcode result = CURLE_URL_MALFORMAT;
path = query = NULL;
Curl_dyn_init(&buf, DYN_HTTP_REQUEST);
uc = curl_url_get(url, CURLUPART_PATH, &path, CURLU_PATH_AS_IS);
if(uc)
got... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3, -0x48(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x100000, %esi # imm = 0x100000
callq 0x35140
movq -0x10(%rbp), %rdi
movl $0x7, %esi
leaq -0x18(%rbp), %rdx
movl $0x10, %ecx
... | /AraHaan[P]curl/lib/http.c |
http_TE_has_token | static bool http_TE_has_token(const char *fvalue, const char *token)
{
while(*fvalue) {
struct Curl_str name;
/* skip to first token */
while(ISBLANK(*fvalue) || *fvalue == ',')
fvalue++;
if(Curl_str_cspn(&fvalue, &name, " \t\r;,"))
return FALSE;
if(Curl_str_casecompare(&name, token))... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5415c
jmp 0x5406f
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x39(%rbp)
je 0x540a1
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
... | /AraHaan[P]curl/lib/http.c |
h2_permissible_field | static bool h2_permissible_field(struct dynhds_entry *e)
{
size_t i;
for(i = 0; i < CURL_ARRAYSIZE(H2_NON_FIELD); ++i) {
if(e->namelen < H2_NON_FIELD[i].namelen)
return TRUE;
if(e->namelen == H2_NON_FIELD[i].namelen &&
strcasecompare(H2_NON_FIELD[i].name, e->name))
return FALSE;
}
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x6, -0x18(%rbp)
jae 0x54214
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdx
leaq 0x9915e(%rip), %rcx # 0xed300
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jae 0x541b5
movb $0x1, -0x1(%rbp)
j... | /AraHaan[P]curl/lib/http.c |
set_reader | static CURLcode set_reader(struct Curl_easy *data, Curl_HttpReq httpreq)
{
CURLcode result = CURLE_OK;
curl_off_t postsize = data->state.infilesize;
DEBUGASSERT(data->conn);
if(data->req.authneg) {
return Curl_creader_set_null(data);
}
switch(httpreq) {
case HTTPREQ_PUT: /* Let's PUT the data to th... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x11c8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x546d7
movq -0x10(%rbp), %rax
movl 0x189(%rax), %eax
shrl $0x12, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x546fd
movq -0x10(%rbp), %... | /AraHaan[P]curl/lib/http.c |
http_header | static CURLcode http_header(struct Curl_easy *data,
const char *hd, size_t hdlen)
{
struct connectdata *conn = data->conn;
CURLcode result;
struct SingleRequest *k = &data->req;
const char *v;
switch(hd[0]) {
case 'a':
case 'A':
#ifndef CURL_DISABLE_ALTSVC
v = (data->asi &... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
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 -0x10(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $-... | /AraHaan[P]curl/lib/http.c |
Curl_h1_req_parse_read | ssize_t Curl_h1_req_parse_read(struct h1_req_parser *parser,
const char *buf, size_t buflen,
const char *scheme_default, int options,
CURLcode *err)
{
ssize_t nread = 0, n;
*err = CURLE_OK;
while(!parser->done) {
n =... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movb 0x48(%rax), %al
andb $0x1, %al
movzbl %al, %eax
c... | /AraHaan[P]curl/lib/http1.c |
start_req | static CURLcode start_req(struct h1_req_parser *parser,
const char *scheme_default, int options)
{
const char *p, *m, *target, *hv, *scheme, *authority, *path;
size_t m_len, target_len, hv_len, scheme_len, authority_len, path_len;
size_t i;
CURLU *url = NULL;
CURLcode result = CURLE... | pushq %rbp
movq %rsp, %rbp
subq $0x20c0, %rsp # imm = 0x20C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x90(%rbp)
movl $0x3, -0x94(%rbp)
jmp 0x57d5d
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
movl $0x20, %esi
callq 0x10e70
movq... | /AraHaan[P]curl/lib/http1.c |
detect_line | static ssize_t detect_line(struct h1_req_parser *parser,
const char *buf, const size_t buflen,
CURLcode *err)
{
const char *line_end;
DEBUGASSERT(!parser->line);
line_end = memchr(buf, '\n', buflen);
if(!line_end) {
*err = CURLE_AGAIN;
return -1;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0x5822a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xa, %esi
callq 0x10e70
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5825b
movq -0x28(%rbp), %rax
movl $0x51, (%r... | /AraHaan[P]curl/lib/http1.c |
parse_content_sha_hdr | static const char *parse_content_sha_hdr(struct Curl_easy *data,
const char *provider1,
size_t plen,
size_t *value_len)
{
char key[CONTENT_SHA256_KEY_LEN];
size_t key_len;
const char *value;
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %r8
movl $0x52, %esi
leaq 0x6e1bd(%rip), %rdx # 0xc73f2
movb $0x0, %al
callq 0x106d0
cltq
movq %rax,... | /AraHaan[P]curl/lib/http_aws_sigv4.c |
calc_payload_hash | static CURLcode calc_payload_hash(struct Curl_easy *data,
unsigned char *sha_hash, char *sha_hex)
{
const char *post_data = data->set.postfields;
size_t post_data_len = 0;
CURLcode result;
if(post_data) {
if(data->set.postfieldsize < 0)
post_data_len = strlen(post_da... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1d8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x59510
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1e8(%rax)
jge 0x594ff
movq -0x20(%rbp), %rdi
cal... | /AraHaan[P]curl/lib/http_aws_sigv4.c |
canon_query | static CURLcode canon_query(struct Curl_easy *data,
const char *query, struct dynbuf *dq)
{
CURLcode result = CURLE_OK;
int entry = 0;
int i;
const char *p = query;
struct pair array[MAX_QUERYPAIRS];
struct pair *ap = &array[0];
if(!query)
return result;
/* sort the name... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x440(%rbp), %rax
movq %rax, -0x448(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x59d1d
movl -... | /AraHaan[P]curl/lib/http_aws_sigv4.c |
trim_headers | static void trim_headers(struct curl_slist *head)
{
struct curl_slist *l;
for(l = head; l; l = l->next) {
const char *value; /* to read from */
char *store;
size_t colon = strcspn(l->data, ":");
Curl_strntolower(l->data, l->data, colon);
value = &l->data[colon];
if(!*value)
continue;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5a35e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x7648b(%rip), %rsi # 0xd06d8
callq 0x10150
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp),... | /AraHaan[P]curl/lib/http_aws_sigv4.c |
merge_duplicate_headers | static CURLcode merge_duplicate_headers(struct curl_slist *head)
{
struct curl_slist *curr = head;
CURLcode result = CURLE_OK;
while(curr) {
struct curl_slist *next = curr->next;
if(!next)
break;
if(compare_header_names(curr->data, next->data) == 0) {
struct dynbuf buf;
char *colon... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5a642
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5a51e
jmp 0x5a642
movq -0x18(%rbp), %rax
movq (%rax), ... | /AraHaan[P]curl/lib/http_aws_sigv4.c |
compare_func | static int compare_func(const void *a, const void *b)
{
const struct pair *aa = a;
const struct pair *bb = b;
/* If one element is empty, the other is always sorted higher */
if(aa->len == 0 && bb->len == 0)
return 0;
if(aa->len == 0)
return -1;
if(bb->len == 0)
return 1;
return strncmp(aa->p,... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5a69f
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5a69f
movl $0x0, -0x4(%rbp)
jmp ... | /AraHaan[P]curl/lib/http_aws_sigv4.c |
Curl_httpchunk_reset | void Curl_httpchunk_reset(struct Curl_easy *data, struct Curl_chunker *ch,
bool ignore_body)
{
(void)data;
ch->hexindex = 0; /* start at 0 */
ch->state = CHUNK_HEX; /* we get hex first! */
ch->last_code = CHUNKE_OK;
Curl_dyn_reset(&ch->trailer);
ch->ignore_body = ignore_body;
... | 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
movb $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0... | /AraHaan[P]curl/lib/http_chunks.c |
Curl_httpchunk_add_reader | CURLcode Curl_httpchunk_add_reader(struct Curl_easy *data)
{
struct Curl_creader *reader = NULL;
CURLcode result;
result = Curl_creader_create(&reader, data, &Curl_httpchunk_encoder,
CURL_CR_TRANSFER_ENCODE);
if(!result)
result = Curl_creader_add(data, reader);
if(result &... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
leaq 0x8ec8d(%rip), %rdx # 0xea330
movl $0x1, %ecx
callq 0x7fbf0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x5b6c6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7fea0
... | /AraHaan[P]curl/lib/http_chunks.c |
add_last_chunk | static CURLcode add_last_chunk(struct Curl_easy *data,
struct Curl_creader *reader)
{
struct chunked_reader *ctx = reader->ctx;
struct curl_slist *trailers = NULL, *tr;
CURLcode result;
size_t n;
int rc;
if(!data->set.trailer_callback) {
CURL_TRC_READ(data, "http_chunk, a... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa08(%rax)
jne 0x5ba9c
jmp 0x5ba18
cmpq $0x0, -0x10(%rbp)
je 0x5ba75
movq -0x10(%rbp), %rax
movq 0xa2c(%... | /AraHaan[P]curl/lib/http_chunks.c |
Curl_http_proxy_get_destination | CURLcode Curl_http_proxy_get_destination(struct Curl_cfilter *cf,
const char **phostname,
int *pport, bool *pipv6_ip)
{
DEBUGASSERT(cf);
DEBUGASSERT(cf->conn);
if(cf->conn->bits.conn_to_host)
*phostname = cf->conn->conn_to_host... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x5c85a
jmp 0x5c85c
jmp 0x5c85e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x3e0(%rax), %rax
shrq $0x8, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x5c892
movq -0x8(%rbp), %rax
m... | /AraHaan[P]curl/lib/http_proxy.c |
Curl_ipv6_scope | unsigned int Curl_ipv6_scope(const struct sockaddr *sa)
{
if(sa->sa_family == AF_INET6) {
const struct sockaddr_in6 * sa6 =
(const struct sockaddr_in6 *)(const void *) sa;
const unsigned char *b = sa6->sin6_addr.s6_addr;
unsigned short w = (unsigned short) ((b[0] << 8) | b[1]);
if((b[0] & 0xFE)... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xa, %eax
jne 0x5d939
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x... | /AraHaan[P]curl/lib/if2ip.c |
imap_do | static CURLcode imap_do(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
*done = FALSE; /* default to false */
/* Parse the URL path */
result = imap_parse_url_path(data);
if(result)
return result;
/* Parse the custom request */
result = imap_parse_custom_request(data);
if(result)... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x607e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x5db98
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5dbc8
movq -0x10(%rbp... | /AraHaan[P]curl/lib/imap.c |
imap_disconnect | static CURLcode imap_disconnect(struct Curl_easy *data,
struct connectdata *conn, bool dead_connection)
{
struct imap_conn *imapc = &conn->proto.imapc;
(void)data;
if(imapc->initialised) {
/* We cannot send quit unconditionally. If this connection is stale or
bad in any... | 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)
movq -0x20(%rbp), %rax
movb 0xfb(%rax), %al
shrb $0x5, %al
andb $0x1, %al
movzbl %al, %eax
... | /AraHaan[P]curl/lib/imap.c |
imap_statemachine | static CURLcode imap_statemachine(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
int imapcode;
struct imap_conn *imapc = &conn->proto.imapc;
struct pingpong *pp = &imapc->pp;
size_t nread = 0;
(void)data;
/* Busy upgrading the connection;... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, 0xf0(%rax)
jne ... | /AraHaan[P]curl/lib/imap.c |
imap_endofresp | static bool imap_endofresp(struct Curl_easy *data, struct connectdata *conn,
const char *line, size_t len, int *resp)
{
struct IMAP *imap = data->req.p.imap;
struct imap_conn *imapc = &conn->proto.imapc;
const char *id = imapc->resptag;
size_t id_len = strlen(id);
/* Do we have a t... | 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 -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x40(%rbp)
movq... | /AraHaan[P]curl/lib/imap.c |
imap_state | static void imap_state(struct Curl_easy *data, imapstate newstate)
{
struct imap_conn *imapc = &data->conn->proto.imapc;
#if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
/* for debug purposes */
static const char * const names[]={
"STOP",
"SERVERGREET",
"CAPABILITY",
"STARTTLS",
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xf0(%rax)
popq %rbp
retq
nopl (%rax)
| /AraHaan[P]curl/lib/imap.c |
imap_state_servergreet_resp | static CURLcode imap_state_servergreet_resp(struct Curl_easy *data,
int imapcode,
imapstate instate)
{
struct connectdata *conn = data->conn;
(void)instate; /* no use for this yet */
if(imapcode == IMAP_RESP_PREAUTH) {
/*... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, -0x14(%rbp)
jne 0x5ec5c
movq -0x20(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x28(%rbp)
movq -0x28(%rbp... | /AraHaan[P]curl/lib/imap.c |
imap_state_starttls_resp | static CURLcode imap_state_starttls_resp(struct Curl_easy *data,
int imapcode,
imapstate instate)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
(void)instate; /* no use for this yet */
/* Pipelining in res... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %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 -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x5f060
movl $0x8, -0x4(%rbp)
jmp 0x5f0b8
cmp... | /AraHaan[P]curl/lib/imap.c |
imap_state_select_resp | static CURLcode imap_state_select_resp(struct Curl_easy *data, int imapcode,
imapstate instate)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct IMAP *imap = data->req.p.imap;
struct imap_conn *imapc = &conn->proto.imapc;
const char *line = Cur... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %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 -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x478, %rax ... | /AraHaan[P]curl/lib/imap.c |
imap_state_fetch_final_resp | static CURLcode imap_state_fetch_final_resp(struct Curl_easy *data,
int imapcode,
imapstate instate)
{
CURLcode result = CURLE_OK;
(void)instate; /* No use for this yet */
if(imapcode != IMAP_RESP_OK)
result = CURLE_WEIR... | 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 $0x1, -0xc(%rbp)
je 0x5f8b8
movl $0x8, -0x14(%rbp)
jmp 0x5f8c3
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5ead0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)... | /AraHaan[P]curl/lib/imap.c |
imap_state_append_final_resp | static CURLcode imap_state_append_final_resp(struct Curl_easy *data,
int imapcode,
imapstate instate)
{
CURLcode result = CURLE_OK;
(void)instate; /* No use for this yet */
if(imapcode != IMAP_RESP_OK)
result = CURLE_U... | 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 $0x1, -0xc(%rbp)
je 0x5f968
movl $0x19, -0x14(%rbp)
jmp 0x5f973
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5ead0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax... | /AraHaan[P]curl/lib/imap.c |
imap_sendf | static CURLcode imap_sendf(struct Curl_easy *data, const char *fmt, ...)
{
CURLcode result = CURLE_OK;
struct imap_conn *imapc = &data->conn->proto.imapc;
DEBUGASSERT(fmt);
/* Calculate the tag based on the connection ID and command ID */
msnprintf(imapc->resptag, sizeof(imapc->resptag), "%c%03d",
... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
testb %al, %al
je 0x5fa4b
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(... | /AraHaan[P]curl/lib/imap.c |
imap_perform_authentication | static CURLcode imap_perform_authentication(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct imap_conn *imapc = &conn->proto.imapc;
saslprogress progress;
/* Check if already authenticated OR if there is enough data to authentica... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %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 -0x28(%rbp), %rax
movb 0xfb(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5fc43
movq ... | /AraHaan[P]curl/lib/imap.c |
imap_atom | static char *imap_atom(const char *str, bool escape_only)
{
struct dynbuf line;
size_t nclean;
size_t len;
if(!str)
return NULL;
len = strlen(str);
nclean = strcspn(str, "() {%*]\\\"");
if(len == nclean)
/* nothing to escape, return a strdup */
return strdup(str);
Curl_dyn_init(&line, 200... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5fea8
movq $0x0, -0x8(%rbp)
jmp 0x5ffd4
movq -0x10(%rbp), %rdi
callq 0x10540
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x67d43(%rip), %rsi # 0xc7c03
callq 0x10... | /AraHaan[P]curl/lib/imap.c |
imap_perform_list | static CURLcode imap_perform_list(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct IMAP *imap = data->req.p.imap;
if(imap->custom)
/* Send the custom request */
result = imap_sendf(data, "%s%s", imap->custom,
imap->custom_params ? imap->custom_params : "");
else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x60066
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x... | /AraHaan[P]curl/lib/imap.c |
imap_perform_fetch | static CURLcode imap_perform_fetch(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct IMAP *imap = data->req.p.imap;
/* Check we have a UID */
if(imap->uid) {
/* Send the FETCH command */
if(imap->partial)
result = imap_sendf(data, "UID FETCH %s BODY[%s]<%s>",
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6029c
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x60240
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
mov... | /AraHaan[P]curl/lib/imap.c |
imap_get_message | static CURLcode imap_get_message(struct Curl_easy *data, struct bufref *out)
{
char *message = Curl_dyn_ptr(&data->conn->proto.imapc.pp.recvbuf);
size_t len = data->conn->proto.imapc.pp.nfinal;
if(len > 2) {
/* Find the start of the message */
len -= 2;
for(message += 2; *message == ' ' || *message =... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x478, %rdi # imm = 0x478
addq $0x58, %rdi
callq 0x35630
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x4f8(%rax), %rax
movq %rax, -0x20(%rbp)
... | /AraHaan[P]curl/lib/imap.c |
imap_parse_url_path | static CURLcode imap_parse_url_path(struct Curl_easy *data)
{
/* The imap struct is already initialised in imap_connect() */
CURLcode result = CURLE_OK;
struct IMAP *imap = data->req.p.imap;
const char *begin = &data->state.up.path[1]; /* skip leading slash */
const char *ptr = begin;
/* See how much of th... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1218(%rax), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl... | /AraHaan[P]curl/lib/imap.c |
imap_dophase_done | static CURLcode imap_dophase_done(struct Curl_easy *data, bool connected)
{
struct IMAP *imap = data->req.p.imap;
(void)connected;
if(imap->transfer != PPTRANSFER_BODY)
/* no data to transfer */
Curl_xfer_setup_nop(data);
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x61165
movq -0x8(%rbp), %rdi
callq 0x98f50
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq... | /AraHaan[P]curl/lib/imap.c |
imap_perform_select | static CURLcode imap_perform_select(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct IMAP *imap = data->req.p.imap;
struct imap_conn *imapc = &conn->proto.imapc;
char *mailbox;
/* Invalidate old information as we are switching mailboxes */
Curl_safefree(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%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, -0x30(%rbp)
leaq... | /AraHaan[P]curl/lib/imap.c |
Curl_llist_insert_next | void
Curl_llist_insert_next(struct Curl_llist *list,
struct Curl_llist_node *e, /* may be NULL */
const void *p,
struct Curl_llist_node *ne)
{
DEBUGASSERT(list);
DEBUGASSERT(list->_init == LLISTINIT);
DEBUGASSERT(ne);
#ifdef DEBUGBUILD
ne->_i... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x61726
jmp 0x61728
jmp 0x6172a
jmp 0x6172c
jmp 0x6172e
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%r... | /AraHaan[P]curl/lib/llist.c |
Curl_md4it | CURLcode Curl_md4it(unsigned char *output, const unsigned char *input,
const size_t len)
{
MD4_CTX ctx;
#ifdef VOID_MD4_INIT
MD4_Init(&ctx);
#else
if(!MD4_Init(&ctx))
return CURLE_FAILED_INIT;
#endif
MD4_Update(&ctx, input, curlx_uztoui(len));
MD4_Final(output, &ctx);
return CURLE_... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x61bb0
cmpl $0x0, %eax
jne 0x61b61
movl $0x2, -0x4(%rbp)
jmp 0x61ba3
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa8440
movq -0xc0(%rbp), %rsi
mo... | /AraHaan[P]curl/lib/md4.c |
MD4_Update | static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size)
{
MD4_u32plus saved_lo;
unsigned long used;
saved_lo = ctx->lo;
ctx->lo = (saved_lo + size) & 0x1fffffff;
if(ctx->lo < saved_lo)
ctx->hi++;
ctx->hi += (MD4_u32plus)size >> 29;
used = saved_lo & 0x3f;
if(used) {
unsigne... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq -0x18(%rbp), %rax
andq $0x1fffffff, %rax # imm = 0x1FFFFFFF
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%... | /AraHaan[P]curl/lib/md4.c |
MD4_Final | static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
{
unsigned long used, available;
used = ctx->lo & 0x3f;
ctx->buffer[used++] = 0x80;
available = 64 - used;
if(available < 8) {
memset(&ctx->buffer[used], 0, available);
my_md4_body(ctx, ctx->buffer, 64);
used = 0;
available = 64;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x3f, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $-0x80, 0x18(%rax,%rcx)
movl... | /AraHaan[P]curl/lib/md4.c |
curl_mime_free | void curl_mime_free(curl_mime *mime)
{
curl_mimepart *part;
if(mime) {
mime_subparts_unbind(mime); /* Be sure it is not referenced anymore. */
while(mime->firstpart) {
part = mime->firstpart;
mime->firstpart = part->nextpart;
Curl_mime_cleanpart(part);
free(part);
}
free(mi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x630ae
movq -0x8(%rbp), %rdi
callq 0x630c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6309e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax... | /AraHaan[P]curl/lib/mime.c |
Curl_mime_duppart | CURLcode Curl_mime_duppart(struct Curl_easy *data,
curl_mimepart *dst, const curl_mimepart *src)
{
curl_mime *mime;
curl_mimepart *d;
const curl_mimepart *s;
CURLcode res = CURLE_OK;
DEBUGASSERT(dst);
/* Duplicate content. */
switch(src->kind) {
case MIMEKIND_NONE:
break... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
jmp 0x6313d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq %rax, -0x48(%rbp)
subq $0x4, %rax
ja 0x6329a
movq -0x48(%rbp), %rax
leaq 0x64dc3(%rip), %rcx # 0xc7f20
movslq (%rcx,%ra... | /AraHaan[P]curl/lib/mime.c |
curl_mime_addpart | curl_mimepart *curl_mime_addpart(curl_mime *mime)
{
curl_mimepart *part;
if(!mime)
return NULL;
part = (curl_mimepart *) malloc(sizeof(*part));
if(part) {
Curl_mime_initpart(part);
part->parent = mime;
if(mime->lastpart)
mime->lastpart->nextpart = part;
else
mime->firstpart =... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6376d
movq $0x0, -0x8(%rbp)
jmp 0x637d7
movl $0x1b8, %edi # imm = 0x1B8
leaq 0x89b57(%rip), %rax # 0xed2d0
callq *(%rax)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x637cf
movq -0x18(%rbp), %rdi
callq 0x... | /AraHaan[P]curl/lib/mime.c |
curl_mime_type | CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
Curl_safefree(part->mimetype);
if(mimetype) {
part->mimetype = strdup(mimetype);
if(!part->mimetype)
return CURLE_OUT_OF_MEMORY;
}
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x638a0
movl $0x2b, -0x4(%rbp)
jmp 0x63901
jmp 0x638a2
leaq 0x89a2f(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, ... | /AraHaan[P]curl/lib/mime.c |
curl_mime_filename | CURLcode curl_mime_filename(curl_mimepart *part, const char *filename)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
Curl_safefree(part->filename);
if(filename) {
part->filename = strdup(filename);
if(!part->filename)
return CURLE_OUT_OF_MEMORY;
}
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x639c0
movl $0x2b, -0x4(%rbp)
jmp 0x63a21
jmp 0x639c2
leaq 0x8990f(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x60(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, ... | /AraHaan[P]curl/lib/mime.c |
mime_file_seek | static int mime_file_seek(void *instream, curl_off_t offset, int whence)
{
curl_mimepart *part = (curl_mimepart *) instream;
if(whence == SEEK_SET && !offset && !part->fp)
return CURL_SEEKFUNC_OK; /* Not open: implicitly already at BOF. */
if(mime_open_file(part))
return CURL_SEEKFUNC_FAIL;
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x63c2c
cmpq $0x0, -0x18(%rbp)
jne 0x63c2c
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x63c2c
movl $0x0, -0x4(%rbp)
jmp 0x63c69
... | /AraHaan[P]curl/lib/mime.c |
mime_file_read | static size_t mime_file_read(char *buffer, size_t size, size_t nitems,
void *instream)
{
curl_mimepart *part = (curl_mimepart *) instream;
if(!nitems)
return STOP_FILLING;
if(mime_open_file(part))
return READ_ERROR;
return fread(buffer, size, nitems, part->fp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x63cb1
movq $-0x2, -0x8(%rbp)
jmp 0x63ce6
movq -0x30(%rbp), %rdi
callq 0x65160
cmpl $0x0, %eax
je 0x63cc9
movq... | /AraHaan[P]curl/lib/mime.c |
strippath | static char *strippath(const char *fullfile)
{
char *filename;
char *base;
filename = strdup(fullfile); /* duplicate since basename() may ruin the
buffer it works on */
if(!filename)
return NULL;
base = strdup(basename(filename));
free(filename); /* free temporary buff... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x89585(%rip), %rax # 0xed2e8
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x63d81
movq $0x0, -0x8(%rbp)
jmp 0x63dbd
leaq 0x89560(%rip), %rax # 0xed2e8
movq (%rax), %rax
movq %rax, -... | /AraHaan[P]curl/lib/mime.c |
curl_mime_encoder | CURLcode curl_mime_encoder(curl_mimepart *part, const char *encoding)
{
CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
const struct mime_encoder *mep;
if(!part)
return result;
part->encoder = NULL;
if(!encoding)
return CURLE_OK; /* Removing current encoder. */
for(mep = encoders; mep->name; m... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x2b, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x63df6
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x63e6b
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x63e15
movl $0x0, -0x4(%rbp)
jmp 0x63e6b
... | /AraHaan[P]curl/lib/mime.c |
Curl_mime_prepare_headers | CURLcode Curl_mime_prepare_headers(struct Curl_easy *data,
curl_mimepart *part,
const char *contenttype,
const char *disposition,
enum mimestrategy strategy)
{
curl_mime *mime = ... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x10fa0... | /AraHaan[P]curl/lib/mime.c |
search_header | static char *search_header(struct curl_slist *hdrlist,
const char *hdr, size_t len)
{
char *value = NULL;
for(; !value && hdrlist; hdrlist = hdrlist->next)
value = match_header(hdrlist, hdr, len);
return value;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
jne 0x64cd3
cmpq $0x0, -0x8(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x64cdc
jmp 0x64... | /AraHaan[P]curl/lib/mime.c |
read_part_content | static size_t read_part_content(curl_mimepart *part,
char *buffer, size_t bufsize, bool *hasread)
{
size_t sz = 0;
switch(part->lastreadstatus) {
case 0:
case CURL_READFUNC_ABORT:
case CURL_READFUNC_PAUSE:
case READ_ERROR:
return part->lastreadstatus;
default:
brea... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 0x1b0(%rax), %rax
movq %rax, -0x38(%rbp)
incq %rax
subq $0x2, %rax
jb 0x6607c
jmp 0x6606a
movq -0x38(%rbp), %rax
addq $-0x10000000, %... | /AraHaan[P]curl/lib/mime.c |
cr_mime_read | static CURLcode cr_mime_read(struct Curl_easy *data,
struct Curl_creader *reader,
char *buf, size_t blen,
size_t *pnread, bool *peos)
{
struct cr_mime_ctx *ctx = reader->ctx;
size_t nread;
char tmp[256];
/* Once we have err... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
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 0x80(%rax), %al
sh... | /AraHaan[P]curl/lib/mime.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.