name string | code string | asm string | file string |
|---|---|---|---|
smb_parse_url_path | static CURLcode smb_parse_url_path(struct Curl_easy *data,
struct connectdata *conn)
{
struct smb_request *req = data->req.p.smb;
struct smb_conn *smbc = &conn->proto.smbc;
char *path;
char *slash;
/* URL decode the path */
CURLcode result = Curl_urldecode(data->state.up.... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x1218(%rax), %rdi
xorl %eax, %eax
movl %eax... | /AraHaan[P]curl/lib/smb.c |
smb_send_and_recv | static CURLcode smb_send_and_recv(struct Curl_easy *data, void **msg)
{
struct connectdata *conn = data->conn;
struct smb_conn *smbc = &conn->proto.smbc;
CURLcode result;
*msg = NULL; /* if it returns early */
/* Check if there is data in the transfer buffer */
if(!smbc->send_size && smbc->upload_size) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0... | /AraHaan[P]curl/lib/smb.c |
smb_send_tree_connect | static CURLcode smb_send_tree_connect(struct Curl_easy *data)
{
struct smb_tree_connect msg;
struct connectdata *conn = data->conn;
struct smb_conn *smbc = &conn->proto.smbc;
char *p = msg.bytes;
const size_t byte_count = strlen(conn->host.name) + strlen(smbc->share) +
strlen(SERVICENAME) + 5; /* 2 nulls... | pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp # imm = 0x450
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x430(%rbp)
leaq -0x41b(%rbp), %rax
addq $0xb, %rax
movq %rax, -0x438(%rbp)
mov... | /AraHaan[P]curl/lib/smb.c |
get_posix_time | static void get_posix_time(time_t *out, curl_off_t timestamp)
{
if(timestamp >= CURL_OFF_T_C(116444736000000000)) {
timestamp -= CURL_OFF_T_C(116444736000000000);
timestamp /= 10000000;
#if SIZEOF_TIME_T < SIZEOF_CURL_OFF_T
if(timestamp > TIME_T_MAX)
*out = TIME_T_MAX;
else if(timestamp < TIME_T... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movabsq $0x19db1ded53e8000, %rax # imm = 0x19DB1DED53E8000
cmpq %rax, -0x10(%rbp)
jl 0x89c80
movq -0x10(%rbp), %rax
movabsq $0x19db1ded53e8000, %rcx # imm = 0x19DB1DED53E8000
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x989... | /AraHaan[P]curl/lib/smb.c |
smb_send_close | static CURLcode smb_send_close(struct Curl_easy *data)
{
struct smb_request *req = data->req.p.smb;
struct smb_close msg;
memset(&msg, 0, sizeof(msg));
msg.word_count = SMB_WC_CLOSE;
msg.fid = smb_swap16(req->fid);
return smb_send_message(data, SMB_COM_CLOSE, &msg, sizeof(msg));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x19(%rbp), %rdi
xorl %esi, %esi
movl $0x9, %edx
callq 0x106f0
movb $0x3, -0x19(%rbp)
movq -0x10(%rbp), %rax
movw 0x12(%rax), %ax
movw %ax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $... | /AraHaan[P]curl/lib/smb.c |
smtp_do | static CURLcode smtp_do(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
*done = FALSE; /* default to false */
/* Parse the custom request */
result = smtp_parse_custom_request(data);
if(result)
return result;
result = smtp_regular_trans... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
jmp 0x8a0b9
jmp 0x8a0bb
jmp 0x8a0bd
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x8c390
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8a0e1
movl -0x1c(%rbp), %eax
movl %eax, -0... | /AraHaan[P]curl/lib/smtp.c |
smtp_done | static CURLcode smtp_done(struct Curl_easy *data, CURLcode status,
bool premature)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct SMTP *smtp = data->req.p.smtp;
(void)premature;
if(!smtp)
return CURLE_OK;
/* Cleanup our per-request based variable... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%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)
cmpq $0x0, -0x30(%r... | /AraHaan[P]curl/lib/smtp.c |
smtp_disconnect | static CURLcode smtp_disconnect(struct Curl_easy *data,
struct connectdata *conn,
bool dead_connection)
{
struct smtp_conn *smtpc = &conn->proto.smtpc;
(void)data;
/* We cannot send quit unconditionally. If this connection is stale or
bad in an... | 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 0x8a5d9
movq -0x10(%rbp), %rax
movq 0x3e0(%rax), %rax
shrq $0xd... | /AraHaan[P]curl/lib/smtp.c |
smtp_state | static void smtp_state(struct Curl_easy *data, smtpstate newstate)
{
struct smtp_conn *smtpc = &data->conn->proto.smtpc;
#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
/* for debug purposes */
static const char * const names[] = {
"STOP",
"SERVERGREET",
"EHLO",
"HELO",
"STARTTLS",
"UPGRADETLS"... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
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)
movq -0x18(%rbp), %rax
movl 0xc0(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x8ad8e
jmp 0x8ad06
cmpq $0x0, -0x8(%rbp)
je 0x8ad8a... | /AraHaan[P]curl/lib/smtp.c |
smtp_state_ehlo_resp | static CURLcode smtp_state_ehlo_resp(struct Curl_easy *data,
struct connectdata *conn, int smtpcode,
smtpstate instate)
{
CURLcode result = CURLE_OK;
struct smtp_conn *smtpc = &conn->proto.smtpc;
const char *line = Curl_dyn_ptr(&smtpc->pp.r... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
callq 0x35630
movq %rax, -0x30(%r... | /AraHaan[P]curl/lib/smtp.c |
smtp_state_rcpt_resp | static CURLcode smtp_state_rcpt_resp(struct Curl_easy *data,
struct connectdata *conn, int smtpcode,
smtpstate instate)
{
CURLcode result = CURLE_OK;
struct SMTP *smtp = data->req.p.smtp;
bool is_smtp_err = FALSE;
bool is_smtp_blocking_er... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movb $0x0, -0x2a(%rbp)
movl -0x14(%rbp), %eax
movl $0x64, %ecx
cltd
idi... | /AraHaan[P]curl/lib/smtp.c |
smtp_state_postdata_resp | static CURLcode smtp_state_postdata_resp(struct Curl_easy *data,
int smtpcode,
smtpstate instate)
{
CURLcode result = CURLE_OK;
(void)instate; /* no use for this yet */
if(smtpcode != 250)
result = CURLE_WEIRD_SERVER_REPLY;
... | 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 $0xfa, -0xc(%rbp)
je 0x8b899
movl $0x8, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8acd0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /AraHaan[P]curl/lib/smtp.c |
smtp_perform_authentication | static CURLcode smtp_perform_authentication(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct smtp_conn *smtpc = &conn->proto.smtpc;
saslprogress progress;
/* Check we have enough data to authenticate with, and the
server supports authentication, and end... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%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 -0x28(%rbp), %rax
movb 0xd0(%rax), %al
shrb $0x4, %al
andb $0x1, %al... | /AraHaan[P]curl/lib/smtp.c |
smtp_parse_address | static CURLcode smtp_parse_address(const char *fqma, char **address,
struct hostname *host)
{
CURLcode result = CURLE_OK;
size_t length;
/* Duplicate the fully qualified email address so we can manipulate it,
ensuring it does not contain the delimiters if specified */
ch... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x61456(%rip), %rax # 0xed2e8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x8beb3
movq -0x10(%rbp), %rax
addq $0x1... | /AraHaan[P]curl/lib/smtp.c |
smtp_perform_rcpt_to | static CURLcode smtp_perform_rcpt_to(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct SMTP *smtp = data->req.p.smtp;
char *address = NULL;
struct hostname host = { NULL, NULL, NULL, NULL };
/* Parse the recipient mailbox into the local address and hostname... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 $0x0, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x106f0
... | /AraHaan[P]curl/lib/smtp.c |
cr_eob_add | static CURLcode cr_eob_add(struct Curl_easy *data)
{
struct Curl_creader *reader = NULL;
CURLcode result;
result = Curl_creader_create(&reader, data, &cr_eob,
CURL_CR_CONTENT_ENCODE);
if(!result)
result = Curl_creader_add(data, reader);
if(result && reader)
Curl_creade... | 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 0x5e435(%rip), %rdx # 0xeb218
movl $0x3, %ecx
callq 0x7fbf0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x8ce06
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7fea0
... | /AraHaan[P]curl/lib/smtp.c |
smtp_init | static CURLcode smtp_init(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct SMTP *smtp;
smtp = data->req.p.smtp = calloc(1, sizeof(struct SMTP));
if(!smtp)
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 $0x30, %esi
leaq 0x5ffbc(%rip), %rax # 0xed2f0
callq *(%rax)
movq -0x8(%rbp), %rcx
movq %rax, 0x180(%rcx)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8d353
movl $0x1b, -0xc(%rbp)
movl -0xc(%rbp), %ea... | /AraHaan[P]curl/lib/smtp.c |
socks_proxy_cf_connect | static CURLcode socks_proxy_cf_connect(struct Curl_cfilter *cf,
struct Curl_easy *data,
bool *done)
{
CURLcode result;
struct connectdata *conn = cf->conn;
int sockindex = cf->sockindex;
struct socks_state *sx = cf->ctx;
if(cf->con... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
mov... | /AraHaan[P]curl/lib/socks.c |
Curl_cf_socks_proxy_insert_after | CURLcode Curl_cf_socks_proxy_insert_after(struct Curl_cfilter *cf_at,
struct Curl_easy *data)
{
struct Curl_cfilter *cf;
CURLcode result;
(void)data;
result = Curl_cf_create(&cf, &Curl_cft_socks_proxy, NULL);
if(!result)
Curl_conn_cf_insert_after(cf_at, cf);
re... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
leaq 0x5fadd(%rip), %rsi # 0xed3d8
xorl %eax, %eax
movl %eax, %edx
callq 0x1f610
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8d91a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f760
movl -... | /AraHaan[P]curl/lib/socks.c |
connect_SOCKS | static CURLcode connect_SOCKS(struct Curl_cfilter *cf,
struct socks_state *sxstate,
struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
CURLproxycode pxresult = CURLPX_OK;
struct connectdata *conn = cf->conn;
switch(conn->socks_proxy.proxytype) {
... | 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)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x114(%rax), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x... | /AraHaan[P]curl/lib/socks.c |
do_SOCKS4 | static CURLproxycode do_SOCKS4(struct Curl_cfilter *cf,
struct socks_state *sx,
struct Curl_easy *data)
{
struct connectdata *conn = cf->conn;
const bool protocol4a =
(conn->socks_proxy.proxytype == CURLPROXY_SOCKS4A);
unsigned char *socksreq = sx-... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb 0x114(%rax), %al
subb $0x6, %al
sete -0x29(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)... | /AraHaan[P]curl/lib/socks.c |
socks_state_recv | static CURLproxycode socks_state_recv(struct Curl_cfilter *cf,
struct socks_state *sx,
struct Curl_easy *data,
CURLproxycode failcode,
const char *description)
{
ssiz... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x268(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq ... | /AraHaan[P]curl/lib/socks.c |
Curl_splay | struct Curl_tree *Curl_splay(struct curltime i,
struct Curl_tree *t)
{
struct Curl_tree N, *l, *r, *y;
if(!t)
return NULL;
N.smaller = N.larger = NULL;
l = r = &N;
for(;;) {
timediff_t comp = compare(i, t->key);
if(comp < 0) {
if(!t->smaller)
break;
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8f89a
movq $0x0, -0x8(%rbp)
jmp 0x8fa52
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
... | /AraHaan[P]curl/lib/splay.c |
Curl_splaygetbest | struct Curl_tree *Curl_splaygetbest(struct curltime i,
struct Curl_tree *t,
struct Curl_tree **removed)
{
static const struct curltime tv_zero = {0, 0};
struct Curl_tree *x;
if(!t) {
*removed = NULL; /* none removed since there was no ro... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8fc26
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8fd17
movq -0x20(%rbp), %rdx
movq 0x3c0ef(%rip), %rdi # 0xcbd20
movl 0x3c0f1... | /AraHaan[P]curl/lib/splay.c |
Curl_strntoupper | void Curl_strntoupper(char *dest, const char *src, size_t n)
{
if(n < 1)
return;
do {
*dest++ = Curl_raw_toupper(*src);
} while(*src++ && --n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jae 0x8ff8d
jmp 0x8ffe7
jmp 0x8ff8f
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x8ff30
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
mo... | /AraHaan[P]curl/lib/strcase.c |
ncasecompare | static int ncasecompare(const char *first, const char *second, size_t max)
{
while(*first && max) {
if(Curl_raw_toupper(*first) != Curl_raw_toupper(*second))
return 0;
max--;
first++;
second++;
}
if(0 == max)
return 1; /* they are equal this far */
return Curl_raw_toupper(*first) == C... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x90470
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x... | /AraHaan[P]curl/lib/strequal.c |
curl_url_strerror | const char *
curl_url_strerror(CURLUcode error)
{
#ifndef CURL_DISABLE_VERBOSE_STRINGS
switch(error) {
case CURLUE_OK:
return "No error";
case CURLUE_BAD_HANDLE:
return "An invalid CURLU pointer was passed as argument";
case CURLUE_BAD_PARTPOINTER:
return "An invalid 'part' argument was passed as ... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x20, %rax
ja 0x90e73
movq -0x18(%rbp), %rax
leaq 0x3b511(%rip), %rcx # 0xcc194
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3b585(%rip), %rax # 0xcc218
movq %rax, -0x8(%rbp)
jmp 0x90e7e
leaq 0x3c... | /AraHaan[P]curl/lib/strerror.c |
Curl_str_until | int Curl_str_until(const char **linep, struct Curl_str *out,
const size_t max, char delim)
{
const char *s = *linep;
size_t len = 0;
DEBUGASSERT(linep && *linep && out && max && delim);
Curl_str_init(out);
while(*s && (*s != delim)) {
s++;
if(++len > max) {
return STRE_BIG;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
jmp 0x9105e
movq -0x18(%rbp), %rdi
callq 0x90fd0
movq -0x30(%rbp), %rax
movsbl (%rax... | /AraHaan[P]curl/lib/strparse.c |
telnet_do | static CURLcode telnet_do(struct Curl_easy *data, bool *done)
{
CURLcode result;
struct connectdata *conn = data->conn;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
#ifdef USE_WINSOCK
WSAEVENT event_handle;
WSANETWORKEVENTS events;
HANDLE stdin_handle;
HANDLE objs[2];
DWORD obj_count;
DWORD wait_... | pushq %rbp
movq %rsp, %rbp
subq $0x10b0, %rsp # imm = 0x10B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%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 $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movb $0x1, -0x81(%rb... | /AraHaan[P]curl/lib/telnet.c |
telnet_done | static CURLcode telnet_done(struct Curl_easy *data,
CURLcode status, bool premature)
{
struct TELNET *tn = data->req.p.telnet;
(void)status; /* unused */
(void)premature; /* not used */
if(!tn)
return CURLE_OK;
curl_slist_free_all(tn->telnet_vars);
tn->telnet_vars = NULL;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x91e75
movl $0x0, -0x4(%rbp)
jmp 0x91eab
movq -0x20(%rbp), %rax
movq 0x1c20(%rax),... | /AraHaan[P]curl/lib/telnet.c |
negotiate | static void negotiate(struct Curl_easy *data)
{
int i;
struct TELNET *tn = data->req.p.telnet;
for(i = 0; i < CURL_NTELOPTS; i++) {
if(i == CURL_TELOPT_ECHO)
continue;
if(tn->us_preferred[i] == CURL_YES)
set_local_option(data, i, CURL_YES);
if(tn->him_preferred[i] == CURL_YES)
set... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x28, -0xc(%rbp)
jge 0x92ba3
cmpl $0x1, -0xc(%rbp)
jne 0x92b50
jmp 0x92b98
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x1, 0x808(%rax,%rcx,4)
jne 0x... | /AraHaan[P]curl/lib/telnet.c |
send_telnet_data | static CURLcode send_telnet_data(struct Curl_easy *data,
char *buffer, ssize_t nread)
{
size_t i, outlen;
unsigned char *outbuf;
CURLcode result = CURLE_OK;
size_t bytes_written;
size_t total_written = 0;
struct connectdata *conn = data->conn;
struct TELNET *tn = data->req... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x92bf0
jmp 0x92bf2
... | /AraHaan[P]curl/lib/telnet.c |
printoption | static void printoption(struct Curl_easy *data,
const char *direction, int cmd, int option)
{
if(data->set.verbose) {
if(cmd == CURL_IAC) {
if(CURL_TELCMD_OK(option))
infof(data, "%s IAC %s", direction, CURL_TELCMD(option));
else
infof(data, "%s IAC %d", directi... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x1e, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x9310f
cmpl $0xff, -0x14(%rbp)
jne 0x92f23
cmpl $0xec, -0x18(%rbp)
jb 0x92ec1
cmpl $0xf... | /AraHaan[P]curl/lib/telnet.c |
rec_will | static
void rec_will(struct Curl_easy *data, int option)
{
struct TELNET *tn = data->req.p.telnet;
switch(tn->him[option]) {
case CURL_NO:
if(tn->him_preferred[option] == CURL_YES) {
tn->him[option] = CURL_YES;
send_negotiation(data, CURL_DO, option);
}
else
send_negotiation(data, CU... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0xc08(%rax,%rcx,4), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x93291
movq -0x20(%rbp), %rax
leaq 0x3a1de(%... | /AraHaan[P]curl/lib/telnet.c |
rec_do | static
void rec_do(struct Curl_easy *data, int option)
{
struct TELNET *tn = data->req.p.telnet;
switch(tn->us[option]) {
case CURL_NO:
if(tn->us_preferred[option] == CURL_YES) {
tn->us[option] = CURL_YES;
send_negotiation(data, CURL_WILL, option);
if(tn->subnegotiation[option] == CURL_YES)
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x935e1
movq -0x20(%rbp), %rax
leaq 0x39f21(%ri... | /AraHaan[P]curl/lib/telnet.c |
suboption | static void suboption(struct Curl_easy *data)
{
struct curl_slist *v;
unsigned char temp[2048];
ssize_t bytes_written;
size_t len;
int err;
struct TELNET *tn = data->req.p.telnet;
struct connectdata *conn = data->conn;
printsub(data, '<', (unsigned char *)tn->subbuffer, CURL_SB_LEN(tn) + 2);
switch(C... | pushq %rbp
movq %rsp, %rbp
subq $0x880, %rsp # imm = 0x880
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x830(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x838(%rbp)
movq -0x8(%rbp), %rdi
movq -0x830(%rbp), %rcx
movq %rcx, %rdx
addq $0x1c48, %rdx ... | /AraHaan[P]curl/lib/telnet.c |
sendsuboption | static void sendsuboption(struct Curl_easy *data, int option)
{
ssize_t bytes_written;
int err;
unsigned short x, y;
unsigned char *uc1, *uc2;
struct TELNET *tn = data->req.p.telnet;
struct connectdata *conn = data->conn;
switch(option) {
case CURL_TELOPT_NAWS:
/* We prepare data to be sent */
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
subl $0x1f, %eax
jne 0x940f1
jmp 0x93d18
movq -0x38(%rbp), %rcx
addq $0x1c4... | /AraHaan[P]curl/lib/telnet.c |
printsub | static void printsub(struct Curl_easy *data,
int direction, /* '<' or '>' */
unsigned char *pointer, /* where suboption data is */
size_t length) /* length of suboption data */
{
if(data->set.verbose) {
unsigned int i = 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x1e, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x94c20
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x9454f
jmp 0x94146
cmpq $0x0, -0... | /AraHaan[P]curl/lib/telnet.c |
set_local_option | static void
set_local_option(struct Curl_easy *data, int option, int newstate)
{
struct TELNET *tn = data->req.p.telnet;
if(newstate == CURL_YES) {
switch(tn->us[option]) {
case CURL_NO:
tn->us[option] = CURL_WANTYES;
send_negotiation(data, CURL_WILL, option);
break;
case CURL_YES:
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x94d27
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %eax
movq %rax, -0x20(%rbp)
subq $0x... | /AraHaan[P]curl/lib/telnet.c |
tftp_setup_connection | static CURLcode tftp_setup_connection(struct Curl_easy *data,
struct connectdata *conn)
{
char *type;
conn->transport = TRNSPRT_UDP;
/* TFTP URLs support an extension like ";mode=<typecode>" that
* we will try to get now! */
type = strstr(data->state.up.path, ";mode=")... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x4, 0x5ba(%rax)
movq -0x8(%rbp), %rax
movq 0x1218(%rax), %rdi
leaq 0x38bc7(%rip), %rsi # 0xcdbd4
callq 0x10250
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x95038
movq -0x10(%rbp), %rax
movq ... | /AraHaan[P]curl/lib/tftp.c |
tftp_do | static CURLcode tftp_do(struct Curl_easy *data, bool *done)
{
struct tftp_state_data *state;
CURLcode result;
struct connectdata *conn = data->conn;
*done = FALSE;
if(!conn->proto.tftpc) {
result = tftp_connect(data, done);
if(result)
return result;
}
state = conn->proto.tftpc;
if(!stat... | 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, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x478(%rax)
jne 0x95111
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x951f0
mov... | /AraHaan[P]curl/lib/tftp.c |
tftp_connect | static CURLcode tftp_connect(struct Curl_easy *data, bool *done)
{
struct tftp_state_data *state;
int blksize;
int need_blksize;
struct connectdata *conn = data->conn;
blksize = TFTP_BLKSIZE_DEFAULT;
state = conn->proto.tftpc = calloc(1, sizeof(struct tftp_state_data));
if(!state)
return CURLE_OUT_O... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x200, -0x24(%rbp) # imm = 0x200
movl $0x1, %edi
movl $0x160, %esi # imm = 0x160
leaq 0x580c9(%rip), %rax # 0xe... | /AraHaan[P]curl/lib/tftp.c |
tftp_disconnect | static CURLcode tftp_disconnect(struct Curl_easy *data,
struct connectdata *conn, bool dead_connection)
{
struct tftp_state_data *state = conn->proto.tftpc;
(void) data;
(void) dead_connection;
/* done, free dynamically allocated pkt buffers */
if(state) {
Curl_safefree(st... | 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
movq 0x478(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9576d
jmp 0x9570f
leaq 0x57bc2(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x... | /AraHaan[P]curl/lib/tftp.c |
tftp_send_first | static CURLcode tftp_send_first(struct tftp_state_data *state,
tftp_event_t event)
{
size_t sbytes;
ssize_t senddata;
const char *mode = "octet";
char *filename;
struct Curl_easy *data = state->data;
CURLcode result = CURLE_OK;
/* Set ASCII mode if -B flag was used */
if... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x37909(%rip), %rax # 0xcd832
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl 0x13be(%rax), %eax
shrl... | /AraHaan[P]curl/lib/tftp.c |
tftp_tx | static CURLcode tftp_tx(struct tftp_state_data *state, tftp_event_t event)
{
struct Curl_easy *data = state->data;
ssize_t sbytes;
CURLcode result = CURLE_OK;
struct SingleRequest *k = &data->req;
size_t cb; /* Bytes currently read */
char buffer[STRERROR_LEN];
char *bufptr;
bool eos;
switch(event) {... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $-0x4, %eax
movl %eax,... | /AraHaan[P]curl/lib/tftp.c |
tftp_connect_for_rx | static CURLcode tftp_connect_for_rx(struct tftp_state_data *state,
tftp_event_t event)
{
CURLcode result;
#ifndef CURL_DISABLE_VERBOSE_STRINGS
struct Curl_easy *data = state->data;
infof(data, "%s", "Connected for receive");
#endif
state->state = TFTP_STATE_RX;
result = tf... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x97272
movq -0x20(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x1e, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x97272
movq -0x20(%rbp), %rax... | /AraHaan[P]curl/lib/tftp.c |
tftp_option_get | static const char *tftp_option_get(const char *buf, size_t len,
const char **option, const char **value)
{
size_t loc;
loc = tftp_strnlen(buf, len);
loc++; /* NULL term */
if(loc >= len)
return NULL;
*option = buf;
loc += tftp_strnlen(buf + loc, len-loc);
loc++; /... | 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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x97350
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp)... | /AraHaan[P]curl/lib/tftp.c |
curlx_mstotv | struct timeval *curlx_mstotv(struct timeval *tv, timediff_t ms)
{
if(!tv)
return NULL;
if(ms < 0)
return NULL;
if(ms > 0) {
timediff_t tv_sec = ms / 1000;
timediff_t tv_usec = (ms % 1000) * 1000; /* max=999000 */
#ifdef HAVE_SUSECONDS_T
#if TIMEDIFF_T_MAX > TIME_T_MAX
/* tv_sec overflow chec... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9788d
movq $0x0, -0x8(%rbp)
jmp 0x97908
cmpq $0x0, -0x18(%rbp)
jge 0x9789e
movq $0x0, -0x8(%rbp)
jmp 0x97908
cmpq $0x0, -0x18(%rbp)
jle 0x978e9
movq -0x18(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idi... | /AraHaan[P]curl/lib/timediff.c |
Curl_now | struct curltime Curl_now(void)
{
/*
** Monotonic timer on macOS is provided by mach_absolute_time(), which
** returns time in Mach "absolute time units," which are platform-dependent.
** To convert to nanoseconds, one must use conversion factors specified by
** mach_timebase_info().
*/
static mach_timebas... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x4, %edi
leaq -0x30(%rbp), %rsi
callq 0x10bd0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x97989
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movl %eax, -0x8(%rbp)
jmp 0x979d8
m... | /AraHaan[P]curl/lib/timeval.c |
Curl_timediff_ceil | timediff_t Curl_timediff_ceil(struct curltime newer, struct curltime older)
{
timediff_t diff = (timediff_t)newer.tv_sec-older.tv_sec;
if(diff >= (TIMEDIFF_T_MAX/1000))
return TIMEDIFF_T_MAX;
else if(diff <= (TIMEDIFF_T_MIN/1000))
return TIMEDIFF_T_MIN;
return diff * 1000 + (newer.tv_usec - older.tv_use... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movabsq $0x20c49ba5e353f7, %rax # imm = 0x20C49BA5E353F7
cmpq %rax, -0x30(%rbp)
jl 0x97abe
movabsq $0x7fffffffffffffff, %rax # imm =... | /AraHaan[P]curl/lib/timeval.c |
Curl_sendrecv | CURLcode Curl_sendrecv(struct Curl_easy *data, struct curltime *nowp)
{
struct SingleRequest *k = &data->req;
CURLcode result = CURLE_OK;
int didwhat = 0;
DEBUGASSERT(nowp);
if(data->state.select_bits) {
if(select_bits_paused(data, data->state.select_bits)) {
/* leave the bits unchanged, so they'll... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x97e6e
movq -0x8(%rbp), %rax
cmpb $0x0, 0x13bd(%rax)
je 0x97eab
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl 0x1... | /AraHaan[P]curl/lib/transfer.c |
Curl_retry_request | CURLcode Curl_retry_request(struct Curl_easy *data, char **url)
{
struct connectdata *conn = data->conn;
bool retry = FALSE;
*url = NULL;
/* if we are talking upload, we cannot do the checks below, unless the
protocol is HTTP as when uploading over HTTP we will still get a
response */
if(data->stat... | 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)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl 0x13be(%rax), %eax
shrl $0x13, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je... | /AraHaan[P]curl/lib/transfer.c |
xfer_setup | static void xfer_setup(
struct Curl_easy *data, /* transfer */
int sockindex, /* socket index to read from or -1 */
curl_off_t size, /* -1 if unknown at this point */
bool getheader, /* TRUE if header parsing is wanted */
int writesockindex, /* socket index to write to, i... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %r9d, -0x4c(%rbp)
movl %ecx, %eax
movl -0x4c(%rbp), %ecx
movq %rdx, -0x48(%rbp)
movl %esi, %edx
movq -0x48(%rbp), %rsi
movl %edx, -0x40(%rbp)
movq %rdi, %r9
movl -0x40(%rbp), %edi
movb %al, %dl
movb 0x10(%rbp), %al
movq %r9, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0... | /AraHaan[P]curl/lib/transfer.c |
Curl_xfer_is_blocked | bool Curl_xfer_is_blocked(struct Curl_easy *data)
{
bool want_send = ((data)->req.keepon & KEEP_SEND);
bool want_recv = ((data)->req.keepon & KEEP_RECV);
if(!want_send)
return want_recv && Curl_cwriter_is_paused(data);
else if(!want_recv)
return want_send && Curl_creader_is_paused(data);
else
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x104(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0x104(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x12(%rbp)
tes... | /AraHaan[P]curl/lib/transfer.c |
Curl_uint_bset_first | bool Curl_uint_bset_first(struct uint_bset *bset, unsigned int *pfirst)
{
unsigned int i;
for(i = 0; i < bset->nslots; ++i) {
if(bset->slots[i]) {
*pfirst = (i * 64) + CURL_CTZ64(bset->slots[i]);
return TRUE;
}
}
*pfirst = UINT_MAX; /* a value we cannot store */
return FALSE;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x9a014
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9a007
movl -0x1c(%rbp), %ecx
shll $0x6, %ecx
movq -... | /AraHaan[P]curl/lib/uint-bset.c |
Curl_uint_bset_next | bool Curl_uint_bset_next(struct uint_bset *bset, unsigned int last,
unsigned int *pnext)
{
unsigned int islot;
curl_uint64_t x;
++last; /* look for number one higher than last */
islot = last / 64; /* the slot this would be in */
if(islot < bset->nslots) {
/* shift away the bits ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x6, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x9a0fb
movq -0x10(%rbp), %ra... | /AraHaan[P]curl/lib/uint-bset.c |
Curl_uint_hash_remove | bool Curl_uint_hash_remove(struct uint_hash *h, unsigned int id)
{
DEBUGASSERT(h);
DEBUGASSERT(h->slots);
DEBUGASSERT(h->init == CURL_UINTHASHINIT);
if(h->table) {
struct uint_hash_entry *he, **he_anchor;
he_anchor = CURL_UINT_HASH_SLOT_ADDR(h, id);
while(*he_anchor) {
he = *he_anchor;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
jmp 0x9a3b1
jmp 0x9a3b3
jmp 0x9a3b5
jmp 0x9a3b7
jmp 0x9a3b9
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9a441
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movl 0x1... | /AraHaan[P]curl/lib/uint-hash.c |
Curl_uint_spbset_empty | bool Curl_uint_spbset_empty(struct uint_spbset *bset)
{
struct uint_spbset_chunk *chunk;
unsigned int i;
for(chunk = &bset->head; chunk; chunk = chunk->next) {
for(i = 0; i < CURL_UINT_SPBSET_CH_SLOTS; ++i) {
if(chunk->slots[i])
return FALSE;
}
}
return TRUE;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9a925
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jae 0x9a916
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x9a909
movb $0x0, -0x1(%rbp)
jmp 0x9a929
jmp 0x9a90b
m... | /AraHaan[P]curl/lib/uint-spbset.c |
uint_spbset_get_chunk | static struct uint_spbset_chunk *
uint_spbset_get_chunk(struct uint_spbset *bset, unsigned int i, bool grow)
{
struct uint_spbset_chunk *chunk, **panchor = NULL;
unsigned int i_offset = (i & ~CURL_UINT_SPBSET_CH_MASK);
if(!bset)
return NULL;
for(chunk = &bset->head; chunk;
panchor = &chunk->next, ch... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax # imm = 0xFFFFFF00
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9a9ed
movq $0x0, -0x8(%rbp)
jmp 0... | /AraHaan[P]curl/lib/uint-spbset.c |
uint_spbset_chunk_first | static bool uint_spbset_chunk_first(struct uint_spbset_chunk *chunk,
unsigned int *pfirst)
{
unsigned int i;
for(i = 0; i < CURL_UINT_SPBSET_CH_SLOTS; ++i) {
if(chunk->slots[i]) {
*pfirst = chunk->offset + ((i * 64) + CURL_CTZ64(chunk->slots[i]));
return TRUE;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jae 0x9aeb3
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x9aea6
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movl -0x1c(%rbp), %eax
shll $0x6, %eax
movq -0x10(%rbp), %r... | /AraHaan[P]curl/lib/uint-spbset.c |
Curl_uint_tbl_init | void Curl_uint_tbl_init(struct uint_tbl *tbl,
Curl_uint_tbl_entry_dtor *entry_dtor)
{
memset(tbl, 0, sizeof(*tbl));
tbl->entry_dtor = entry_dtor;
tbl->last_key_added = UINT_MAX;
#ifdef DEBUGBUILD
tbl->init = CURL_UINT_TBL_MAGIC;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x106f0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp... | /AraHaan[P]curl/lib/uint-table.c |
uint_tbl_next_at | static bool uint_tbl_next_at(struct uint_tbl *tbl, unsigned int key,
unsigned int *pkey, void **pentry)
{
for(; key < tbl->nrows; ++key) {
if(tbl->rows[key]) {
*pkey = key;
*pentry = tbl->rows[key];
return TRUE;
}
}
*pkey = UINT_MAX; /* always invalid */
*... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x9b491
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9b484
movl -0x14(%rbp), %ec... | /AraHaan[P]curl/lib/uint-table.c |
Curl_uint_tbl_next | bool Curl_uint_tbl_next(struct uint_tbl *tbl, unsigned int last_key,
unsigned int *pkey, void **pentry)
{
if(!pkey || !pentry)
return FALSE;
if(uint_tbl_next_at(tbl, last_key + 1, pkey, pentry))
return TRUE;
*pkey = UINT_MAX; /* always invalid */
*pentry = NULL;
return FALSE;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9b4e5
cmpq $0x0, -0x28(%rbp)
jne 0x9b4eb
movb $0x0, -0x1(%rbp)
jmp 0x9b527
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x20(%rbp), %... | /AraHaan[P]curl/lib/uint-table.c |
Curl_freeset | void Curl_freeset(struct Curl_easy *data)
{
/* Free all dynamic strings stored in the data->set substructure. */
enum dupstring i;
enum dupblob j;
for(i = (enum dupstring)0; i < STRING_LAST; i++) {
Curl_safefree(data->set.str[i]);
}
for(j = (enum dupblob)0; j < BLOB_LAST; j++) {
Curl_safefree(data... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4b, -0xc(%rbp)
jae 0x9b596
jmp 0x9b55b
leaq 0x51d76(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
movq 0x6d8(%rcx,%rdx,8), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ec... | /AraHaan[P]curl/lib/url.c |
up_free | static void up_free(struct Curl_easy *data)
{
struct urlpieces *up = &data->state.up;
Curl_safefree(up->scheme);
Curl_safefree(up->hostname);
Curl_safefree(up->port);
Curl_safefree(up->user);
Curl_safefree(up->password);
Curl_safefree(up->options);
Curl_safefree(up->path);
Curl_safefree(up->query);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc00, %rax # imm = 0xC00
addq $0x5e8, %rax # imm = 0x5E8
movq %rax, -0x10(%rbp)
leaq 0x515e1(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%r... | /AraHaan[P]curl/lib/url.c |
Curl_verboseconnect | void Curl_verboseconnect(struct Curl_easy *data,
struct connectdata *conn, int sockindex)
{
if(data->set.verbose && sockindex == SECONDARYSOCKET)
infof(data, "Connected 2nd connection to %s port %u",
conn->secondary.remote_ip, conn->secondary.remote_port);
else
infof(data,... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x1e, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x9cddf
cmpl $0x1, -0x14(%rbp)
jne 0x9cddf
jmp 0x9cd73
cmpq $0x0, -0x8(%rbp)
je 0x9cdd8
movq -0x8(%rbp), %rax
m... | /AraHaan[P]curl/lib/url.c |
Curl_parse_login_details | CURLcode Curl_parse_login_details(const char *login, const size_t len,
char **userp, char **passwdp,
char **optionsp)
{
char *ubuf = NULL;
char *pbuf = NULL;
const char *psep = NULL;
const char *osep = NULL;
size_t ulen;
size_t plen;
size... | 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 %r8, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
jmp 0x9d201
jmp 0x9d203
jmp 0x9d205
movq -0x10(%rbp), %rdi
movq -0x18(... | /AraHaan[P]curl/lib/url.c |
allocate_conn | static struct connectdata *allocate_conn(struct Curl_easy *data)
{
struct connectdata *conn = calloc(1, sizeof(struct connectdata));
if(!conn)
return NULL;
/* and we setup a few fields in case we end up actually using this struct */
conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x5c0, %esi # imm = 0x5C0
leaq 0x4ed73(%rip), %rax # 0xed2f0
callq *(%rax)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9e597
movq $0x0, -0x8(%rbp)
jmp 0x9ea63
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x270(%r... | /AraHaan[P]curl/lib/url.c |
setup_connection_internals | static CURLcode setup_connection_internals(struct Curl_easy *data,
struct connectdata *conn)
{
const struct Curl_handler *p;
const char *hostname;
int port;
CURLcode result;
/* Perform setup complement if some. */
p = conn->handler;
if(p->setup_connection) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x3e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa0a0f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl... | /AraHaan[P]curl/lib/url.c |
ConnectionExists | static bool
ConnectionExists(struct Curl_easy *data,
struct connectdata *needle,
struct connectdata **usethis,
bool *force_reuse,
bool *waitpipe)
{
struct url_conn_match match;
bool result;
memset(&match, 0, sizeof(match));
match.data = data;
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x106f0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
mo... | /AraHaan[P]curl/lib/url.c |
resolve_server | static CURLcode resolve_server(struct Curl_easy *data,
struct connectdata *conn,
bool *async)
{
struct hostname *ehost;
timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
const char *peertype = "host";
CURLcode result;
#ifdef USE_UNIX_SOCKETS
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x23750
movq %rax, -0x30(%rbp)
leaq 0x26058(%rip), %rax # 0xc724c
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x590(%ra... | /AraHaan[P]curl/lib/url.c |
findprotocol | static CURLcode findprotocol(struct Curl_easy *data,
struct connectdata *conn,
const char *protostr)
{
const struct Curl_handler *p = Curl_get_scheme_handler(protostr);
if(p && /* Protocol found in table. Check if allowed */
(data->set.allowed_protocol... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9d050
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa16c6
movq -0x10(%rbp), %rax
movl 0x974(%rax), %eax
movq -0x28(%rbp), %rcx
andl 0x94(%rcx), %eax
cmpl $0x0, %eax
je 0xa... | /AraHaan[P]curl/lib/url.c |
proxy_info_matches | static bool
proxy_info_matches(const struct proxy_info *data,
const struct proxy_info *needle)
{
if((data->proxytype == needle->proxytype) &&
(data->port == needle->port) &&
strcasecompare(data->host.name, needle->host.name))
return TRUE;
return FALSE;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x24(%rcx), %ecx
cmpl %ecx, %eax
jne 0xa38d4
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0xa38d4
movq -... | /AraHaan[P]curl/lib/url.c |
resolve_unix | static CURLcode resolve_unix(struct Curl_easy *data,
struct connectdata *conn,
char *unix_path)
{
struct Curl_dns_entry *hostaddr = NULL;
bool longpath = FALSE;
DEBUGASSERT(unix_path);
DEBUGASSERT(conn->dns_entry == NULL);
/* Unix domain sockets are ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
jmp 0xa3912
jmp 0xa3914
jmp 0xa3916
movl $0x1, %edi
movl $0x20, %esi
leaq 0x499c9(%rip), %rax # 0xed2f0
callq *(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28... | /AraHaan[P]curl/lib/url.c |
curl_url_set | CURLUcode curl_url_set(CURLU *u, CURLUPart what,
const char *part, unsigned int flags)
{
char **storep = NULL;
bool urlencode = (flags & CURLU_URLENCODE) ? 1 : 0;
bool plusencode = FALSE;
bool urlskipslash = FALSE;
bool leadingslash = FALSE;
bool appendquery = FALSE;
bool equalsenco... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x24(%rbp), %edx
andl $0x80, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
an... | /AraHaan[P]curl/lib/urlapi.c |
redirect_url | static CURLUcode redirect_url(const char *base, const char *relurl,
CURLU *u, unsigned int flags)
{
struct dynbuf urlbuf;
bool host_changed = FALSE;
const char *useurl = relurl;
const char *cutoff = NULL;
size_t prelen;
CURLUcode uc;
/* protsep points to the start of the hos... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movb $0x0, -0x49(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq... | /AraHaan[P]curl/lib/urlapi.c |
parse_hostname_login | static CURLUcode parse_hostname_login(struct Curl_URL *u,
const char *login,
size_t len,
unsigned int flags,
size_t *offset) /* to the hostname */
{
CURLUcode result ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
jmp 0xa64b7
movq -0x30(%rbp), %rax
movq $0x0, (... | /AraHaan[P]curl/lib/urlapi.c |
ipv4_normalize | static int ipv4_normalize(struct dynbuf *host)
{
bool done = FALSE;
int n = 0;
const char *c = Curl_dyn_ptr(host);
unsigned int parts[4] = {0, 0, 0, 0};
CURLcode result = CURLE_OK;
if(*c == '[')
return HOST_IPV6;
while(!done) {
int rc;
curl_off_t l;
if(*c == '0') {
if(c[1] == 'x') ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35630
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x106f0
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b,... | /AraHaan[P]curl/lib/urlapi.c |
urldecode_host | static CURLUcode urldecode_host(struct dynbuf *host)
{
char *per = NULL;
const char *hostname = Curl_dyn_ptr(host);
per = strchr(hostname, '%');
if(!per)
/* nothing to decode */
return CURLUE_OK;
else {
/* encoded */
size_t dlen;
char *decoded;
CURLcode result = Curl_urldecode(hostname... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35630
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x25, %esi
callq 0x10470
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa6da6
movl $0x0, -0x4(%rbp)
jmp 0xa6e27
movq -0x20(%rbp), %rdi
x... | /AraHaan[P]curl/lib/urlapi.c |
curl_version | char *curl_version(void)
{
static char out[300];
char *outp;
size_t outlen;
const char *src[VERSION_PARTS];
#ifdef USE_SSL
char ssl_version[200];
#endif
#ifdef HAVE_LIBZ
char z_version[30];
#endif
#ifdef HAVE_BROTLI
char br_version[30];
#endif
#ifdef HAVE_ZSTD
char zstd_ver[30];
#endif
#ifdef USE_ARES
... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movl $0x0, -0x1e4(%rbp)
movl -0x1e4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1e4(%rbp)
cltq
leaq 0x266ed(%rip), %rcx # 0xce5ec
movq %rcx, -0x90(%rbp,%rax,8)
leaq -0x160(%rbp), %rdi
movl $0xc8, %esi
callq 0xbada0
leaq -0x160(%rbp)... | /AraHaan[P]curl/lib/version.c |
curl_version_info | curl_version_info_data *curl_version_info(CURLversion stamp)
{
size_t n;
const struct feat *p;
int features = 0;
#if defined(USE_SSH)
static char ssh_buf[80]; /* 'ssh_buffer' clashes with libssh/libssh.h */
#endif
#ifdef USE_SSL
#ifdef CURL_WITH_MULTI_SSL
static char ssl_buffer[200];
#else
static char ssl... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x45507(%rip), %rdi # 0xed790
movl $0x50, %esi
callq 0xbada0
leaq 0x454f6(%rip), %rax # 0xed790
movq %rax, 0x451d7(%rip) # 0xed478
callq 0x102e0
movq %rax, 0x451db(%rip) # 0xed488
callq 0x10400
movl %eax, 0x452... | /AraHaan[P]curl/lib/version.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(po... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0xa84ca
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /AraHaan[P]curl/lib/warnless.c |
ws_dec_reset | static void ws_dec_reset(struct ws_decoder *dec)
{
dec->frame_age = 0;
dec->frame_flags = 0;
dec->payload_offset = 0;
dec->payload_len = 0;
dec->head_len = dec->head_total = 0;
dec->state = WS_DEC_INIT;
dec->cont_flags = 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rb... | /AraHaan[P]curl/lib/ws.c |
nw_in_recv | static ssize_t nw_in_recv(void *reader_ctx,
unsigned char *buf, size_t buflen,
CURLcode *err)
{
struct Curl_easy *data = reader_ctx;
size_t nread;
*err = curl_easy_recv(data, buf, buflen, &nread);
if(*err)
return -1;
return (ssize_t)nread;
} | 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 -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x109f0
movl %eax, %ecx
movq -0x28(%rbp)... | /AraHaan[P]curl/lib/ws.c |
ws_client_collect | static ssize_t ws_client_collect(const unsigned char *buf, size_t buflen,
int frame_age, int frame_flags,
curl_off_t payload_offset,
curl_off_t payload_len,
void *userp,
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
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 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax,... | /AraHaan[P]curl/lib/ws.c |
ws_dec_info | static void ws_dec_info(struct ws_decoder *dec, struct Curl_easy *data,
const char *msg)
{
switch(dec->head_len) {
case 0:
break;
case 1:
CURL_TRC_WRITE(data, "websocket, decoded %s [%s%s]", msg,
ws_frame_name_of_op(dec->head[0]),
(dec->head[0]... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xa9461
jmp 0xa9454
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xa9466
jmp 0xa951b
jmp 0xa96be
jmp 0xa9468
cmpq $0x0, -0x1... | /AraHaan[P]curl/lib/ws.c |
update_meta | static void update_meta(struct websocket *ws,
int frame_age, int frame_flags,
curl_off_t payload_offset,
curl_off_t payload_len,
size_t cur_len)
{
curl_off_t bytesleft = (payload_len - payload_offset - cur_len);
ws->fra... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe0(%rax)
m... | /AraHaan[P]curl/lib/ws.c |
ws_enc_write_head | static ssize_t ws_enc_write_head(struct Curl_easy *data,
struct ws_encoder *enc,
unsigned int flags,
curl_off_t payload_len,
struct bufq *out,
CURLcode *er... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0xaa237
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x24c5f(%rip), %rsi # 0xcee... | /AraHaan[P]curl/lib/ws.c |
curl_ws_meta | curl_ws_frame *curl_ws_meta(CURL *d)
{
/* we only return something for websocket, called from within the callback
when not using raw mode */
struct Curl_easy *data = d;
if(GOOD_EASY_HANDLE(data) && Curl_is_in_callback(data) &&
data->conn && !data->set.ws_raw_mode) {
struct websocket *ws;
ws = Cu... | 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 0xaa66a
movq -0x18(%rbp), %rax
cmpl $0xc0dedbad, (%rax) # imm = 0xC0DEDBAD
jne 0xaa66a
movq -0x18(%rbp), %rdi
callq 0x71350
testb $0x1, %al
jne 0xaa616
jmp 0xaa66a
movq -0x18(%r... | /AraHaan[P]curl/lib/ws.c |
ws_dec_next_frame | static void ws_dec_next_frame(struct ws_decoder *dec)
{
dec->frame_age = 0;
dec->frame_flags = 0;
dec->payload_offset = 0;
dec->payload_len = 0;
dec->head_len = dec->head_total = 0;
dec->state = WS_DEC_INIT;
/* dec->cont_flags must be carried over to next frame */
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rb... | /AraHaan[P]curl/lib/ws.c |
ws_dec_pass_payload | static CURLcode ws_dec_pass_payload(struct ws_decoder *dec,
struct Curl_easy *data,
struct bufq *inraw,
ws_write_payload *write_payload,
void *write_ctx)
{
const unsigned cha... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x58(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x58(%rbp)
movb %al, -... | /AraHaan[P]curl/lib/ws.c |
ws_frame_flags2firstbyte | static unsigned char ws_frame_flags2firstbyte(struct Curl_easy *data,
unsigned int flags,
bool contfragment,
CURLcode *err)
{
switch(flags & ~CURLWS_OFFSET) {
case 0:
if(... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x44, %eax
ja 0xab744
movq -0x28(%rbp), %rax
leaq 0x2317a(%rip), %rcx ... | /AraHaan[P]curl/lib/ws.c |
auth_decode_digest_md5_message | static CURLcode auth_decode_digest_md5_message(const struct bufref *chlgref,
char *nonce, size_t nlen,
char *realm, size_t rlen,
char *alg, size_t alen,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15ea0
movq %rax, -0x40(%rbp)
movq -0x10(%rb... | /AraHaan[P]curl/lib/vauth/digest.c |
auth_digest_get_qop_values | static CURLcode auth_digest_get_qop_values(const char *options, int *value)
{
struct Curl_str out;
/* Initialise the output */
*value = 0;
while(!Curl_str_until(&options, &out, 32, ',')) {
if(Curl_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH))
*value |= DIGEST_QOP_VALUE_AUTH;
else if(Curl_s... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x20, %edx
movl $0x2c, %ecx
callq 0x91030
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xac7c2
jmp 0xac844
leaq -0x20(%rbp... | /AraHaan[P]curl/lib/vauth/digest.c |
Curl_auth_decode_digest_http_message | CURLcode Curl_auth_decode_digest_http_message(const char *chlg,
struct digestdata *digest)
{
bool before = FALSE; /* got a nonce before */
/* If we already have received a nonce, keep that in mind */
if(digest->nonce)
before = TRUE;
/* Clean up any former left... | pushq %rbp
movq %rsp, %rbp
subq $0x550, %rsp # imm = 0x550
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xac875
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0xacf70
jmp 0xac880
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %ea... | /AraHaan[P]curl/lib/vauth/digest.c |
Curl_auth_digest_cleanup | void Curl_auth_digest_cleanup(struct digestdata *digest)
{
Curl_safefree(digest->nonce);
Curl_safefree(digest->cnonce);
Curl_safefree(digest->realm);
Curl_safefree(digest->opaque);
Curl_safefree(digest->qop);
Curl_safefree(digest->algorithm);
digest->nc = 0;
digest->algo = ALGO_MD5; /* default algorith... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x40355(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xacf9c
leaq 0x40335(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx)... | /AraHaan[P]curl/lib/vauth/digest.c |
Curl_auth_decode_ntlm_type2_message | CURLcode Curl_auth_decode_ntlm_type2_message(struct Curl_easy *data,
const struct bufref *type2ref,
struct ntlmdata *ntlm)
{
static const char type2_marker[] = { 0x02, 0x00, 0x00, 0x00 };
/* NTLM type-2 message structure:
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15ea0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15ec0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x20, -0x38(%rbp)... | /AraHaan[P]curl/lib/vauth/ntlm.c |
Curl_auth_build_spn | char *Curl_auth_build_spn(const char *service, const char *host,
const char *realm)
{
char *spn = NULL;
/* Generate our SPN */
if(host && realm)
spn = aprintf("%s/%s@%s", service, host, realm);
else if(host)
spn = aprintf("%s/%s", service, host);
else if(realm)
spn = apr... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xaf17a
cmpq $0x0, -0x18(%rbp)
je 0xaf17a
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x2038b(%rip), %rdi # 0xcf4f8
movb $0x0,... | /AraHaan[P]curl/lib/vauth/vauth.c |
Curl_tls_keylog_write_line | bool
Curl_tls_keylog_write_line(const char *line)
{
/* The current maximum valid keylog line length LF and NUL is 195. */
size_t linelen;
char buf[256];
if(!keylog_file_fp || !line) {
return FALSE;
}
linelen = strlen(line);
if(linelen == 0 || linelen > sizeof(buf) - 2) {
/* Empty line or too big... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x3e259(%rip) # 0xed900
je 0xaf6b0
cmpq $0x0, -0x10(%rbp)
jne 0xaf6b9
movb $0x0, -0x1(%rbp)
jmp 0xaf740
movq -0x10(%rbp), %rdi
callq 0x10540
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xaf6d7
cmpq $0xfe, -0... | /AraHaan[P]curl/lib/vtls/keylog.c |
ossl_cleanup | static void ossl_cleanup(void)
{
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
/* OpenSSL 1.1 deprecates all these cleanup functions and
turns them into no-ops in OpenSSL 1.0 compatibility mode */
#else
/* Free ciphers and digests lists */
EVP_cleanup();
#ifdef USE_OPENSSL_ENGINE
/* Free engine list */
ENGI... | pushq %rbp
movq %rsp, %rbp
callq 0xaf640
popq %rbp
retq
nopl (%rax,%rax)
| /AraHaan[P]curl/lib/vtls/openssl.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.