name string | code string | asm string | file string |
|---|---|---|---|
curl_easy_getinfo | CURLcode curl_easy_getinfo(struct Curl_easy *data, CURLINFO info, ...)
{
va_list arg;
void *paramp;
CURLcode result;
va_start(arg, info);
paramp = va_arg(arg, void *);
result = Curl_getinfo(data, info, paramp);
va_end(arg);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
testb %al, %al
je 0x80c5ab
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... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
dupset | static CURLcode dupset(struct Curl_easy *dst, struct Curl_easy *src)
{
CURLcode result = CURLE_OK;
enum dupstring i;
enum dupblob j;
/* Copy src->set into dst->set first, then deal with the strings
afterwards */
dst->set = src->set;
Curl_mime_initpart(&dst->set.mimepost, dst);
/* clear all string p... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
movq -0x18(%rbp), %rsi
addq $0x1b0, %rsi # imm = 0x1B0
movl $0x8f0, %edx # imm = 0x8F0
callq 0x3cb70
movq -0x10(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
curl_easy_pause | CURLcode curl_easy_pause(struct Curl_easy *data, int action)
{
struct SingleRequest *k;
CURLcode result = CURLE_OK;
int oldstate;
int newstate;
if(!GOOD_EASY_HANDLE(data) || !data->conn)
/* crazy input, don't continue */
return CURLE_BAD_FUNCTION_ARGUMENT;
k = &data->req;
oldstate = k->keepon & ... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x80cd47
movq -0x10(%rbp), %rax
cmpl $0xc0dedbad, (%rax) # imm = 0xC0DEDBAD
jne 0x80cd47
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x80cd53
movl $0x2b, -0x4(%rbp)
jmp 0x8... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
easy_connection | static CURLcode easy_connection(struct Curl_easy *data, curl_socket_t *sfd,
struct connectdata **connp)
{
if(!data)
return CURLE_BAD_FUNCTION_ARGUMENT;
/* only allow these to be called on handles with CURLOPT_CONNECT_ONLY */
if(!data->set.connect_only) {
failf(data, "CONNE... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x80d144
movl $0x2b, -0x4(%rbp)
jmp 0x80d1ac
movq -0x10(%rbp), %rax
cmpb $0x0, 0xa91(%rax)
jne 0x80d16c
movq -0x10(%rbp), %rdi
leaq 0x392606(%rip), %rsi # 0xb9f762
movb $0x0, %a... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
curl_easy_send | CURLcode curl_easy_send(struct Curl_easy *data, const void *buffer,
size_t buflen, size_t *n)
{
ssize_t written = 0;
CURLcode result;
if(Curl_is_in_callback(data))
return CURLE_RECURSIVE_API_CALL;
result = Curl_senddata(data, buffer, buflen, &written);
*n = (size_t)written;
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x81e4a0
testb $0x1, %al
jne 0x80d2df
jmp 0x80d2e8
movl $0x5d, -0x4(%rbp)
jmp 0x80d311
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
h2_process_pending_input | static int h2_process_pending_input(struct Curl_easy *data,
struct http_conn *httpc,
CURLcode *err)
{
ssize_t nread;
char *inbuf;
ssize_t rv;
nread = httpc->inbuflen - httpc->nread_inbuf;
inbuf = httpc->inbuf + httpc->nread_inbuf;
set... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x88(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x88(%rcx), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
Curl_http2_setup | CURLcode Curl_http2_setup(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result;
struct http_conn *httpc = &conn->proto.httpc;
struct HTTP *stream = data->req.p.http;
DEBUGASSERT(data->state.buffer);
stream->stream_id = -1;
Curl_dyn_init(&stream->header_recvbuf, DY... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x80f23f
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x228(%rax) # imm ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
http2_disconnect | static CURLcode http2_disconnect(struct Curl_easy *data,
struct connectdata *conn,
bool dead_connection)
{
struct http_conn *c = &conn->proto.httpc;
(void)dead_connection;
#ifndef DEBUG_HTTP2
(void)data;
#endif
H2BUGF(infof(data, "HTTP/2 DISCONN... | 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 $0x448, %rax # imm = 0x448
movq %rax, -0x20(%rbp)
jmp 0x810957
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x881ee0
leaq 0x6eba95(%rip... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
decode_status_code | static int decode_status_code(const uint8_t *value, size_t len)
{
int i;
int res;
if(len != 3) {
return -1;
}
res = 0;
for(i = 0; i < 3; ++i) {
char c = value[i];
if(c < '0' || c > '9') {
return -1;
}
res *= 10;
res += c - '0';
}
return res;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
je 0x8122ec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x81234e
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x812348
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
data_source_read_callback | static ssize_t data_source_read_callback(nghttp2_session *session,
int32_t stream_id,
uint8_t *buf, size_t length,
uint32_t *data_flags,
nghttp2_data_source... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x81265a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x88c820... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
curl_mime_data_cb | CURLcode curl_mime_data_cb(curl_mimepart *part, curl_off_t datasize,
curl_read_callback readfunc,
curl_seek_callback seekfunc,
curl_free_callback freefunc, void *arg)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
cleanup_part_co... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x813360
movl $0x2b, -0x4(%rbp)
jmp 0x8133be
movq -0x10(%rbp), %rdi
callq 0x812c30
cmpq $0x0, -0x20(%rbp)
je 0x81... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
Curl_mime_set_subparts | CURLcode Curl_mime_set_subparts(curl_mimepart *part,
curl_mime *subparts, int take_ownership)
{
curl_mime *root;
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
/* Accept setting twice the same subparts. */
if(part->kind == MIMEKIND_MULTIPART && part->arg == subparts)
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x813c66
movl $0x2b, -0x4(%rbp)
jmp 0x813dd1
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x813c8a
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x813... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
Curl_conncache_find_bundle | struct connectbundle *
Curl_conncache_find_bundle(struct Curl_easy *data,
struct connectdata *conn,
struct conncache *connc)
{
struct connectbundle *bundle = NULL;
CONNCACHE_LOCK(data);
if(connc) {
char key[HASHKEY_SIZE];
hashkey(conn, key, sizeof(key)... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x846630
movq -0x8(%rbp), %rdi
movl $0x5, %esi
movl $0x2, %edx
callq 0x82d500
cmpq $0x0, -0x18(%rbp)
je 0x84668b
movq -0x10(%rbp), %rdi
le... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/conncache.c |
bundle_remove_conn | static int bundle_remove_conn(struct connectbundle *bundle,
struct connectdata *conn)
{
struct Curl_llist_element *curr;
curr = bundle->conn_list.head;
while(curr) {
if(curr->ptr == conn) {
Curl_llist_remove(&bundle->conn_list, curr, NULL);
bundle->num_connections--;... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x846b9b
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x846b8d
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x20... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/conncache.c |
Curl_conncache_foreach | bool Curl_conncache_foreach(struct Curl_easy *data,
struct conncache *connc,
void *param,
int (*func)(struct Curl_easy *data,
struct connectdata *conn, void *param))
{
struct Curl_hash_iterator ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x846c58
movb $0x0, -0x1(%rbp)
jmp 0x846d47
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x846c79
movq -0x10(%rbp), %rdi
movl $0x5, %esi
movl $0x2, %edx
c... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/conncache.c |
Curl_connalive | bool Curl_connalive(struct connectdata *conn)
{
/* First determine if ssl */
if(conn->ssl[FIRSTSOCKET].use) {
/* use the SSL context */
if(!Curl_ssl_check_cxn(conn))
return false; /* FIN received */
}
/* Minix 3.1 doesn't support any flags on recv; just assume socket is OK */
#ifdef MSG_PEEK
els... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x228(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8491c6
movq -0x10(%rbp), %rdi
callq 0x844b60
cmpl $0x0, %eax
jne 0x8491c4
movb $0x0, -0x1(%rbp)
jmp 0x84920a
jmp 0x849206
movq -0x10(%rbp), %rax
cmpl $-0x1... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/connect.c |
Curl_get_line | char *Curl_get_line(char *buf, int len, FILE *input)
{
bool partial = FALSE;
while(1) {
char *b = fgets(buf, len, input);
if(b) {
size_t rlen = strlen(b);
if(rlen && (b[rlen-1] == '\n')) {
if(partial) {
partial = FALSE;
continue;
}
return b;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x3d770
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x84eb67
movq -0x30(%rbp), %rdi
callq 0x3b8f0
movq %... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/curl_get_line.c |
Curl_memrchr | void *
Curl_memrchr(const void *s, int c, size_t n)
{
if(n > 0) {
const unsigned char *p = s;
const unsigned char *q = s;
p += n - 1;
while(p >= q) {
if(*p == (unsigned char)c)
return (void *)p;
p--;
}
}
return NULL;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x84ebeb
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/curl_memrchr.c |
Curl_dyn_init | void Curl_dyn_init(struct dynbuf *s, size_t toobig)
{
DEBUGASSERT(s);
DEBUGASSERT(toobig);
s->bufr = NULL;
s->leng = 0;
s->allc = 0;
s->toobig = toobig;
#ifdef DEBUGBUILD
s->init = DYNINIT;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x84ec0e
jmp 0x84ec10
jmp 0x84ec12
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/dynbuf.c |
Curl_dyn_tail | CURLcode Curl_dyn_tail(struct dynbuf *s, size_t trail)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
if(trail > s->leng)
return CURLE_BAD_FUNCTION_ARGUMENT;
else if(trail == s->leng)
return CURLE_OK;
else if(!trail) {
Curl_dyn_reset(s);
}
else {
mem... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x84ecf2
jmp 0x84ecf4
jmp 0x84ecf6
jmp 0x84ecf8
jmp 0x84ecfa
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x84ed11
movl $0x2b, -0x4(%rbp)
jmp 0x84ed8a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmp... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/dynbuf.c |
dyn_nappend | static CURLcode dyn_nappend(struct dynbuf *s,
const unsigned char *mem, size_t len)
{
size_t indx = s->leng;
size_t a = s->allc;
size_t fit = len + indx + 1; /* new string + old string + zero byte */
/* try to detect if there's rubbish in the struct */
DEBUGASSERT(s->init == DYNIN... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/dynbuf.c |
Curl_dyn_addf | CURLcode Curl_dyn_addf(struct dynbuf *s, const char *fmt, ...)
{
CURLcode result;
va_list ap;
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
va_start(ap, fmt);
result = Curl_dyn_vaddf(s, fmt, ap);
va_end(ap);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x84f048
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rb... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/dynbuf.c |
Curl_dyn_setlen | CURLcode Curl_dyn_setlen(struct dynbuf *s, size_t set)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
if(set > s->leng)
return CURLE_BAD_FUNCTION_ARGUMENT;
s->leng = set;
s->bufr[s->leng] = 0;
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x84f12e
jmp 0x84f130
jmp 0x84f132
jmp 0x84f134
jmp 0x84f136
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x84f14d
movl $0x2b, -0x4(%rbp)
jmp 0x84f173
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/dynbuf.c |
Curl_isunreserved | bool Curl_isunreserved(unsigned char in)
{
switch(in) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
case 'a': case 'b': case 'c': case 'd': case 'e':
case 'f': case 'g': case 'h': case 'i': case 'j':
case 'k': case 'l': case 'm': case 'n': ca... | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
addl $-0x2d, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x51, %eax
ja 0x84f1b6
movq -0x10(%rbp), %rax
leaq 0x3557a5(%rip), %rcx # 0xba494c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x84... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/escape.c |
curl_easy_escape | char *curl_easy_escape(struct Curl_easy *data, const char *string,
int inlength)
{
size_t length;
struct dynbuf d;
(void)data;
if(inlength < 0)
return NULL;
Curl_dyn_init(&d, CURL_MAX_INPUT_LENGTH * 3);
length = (inlength?(size_t)inlength:strlen(string));
if(!length)
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x84f226
movq $0x0, -0x8(%rbp)
jmp 0x84f310
leaq -0x48(%rbp), %rdi
movl $0x16e3600, %esi # imm = 0x16E3600
callq 0x84ec00
cmpl $0x0, -0x1c(%rbp)
je 0x84f244
movslq -0x1c(%rb... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/escape.c |
curl_easy_unescape | char *curl_easy_unescape(struct Curl_easy *data, const char *string,
int length, int *olen)
{
char *str = NULL;
(void)data;
if(length >= 0) {
size_t inputlen = length;
size_t outputlen;
CURLcode res = Curl_urldecode(string, inputlen, &str, &outputlen,
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x84f3ef
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x4... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/escape.c |
Curl_urldecode | CURLcode Curl_urldecode(const char *string, size_t length,
char **ostring, size_t *olen,
enum urlreject ctrl)
{
size_t alloc;
char *ns;
size_t strindex = 0;
unsigned long hex;
DEBUGASSERT(string);
DEBUGASSERT(ctrl >= REJECT_NADA); /* crash on TRUE/FALSE */
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq $0x0, -0x48(%rbp)
jmp 0x84f436
jmp 0x84f438
jmp 0x84f43a
cmpq $0x0, -0x18(%rbp)
je 0x84f44b
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x84f458
movq ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/escape.c |
file_setup_connection | static CURLcode file_setup_connection(struct Curl_easy *data,
struct connectdata *conn)
{
(void)conn;
/* allocate the FILE specific struct */
data->req.p.file = calloc(1, sizeof(struct FILEPROTO));
if(!data->req.p.file)
return CURLE_OUT_OF_MEMORY;
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
leaq 0x6acd67(%rip), %rax # 0xefc418
callq *(%rax)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x198(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x198(%rax)
jne 0x84f6d8
movl $0x1b, -0x4(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/file.c |
file_do | static CURLcode file_do(struct Curl_easy *data, bool *done)
{
/* This implementation ignores the host name in conformance with
RFC 1738. Only local files (reachable via the standard file system)
are supported. This means that files on remotely mounted directories
(via NFS, Samba, NT sharing) can be acc... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $-0x1, -0xc8(%rbp)
movb $0x0, -0xca(%rbp)
movq -0x20(%rbp), %rax
movq 0xc70(%rax), %rax
movq %rax, -0xd8(%rbp)
movq $0x0, -0xe0(%rbp)
movq -0x28(%rbp), %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/file.c |
file_connect | static CURLcode file_connect(struct Curl_easy *data, bool *done)
{
char *real_path;
struct FILEPROTO *file = data->req.p.file;
int fd;
#ifdef DOS_FILESYSTEM
size_t i;
char *actual_path;
#endif
size_t real_path_len;
CURLcode result = Curl_urldecode(data->state.up.path, 0, &real_path,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x11d0(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movl $0x4, %r8d
callq 0x84f410
movl ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/file.c |
file_upload | static CURLcode file_upload(struct Curl_easy *data)
{
struct FILEPROTO *file = data->req.p.file;
const char *dir = strchr(file->path, DIRSEP);
int fd;
int mode;
CURLcode result = CURLE_OK;
char *buf = data->state.buffer;
curl_off_t bytecount = 0;
struct_stat file_stat;
const char *buf2;
/*
* Sin... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x3d450
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0xc70(%rax),... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/file.c |
ftp_setup_connection | static CURLcode ftp_setup_connection(struct Curl_easy *data,
struct connectdata *conn)
{
char *type;
struct FTP *ftp;
data->req.p.ftp = ftp = calloc(sizeof(struct FTP), 1);
if(!ftp)
return CURLE_OUT_OF_MEMORY;
ftp->path = &data->state.up.path[1]; /* don't include the... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x20, %edi
movl $0x1, %esi
leaq 0x6abe07(%rip), %rax # 0xefc418
callq *(%rax)
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rcx, 0x198(%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x850638
movl $0x1b, -0x4(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_do | static CURLcode ftp_do(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
*done = FALSE; /* default to false */
ftpc->wait_data_conn = FALSE; /* default to no such wait */
if(data->state.wildcardmatch) {
r... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x3... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_done | static CURLcode ftp_done(struct Curl_easy *data, CURLcode status,
bool premature)
{
struct connectdata *conn = data->conn;
struct FTP *ftp = data->req.p.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
ssize_t nread;
int ftpcode;
CURLcode result = C... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x448, %rax ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_do_more | static CURLcode ftp_do_more(struct Curl_easy *data, int *completep)
{
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result = CURLE_OK;
bool connected = FALSE;
bool complete = FALSE;
/* the ftp struct is inited in ftp_connect(). If we are connecting to an HTTP
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movb $0x0, -0x2d(%rbp)
movb $0x0, -0x2e(%rbp)
movq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_connect | static CURLcode ftp_connect(struct Curl_easy *data,
bool *done) /* see description above */
{
CURLcode result;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
*done = FALSE; /* default to not done yet */
/* We a... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movb... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_multi_statemach | static CURLcode ftp_multi_statemach(struct Curl_easy *data,
bool *done)
{
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result = Curl_pp_statemach(data, &ftpc->pp, FALSE, FALSE);
/* Check for the state outside of the Curl_socket_c... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %ed... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_doing | static CURLcode ftp_doing(struct Curl_easy *data,
bool *dophase_done)
{
CURLcode result = ftp_multi_statemach(data, dophase_done);
if(result)
DEBUGF(infof(data, "DO phase failed"));
else if(*dophase_done) {
result = ftp_dophase_done(data, FALSE /* not connected */);
DEBUGF(... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x851520
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x8515bc
jmp 0x8515b8
jmp 0x8515ba
jmp 0x8515d9
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x8515d7
movq -0x8(%rbp), %rd... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_domore_getsock | static int ftp_domore_getsock(struct Curl_easy *data,
struct connectdata *conn, curl_socket_t *socks)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
(void)data;
/* When in DO_MORE state, we could be either waiting for us to connect to a
* remote site, or we could wait for that site... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jb 0x85167e
movq -0x18(%rbp), %rax
cmpl $0x11, (%rax)
jae 0x85167e
movq -0x18... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_disconnect | static CURLcode ftp_disconnect(struct Curl_easy *data,
struct connectdata *conn,
bool dead_connection)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
/* We cannot send quit unconditionally. If this connection is stale or... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x11(%rbp)
je 0x8517be
movq -0x2... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
Curl_GetFTPResponse | CURLcode Curl_GetFTPResponse(struct Curl_easy *data,
ssize_t *nreadp, /* return number of bytes read */
int *ftpcode) /* return the ftp-code */
{
/*
* We cannot read just one byte per read() and then go back to select() as
* the OpenSSL read() doesn't gr... | 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, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x1e0(%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x448, %rax ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_readresp | static CURLcode ftp_readresp(struct Curl_easy *data,
curl_socket_t sockfd,
struct pingpong *pp,
int *ftpcode, /* return the ftp-code if done */
size_t *size) /* size of the response */
{
int code;
CUR... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
leaq -0x34(%rbp), %rcx
callq 0x86c390
movl %eax, -0x38(%rbp)
movl -0x34... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
state | static void _state(struct Curl_easy *data,
ftpstate newstate
#ifdef DEBUGBUILD
, int lineno
#endif
)
{
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
#if defined(DEBUGBUILD)
#if defined(CURL_DISABLE_VERBOSE_STRINGS)
(void) lineno;
#else
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xd0(%rax)
popq %rbp
retq
nopw %cs:(%... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_statemachine | static CURLcode ftp_statemachine(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result;
curl_socket_t sock = conn->sock[FIRSTSOCKET];
int ftpcode;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
static const char ftpauth[][4] = { "S... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1e0(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
mov... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_endofresp | static bool ftp_endofresp(struct Curl_easy *data, struct connectdata *conn,
char *line, size_t len, int *code)
{
(void)data;
(void)conn;
if((len > 3) && LASTLINE(line)) {
*code = curlx_sltosi(strtol(line, NULL, 10));
return TRUE;
}
return FALSE;
} | 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 %r8, -0x30(%rbp)
cmpq $0x3, -0x28(%rbp)
jbe 0x8529bc
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x8529bc
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_user_resp | static CURLcode ftp_state_user_resp(struct Curl_easy *data,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
(void)instate; /* no use for this yet... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
cmpl $0x14b, -0xc(%rbp) #... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_user | static CURLcode ftp_state_user(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = Curl_pp_sendf(data,
&conn->proto.ftpc.pp, "USER %s",
conn->user?conn->user:"");
if(!result) {
struct ftp_conn *f... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x188(%rax)
je 0x852c05
movq -0x10(%rbp), %rax
movq 0x188(%rax)... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_acct_resp | static CURLcode ftp_state_acct_resp(struct Curl_easy *data,
int ftpcode)
{
CURLcode result = CURLE_OK;
if(ftpcode != 230) {
failf(data, "ACCT rejected by server: %03d", ftpcode);
result = CURLE_FTP_WEIRD_PASS_REPLY; /* FIX */
}
else
result = ftp_state_loggedin(dat... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xe6, -0xc(%rbp)
je 0x852cad
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x352374(%rip), %rsi # 0xba5011
movb $0x0, %al
callq 0x820e10
movl $0xb, -0x10(%rbp)
jmp 0x852cb9
movq -0x8(%rbp), %rdi
ca... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_mdtm | static CURLcode ftp_state_mdtm(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
/* Requested time of file or time-depended transfer? */
if((data->set.get_filetime || data->set.timecondition) && ftpc->file) {
/* we hav... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xa92(%rax), %rax
shrq $0x5, %rax
andq $0x1, %rax... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_mdtm_resp | static CURLcode ftp_state_mdtm_resp(struct Curl_easy *data,
int ftpcode)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
switch(ftpcode) {
case 213:
{
/* we got a... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x44... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_size_resp | static CURLcode ftp_state_size_resp(struct Curl_easy *data,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
curl_off_t filesize = -1;
char *buf = data->state.buffer;
/* get the size from the ascii string: */
if(ftpcode == 21... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xc70(%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0xd5, -0x14(%rbp)
jne 0x853709
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x3... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_rest_resp | static CURLcode ftp_state_rest_resp(struct Curl_easy *data,
struct connectdata *conn,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct ftp_conn *ftpc = &conn->proto.ftpc;
switch(instate)... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x54(%rbp)
subl $0x1a, %eax
je 0x8538... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_use_pasv | static CURLcode ftp_state_use_pasv(struct Curl_easy *data,
struct connectdata *conn)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result = CURLE_OK;
/*
Here's the executive summary on what to do:
PASV is RFC959, expect:
227 Entering Passive Mode (a1,a2,a3,a... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x374(%rax), %eax
shrl $0x12, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x8539cb
movq -0x10(... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_pasv_resp | static CURLcode ftp_state_pasv_resp(struct Curl_easy *data,
int ftpcode)
{
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result;
struct Curl_dns_entry *addr = NULL;
enum resolve_t rc;
unsigned short connectport; /* the local po... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0xc70(%rax), %rax
addq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_port_resp | static CURLcode ftp_state_port_resp(struct Curl_easy *data,
int ftpcode)
{
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
ftpport fcmd = (ftpport)ftpc->count1;
CURLcode result = CURLE_OK;
/* The FTP spec tells a positive response should h... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0xc4(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_get_resp | static CURLcode ftp_state_get_resp(struct Curl_easy *data,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct connectdata *conn = data->conn;
if((ftpcode == 150) || (ftpcode == 125)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x96, -0x14(%rbp)
je 0x854337
cmpl $0x7d,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_stor_resp | static CURLcode ftp_state_stor_resp(struct Curl_easy *data,
int ftpcode, ftpstate instate)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
if(ftpcode >= 400) {
failf(data, "Failed FTP upload: %0d", ftpcode);
state(data, FTP_STOP);
/* oops, we n... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x190, -0x14(%rbp) # imm = 0x190
jl 0x85466a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x351187(%... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_loggedin | static CURLcode ftp_state_loggedin(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
if(conn->bits.ftp_use_control_ssl) {
/* PBSZ = PROTECTION BUFFER SIZE.
The 'draft-murray-auth-ftp-ssl' (draft 12, page 7) says:
Specifically, the PROT command MUST be prec... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x374(%rax), %eax
shrl $0x15, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x85477c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x448, ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_cwd | static CURLcode ftp_state_cwd(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(ftpc->cwddone)
/* already done and fine */
result = ftp_state_mdtm(data);
else {
/* FTPFILE_NOCWD with full path:... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0xa6(%rax)
je 0x8547e3
movq -0x8(%rbp), %rdi
callq 0x853040
movl %eax, -0x14(%rbp)
j... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_retr | static CURLcode ftp_state_retr(struct Curl_easy *data,
curl_off_t filesize)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(data->set.max_filesize && (filesize > data->set.max_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_ul_setup | static CURLcode ftp_state_ul_setup(struct Curl_easy *data,
bool sizechecked)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct FTP *ftp = data->req.p.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
bool append = data->set.remote_append;
if((data-... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x448, %rax ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_type | static CURLcode ftp_state_type(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
/* If we have selected NOBODY and HEADER, it means that we only want file
information. Which in FTP ca... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x30(%rbp)
movq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_nb_type | static CURLcode ftp_nb_type(struct Curl_easy *data,
struct connectdata *conn,
bool ascii, ftpstate newstate)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result;
char want = (char)(ascii?'A':'I');
if(ftpc->transfertype == want) {
state(data, ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %dl
movl $0x49, %eax
movl $0x41, %ecx
testb $0x1,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_size | static CURLcode ftp_state_size(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer == PPTRANSFER_INFO) && ftpc->file) {
/* if a "head"-like request is b... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_rest | static CURLcode ftp_state_rest(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer != PPTRANSFER_BODY) && ftpc->file) {
/* if a "head"-like request is b... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x8... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_prepare_transfer | static CURLcode ftp_state_prepare_transfer(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct connectdata *conn = data->conn;
if(ftp->transfer != PPTRANSFER_BODY) {
/* doesn't transfer any data */
/* still possibly do PRE QUOTE jobs */
state(data, FTP_R... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x855271
movq -0x8(%rbp), %rdi
movl $0xd, %esi
ca... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_pl_get_permission | static int ftp_pl_get_permission(const char *str)
{
int permissions = 0;
/* USER */
if(str[0] == 'r')
permissions |= 1 << 8;
else if(str[0] != '-')
permissions |= FTP_LP_MALFORMATED_PERM;
if(str[1] == 'w')
permissions |= 1 << 7;
else if(str[1] != '-')
permissions |= FTP_LP_MALFORMATED_PERM;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x859a28
movl -0xc(%rbp), %eax
orl $0x100, %eax # imm = 0x100
movl %eax, -0xc(%rbp)
jmp 0x859a41
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x859a3f
movl -0... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftplistparser.c |
GetEnv | static char *GetEnv(const char *variable)
{
#if defined(_WIN32_WCE) || defined(CURL_WINDOWS_APP)
(void)variable;
return NULL;
#elif defined(WIN32)
/* This uses Windows API instead of C runtime getenv() to get the environment
variable since some changes aren't always visible to the latter. #4774 */
char *bu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3da30
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x859f32
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x859f32
leaq 0x6a24ed(%rip), %rax # 0xefc410
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/getenv.c |
inspect_header | static header_instruction inspect_header(const char *name, size_t namelen,
const char *value, size_t valuelen) {
switch(namelen) {
case 2:
if(!strncasecompare("te", name, namelen))
return HEADERINST_FORWARD;
return contains_trailers(value, valuelen) ?
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x30(%rbp)
subq $0xf, %rax
ja 0x85a8eb
movq -0x30(%rbp), %rax
leaq 0x34b44f(%rip), %rcx # 0xba5c18
movslq (%rcx,%rax,4), %rax
add... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/h2h3.c |
Curl_hash_init | void
Curl_hash_init(struct Curl_hash *h,
int slots,
hash_function hfunc,
comp_function comparator,
Curl_hash_dtor dtor)
{
DEBUGASSERT(h);
DEBUGASSERT(slots);
DEBUGASSERT(hfunc);
DEBUGASSERT(comparator);
DEBUGASSERT(dtor);
h->table = NULL;
h->has... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
jmp 0x85aad9
jmp 0x85aadb
jmp 0x85aadd
jmp 0x85aadf
jmp 0x85aae1
jmp 0x85aae3
jmp 0x85aae5
jmp 0x85aae7
jmp 0x85aae9
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
m... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hash.c |
copy_header_external | static void copy_header_external(struct Curl_easy *data,
struct Curl_header_store *hs,
size_t index,
size_t amount,
struct Curl_llist_element *e,
struct cu... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0xc30, %rax # imm = 0xC30
addq $0x620, %rax # imm = 0x620
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq %rax... | /JKorbelRA[P]CMake/Utilities/cmcurl/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_element *pick;
struct Curl_ll... | 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, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movl -0x18(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0xd40(%rcx), %eax
jle 0x85b69a
movq $0x0,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/headers.c |
namevalue | static CURLcode namevalue(char *header, size_t hlen, unsigned int type,
char **name, char **value)
{
char *end = header + hlen - 1; /* point to the last byte */
DEBUGASSERT(hlen);
*name = header;
if(type == CURLH_PSEUDO) {
if(*header != ':')
return CURLE_BAD_FUNCTION_ARGUME... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x85bc99
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x10, -0x1... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/headers.c |
Curl_hostcache_prune | void Curl_hostcache_prune(struct Curl_easy *data)
{
time_t now;
if((data->set.dns_cache_timeout == -1) || !data->dns.hostcache)
/* cache forever means never prune, and NULL hostcache means
we can't do it */
return;
if(data->share)
Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SIN... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x6c8(%rax)
je 0x85bfd7
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x85bfd9
jmp 0x85c03e
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x85bffa
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x82d500
l... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hostip.c |
hostcache_prune | static void
hostcache_prune(struct Curl_hash *hostcache, long cache_timeout, time_t now)
{
struct hostcache_prune_data user;
user.cache_timeout = cache_timeout;
user.now = now;
Curl_hash_clean_with_criterium(hostcache,
(void *) &user,
hostcache... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq 0x1b2d(%rip), %rdx # 0x85dbb0
callq 0x85b050
addq $0x30, %rsp... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hostip.c |
Curl_fetch_addr | struct Curl_dns_entry *
Curl_fetch_addr(struct Curl_easy *data,
const char *hostname,
int port)
{
struct Curl_dns_entry *dns = NULL;
if(data->share)
Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
dns = fetch_addr(data, hostname, port);
if(dns)
dns-... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x85c0cc
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x82d500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp... | /JKorbelRA[P]CMake/Utilities/cmcurl/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 = Curl_num_addresses(*addr);
if(num_addrs > 1) {
struct Curl_addrinfo **nodes;
infof(data, "Shuffling %i addresses", num_addrs);
... | 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 0x85bec0
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jle 0x85c735
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x349a2c(%rip), %rsi # 0xba5f7a
movb $0x... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hostip.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 0x85fc4c
movq -0x10(%rbp), %rax
addq $0xc30, %rax # imm = 0xC30
addq $0x... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_http_range | CURLcode Curl_http_range(struct Curl_easy *data,
Curl_HttpReq httpreq)
{
if(data->state.use_range) {
/*
* A range is selected. We use different headers whether we're downloading
* or uploading and we always let customized headers override our internal
* ones if any such are... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x1300(%rax), %eax
shrl $0x9, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8637df
cmpl $0x0, -0x14(%rbp)
je 0x863644
cmpl $0x5, -0x14(%rbp)
jne 0x8636a2
movq -0x10(%rbp), %rdi
leaq 0x342d04(%rip), %rsi ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_transferencode | CURLcode Curl_transferencode(struct Curl_easy *data)
{
if(!Curl_checkheaders(data, STRCONST("TE")) &&
data->set.http_transfer_encoding) {
/* When we are to insert a TE: header in the request, we must also insert
TE in a Connection: header, so we need to merge the custom provided
Connection: hea... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x34012c(%rip), %rsi # 0xba3d83
movl $0x2, %edx
callq 0x8312b0
cmpq $0x0, %rax
jne 0x863d92
movq -0x10(%rbp), %rax
movq 0xa92(%rax), %rax
shrq $0x14, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x863d92
movq -0x10(%rbp), %rdi
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_http_statusline | CURLcode Curl_http_statusline(struct Curl_easy *data,
struct connectdata *conn)
{
struct SingleRequest *k = &data->req;
data->info.httpcode = k->httpcode;
data->info.httpversion = conn->httpversion;
if(!data->state.httpversion ||
data->state.httpversion > conn->httpversion)
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x70(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1358(%rax)
movq -0x10(%rbp), %rax
movzbl 0x57f(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ec... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_proxyCONNECT | CURLcode Curl_proxyCONNECT(struct Curl_easy *data,
int sockindex,
const char *hostname,
int remote_port)
{
CURLcode result;
struct connectdata *conn = data->conn;
if(!conn->connect_state) {
result = connect_init(data, FALSE);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x540(%rax)
jne 0x86722e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x867470
mov... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_proxy.c |
trim_headers | static void trim_headers(struct curl_slist *head)
{
struct curl_slist *l;
for(l = head; l; l = l->next) {
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 0x869a6d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3170de(%rip), %rsi # 0xb809db
callq 0x3da90
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_aws_sigv4.c |
Curl_pp_sendf | CURLcode Curl_pp_sendf(struct Curl_easy *data, struct pingpong *pp,
const char *fmt, ...)
{
CURLcode result;
va_list ap;
va_start(ap, fmt);
result = Curl_pp_vsendf(data, pp, fmt, ap);
va_end(ap);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x86c31b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rb... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/pingpong.c |
Curl_pp_flushsend | CURLcode Curl_pp_flushsend(struct Curl_easy *data,
struct pingpong *pp)
{
/* we have a piece of a command still left to send */
struct connectdata *conn = data->conn;
ssize_t written;
curl_socket_t sock = conn->sock[FIRSTSOCKET];
CURLcode result = Curl_write(data, sock, pp->sendthis... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1e0(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
mo... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/pingpong.c |
Curl_rename | int Curl_rename(const char *oldpath, const char *newpath)
{
#ifdef WIN32
/* rename() on Windows doesn't overwrite, so we can't use it here.
MoveFileEx() will overwrite and is usually atomic, however it fails
when there are open handles to the file. */
const int max_wait_ms = 1000;
struct curltime start ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3e340
cmpl $0x0, %eax
je 0x86ca5b
movl $0x1, -0x4(%rbp)
jmp 0x86ca62
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/rename.c |
Curl_sha256it | CURLcode Curl_sha256it(unsigned char *output, const unsigned char *input,
const size_t length)
{
CURLcode result;
my_sha256_ctx ctx;
result = my_sha256_init(&ctx);
if(!result) {
my_sha256_update(&ctx, input, curlx_uztoui(length));
my_sha256_final(output, &ctx);
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x86cad0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x86cac3
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x840870
movq -0x30(%rbp), %rsi
movl... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/sha256.c |
smb_setup_connection | static CURLcode smb_setup_connection(struct Curl_easy *data,
struct connectdata *conn)
{
struct smb_request *req;
/* Initialize the request state */
data->req.p.smb = req = calloc(1, sizeof(struct smb_request));
if(!req)
return CURLE_OUT_OF_MEMORY;
/* Parse the URL p... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
leaq 0x68f857(%rip), %rax # 0xefc418
callq *(%rax)
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rcx, 0x198(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x86cbe5
movl $0x1b, -0x4(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/smb.c |
smb_connection_state | static CURLcode smb_connection_state(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
struct smb_conn *smbc = &conn->proto.smbc;
struct smb_negotiate_response *nrsp;
struct smb_header *h;
CURLcode result;
void *msg = NULL;
if(smbc->state == SMB_CONNECTING) {
#ifdef USE_SSL
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x86c... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/smb.c |
smb_flush | static CURLcode smb_flush(struct Curl_easy *data)
{
struct connectdata *conn = data->conn;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
struct smb_conn *smbc = &conn->proto.smbc;
ssize_t bytes_written;
ssize_t len = smbc->send_size - smbc->sent;
CURLcode result;
if(!smbc->send_size)
return CURLE_O... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1e0(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/smb.c |
smb_send_open | static CURLcode smb_send_open(struct Curl_easy *data)
{
struct smb_request *req = data->req.p.smb;
struct smb_nt_create msg;
size_t byte_count;
if((strlen(req->path) + 1) > sizeof(msg.bytes))
return CURLE_FILESIZE_EXCEEDED;
memset(&msg, 0, sizeof(msg));
msg.word_count = SMB_WC_NT_CREATE_ANDX;
msg.an... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3b8f0
addq $0x1, %rax
cmpq $0x400, %rax # imm = 0x400
jbe 0x86e4e3
movl $0x3f, -0x4(%rbp)
jmp 0... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/smb.c |
ossl_cleanup | static void ossl_cleanup(void)
{
#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && \
!defined(LIBRESSL_VERSION_NUMBER)
/* 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_O... | pushq %rbp
movq %rsp, %rbp
callq 0x87fed0
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/openssl.c |
ossl_version | static size_t ossl_version(char *buffer, size_t size)
{
#ifdef LIBRESSL_VERSION_NUMBER
#ifdef HAVE_OPENSSL_VERSION
char *p;
int count;
const char *ver = OpenSSL_version(OPENSSL_VERSION);
const char expected[] = OSSL_PACKAGE " "; /* ie "LibreSSL " */
if(Curl_strncasecompare(ver, expected, sizeof(expected) - 1)... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x6, %edi
callq 0x3c6b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %r8
leaq 0x36c0d3(%rip), %rdx # 0xbdde2f
leaq 0x33... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/openssl.c |
ossl_check_cxn | static int ossl_check_cxn(struct connectdata *conn)
{
/* SSL_peek takes data out of the raw recv buffer without peeking so we use
recv MSG_PEEK instead. Bug #795 */
#ifdef MSG_PEEK
char buf;
ssize_t nread;
nread = recv((RECV_TYPE_ARG1)conn->sock[FIRSTSOCKET], (RECV_TYPE_ARG2)&buf,
(RECV_TYPE... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1e0(%rax), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x3c470
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x871dbd
movl $0x0, -0x4(%rbp)
jmp 0x871e31
cmpq $0x1, -0x20(%rbp)
jne 0x871dcd
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/openssl.c |
ossl_cert_status_request | static bool ossl_cert_status_request(void)
{
#if (OPENSSL_VERSION_NUMBER >= 0x0090808fL) && !defined(OPENSSL_NO_TLSEXT) && \
!defined(OPENSSL_NO_OCSP)
return TRUE;
#else
return FALSE;
#endif
} | pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/openssl.c |
ossl_connect | static CURLcode ossl_connect(struct Curl_easy *data, struct connectdata *conn,
int sockindex)
{
CURLcode result;
bool done = FALSE;
result = ossl_connect_common(data, conn, sockindex, FALSE, &done);
if(result)
return result;
DEBUGASSERT(done);
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
leaq -0x21(%rbp), %r8
callq 0x873550
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x87232e
movl... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/openssl.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, (%... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/md4.c |
hostmatch | static bool hostmatch(const char *hostname,
size_t hostlen,
const char *pattern,
size_t patternlen)
{
const char *pattern_label_end, *wildcard, *hostname_label_end;
size_t prefixlen, suffixlen;
/* normalize pattern and hostname by stripping off tr... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0x87fbaa
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x87fbcb
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/hostcheck.c |
Curl_tls_keylog_open | void
Curl_tls_keylog_open(void)
{
char *keylog_file_name;
if(!keylog_file_fp) {
keylog_file_name = curl_getenv("SSLKEYLOGFILE");
if(keylog_file_name) {
keylog_file_fp = fopen(keylog_file_name, FOPEN_APPENDTEXT);
if(keylog_file_fp) {
#ifdef WIN32
if(setvbuf(keylog_file_fp, NULL, _IONBF, ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x687b68(%rip) # 0xf07998
jne 0x87fec4
leaq 0x32912e(%rip), %rdi # 0xba8f6b
callq 0x859ed0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x87fec2
movq -0x8(%rbp), %rdi
leaq 0x2e77a3(%rip), %rsi # 0xb675fb
callq 0x3e0f0
movq %rax, 0x687b34(%rip) # 0xf07... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/keylog.c |
nghttp2_session_detach_idle_stream | void nghttp2_session_detach_idle_stream(nghttp2_session *session,
nghttp2_stream *stream) {
nghttp2_stream *prev_stream, *next_stream;
DEBUGF("stream: detach idle stream(%p)=%d, state=%d\n", stream,
stream->stream_id, stream->state);
prev_stream = stream->closed_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x88324e
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x883284
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x88(%r... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.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.