name string | code string | asm string | file string |
|---|---|---|---|
Curl_HMAC_final | int Curl_HMAC_final(HMAC_context *ctxt, unsigned char *result)
{
const HMAC_params * hashparams = ctxt->hmac_hash;
/* Do not get result if called with a null parameter: only release
storage. */
if(!result)
result = (unsigned char *) ctxt->hmac_hashctxt2 +
ctxt->hmac_hash->hmac_ctxtsize;
(*hashp... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x576ab
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x18(%rcx), %ecx
addq %rcx, %rax
movq %rax, ... | /macressler[P]curl/lib/hmac.c |
gopher_do | static CURLcode gopher_do(struct connectdata *conn, bool *done)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
curl_off_t *bytecount = &data->req.bytecount;
char *path = data->state.path;
char *sel = NULL;
char *sel_org = NULL;
ssize_t... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x258(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
addq $0xc0, %rax
addq $0x20, %rax
movq %rax, -0x38(... | /macressler[P]curl/lib/gopher.c |
Curl_proxy_connect | CURLcode Curl_proxy_connect(struct connectdata *conn, int sockindex)
{
if(conn->http_proxy.proxytype == CURLPROXY_HTTPS) {
const CURLcode result = https_proxy_connect(conn, sockindex);
if(result)
return result;
if(!conn->bits.proxy_ssl_connected[sockindex])
return result; /* wait for HTTPS pro... | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x178(%rax)
jne 0x57a7e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x57c10
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x57a5f
movl -0x18(%rbp), %eax
movl %... | /macressler[P]curl/lib/http_proxy.c |
destroy_async_data | static void destroy_async_data(struct Curl_async *async)
{
if(async->os_specific) {
struct thread_data *td = (struct thread_data*) async->os_specific;
int done;
/*
* if the thread is still blocking in the resolve syscall, detach it and
* let the thread do the cleanup...
*/
Curl_mutex_a... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x590c0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x9ec0
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movq -... | /macressler[P]curl/lib/asyn-thread.c |
Curl_resolver_wait_resolv | CURLcode Curl_resolver_wait_resolv(struct connectdata *conn,
struct Curl_dns_entry **entry)
{
struct thread_data *td = (struct thread_data*) conn->async.os_specific;
CURLcode result = CURLE_OK;
DEBUGASSERT(conn && td);
/* wait for the thread to resolve the name */
if(Cur... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x610(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
jmp 0x59118
movq -0x18(%rbp), %rdi
callq 0x571b0
cmpl $0x0, %eax
je 0x59134
movq -0x8(%rbp), %rdi
callq 0x591b0
movl %eax, -0x1c(%rbp)
jmp 0... | /macressler[P]curl/lib/asyn-thread.c |
destroy_thread_sync_data | static
void destroy_thread_sync_data(struct thread_sync_data * tsd)
{
if(tsd->mtx) {
Curl_mutex_destroy(tsd->mtx);
free(tsd->mtx);
}
free(tsd->hostname);
if(tsd->res)
Curl_freeaddrinfo(tsd->res);
memset(tsd, 0, sizeof(*tsd));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x59915
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9bd0
leaq 0x3a147(%rip), %rax # 0x93a50
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
leaq 0x3a134(%rip), %rax # 0x93a50
mo... | /macressler[P]curl/lib/asyn-thread.c |
init_thread_sync_data | static
int init_thread_sync_data(struct thread_data * td,
const char *hostname,
int port,
const struct addrinfo *hints)
{
struct thread_sync_data *tsd = &td->tsd;
memset(tsd, 0, sizeof(*tsd));
tsd->td = td;
tsd->port = port;
/*... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x9520
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %... | /macressler[P]curl/lib/asyn-thread.c |
Curl_input_ntlm | CURLcode Curl_input_ntlm(struct connectdata *conn,
bool proxy, /* if proxy or not */
const char *header) /* rest of the www-authenticate:
header */
{
/* point to the correct struct with this */
struct ntlmdata ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
testb $0x1, -0x11(%rbp)
je 0x59bc5
movq -0x10(%rbp), %rax
addq $0x4d0, %rax # imm = 0x4D0
movq %rax, -0x38(%rbp)
jmp 0x59bd3
movq -0x10(%rbp), %... | /macressler[P]curl/lib/http_ntlm.c |
Curl_output_ntlm | CURLcode Curl_output_ntlm(struct connectdata *conn, bool proxy)
{
char *base64 = NULL;
size_t len = 0;
CURLcode result;
/* point to the address of the pointer that holds the string to send to the
server, which is for a plain host or for a HTTP proxy */
char **allocuserpwd;
/* point to the name and pa... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x59d96
jmp 0x59d98
jmp 0x59d9a
testb $0x1, -0x11(%rbp)
je 0x59df3
movq -0x10(%rbp), %rax
addq $0x3f0, %rax # imm = 0x3F0
movq %rax, -0x38(%... | /macressler[P]curl/lib/http_ntlm.c |
Curl_ntlm_core_lm_resp | void Curl_ntlm_core_lm_resp(const unsigned char *keys,
const unsigned char *plaintext,
unsigned char *results)
{
#ifdef USE_OPENSSL
DES_key_schedule ks;
setup_des_key(keys, DESKEY(ks));
DES_ecb_encrypt((DES_cblock*) plaintext, (DES_cblock*) results,
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x5a110
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdx
movl $0x1, %ecx
callq 0x9450
movq -0x8(%rbp), %rdi
addq $0x7, %rdi
leaq -0x98(%r... | /macressler[P]curl/lib/curl_ntlm_core.c |
Curl_ntlm_core_mk_lm_hash | CURLcode Curl_ntlm_core_mk_lm_hash(struct Curl_easy *data,
const char *password,
unsigned char *lmbuffer /* 21 bytes */)
{
CURLcode result;
unsigned char pw[14];
static const unsigned char magic[] = {
0x4B, 0x47, 0x53, 0x21, 0x40, 0x23, 0x2... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x93b0
cmpq $0xe, %rax
jae 0x5a188
movq -0x18(%rbp), %rdi
callq 0x93b0
movq %rax, -0xc8(%rbp)
jmp 0x5a196
movl $0xe, %eax
movq %rax, -0xc8(%rbp)
jmp 0x5a196
movq -0xc8(%rbp), %ra... | /macressler[P]curl/lib/curl_ntlm_core.c |
Curl_ntlm_core_mk_nt_hash | CURLcode Curl_ntlm_core_mk_nt_hash(struct Curl_easy *data,
const char *password,
unsigned char *ntbuffer /* 21 bytes */)
{
size_t len = strlen(password);
unsigned char *pw = len ? malloc(len * 2) : strdup("");
CURLcode result;
if(!pw)
ret... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x93b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5a2b7
leaq 0x397a6(%rip), %rax # 0x93a48
movq (%rax), %rax
movq -0x28(%rbp), %rdi
shlq %rdi
callq *%rax
movq %rax, -... | /macressler[P]curl/lib/curl_ntlm_core.c |
Curl_sasl_cleanup | void Curl_sasl_cleanup(struct connectdata *conn, unsigned int authused)
{
#if defined(USE_KERBEROS5)
/* Cleanup the gssapi structure */
if(authused == SASL_MECH_GSSAPI) {
Curl_auth_gssapi_cleanup(&conn->krb5);
}
#endif
#if defined(USE_NTLM)
/* Cleanup the NTLM structure */
if(authused == SASL_MECH_NTLM) ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jne 0x5a995
movq -0x8(%rbp), %rdi
addq $0x4b0, %rdi # imm = 0x4B0
callq 0x702b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /macressler[P]curl/lib/curl_sasl.c |
Curl_sasl_decode_mech | unsigned int Curl_sasl_decode_mech(const char *ptr, size_t maxlen, size_t *len)
{
unsigned int i;
char c;
for(i = 0; mechtable[i].name; i++) {
if(maxlen >= mechtable[i].len &&
!memcmp(ptr, mechtable[i].name, mechtable[i].len)) {
if(len)
*len = mechtable[i].len;
if(maxlen == mechta... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x37ef9(%rip), %rax # 0x928c0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x5ab14
movq -0x18(%rbp), %rax
movl -0x24(%rb... | /macressler[P]curl/lib/curl_sasl.c |
Curl_sasl_init | void Curl_sasl_init(struct SASL *sasl, const struct SASLproto *params)
{
sasl->params = params; /* Set protocol dependent parameters */
sasl->state = SASL_STOP; /* Not yet running */
sasl->authmechs = SASL_AUTH_NONE; /* No known authentication mechanism yet */
sasl->prefmech = SASL_AUTH_DEFAUL... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffdf, 0x10(%rax) # imm = 0xFFFFFFDF
movq -0x8(%rbp), %rax
movl $0... | /macressler[P]curl/lib/curl_sasl.c |
Curl_rand | CURLcode Curl_rand(struct Curl_easy *data, unsigned char *rnd, size_t num)
{
CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
DEBUGASSERT(num > 0);
while(num) {
unsigned int r;
size_t left = num < sizeof(unsigned int) ? num : sizeof(unsigned int);
result = randit(data, &r);
if(result)
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x2b, -0x24(%rbp)
jmp 0x5b94d
jmp 0x5b94f
cmpq $0x0, -0x20(%rbp)
je 0x5b9e8
cmpq $0x4, -0x20(%rbp)
jae 0x5b96b
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5b976
movl $0x4, %eax
movq %rax, -0x38... | /macressler[P]curl/lib/rand.c |
randit | static CURLcode randit(struct Curl_easy *data, unsigned int *rnd)
{
unsigned int r;
CURLcode result = CURLE_OK;
static unsigned int randseed;
static bool seeded = FALSE;
#ifdef CURLDEBUG
char *force_entropy = getenv("CURL_ENTROPY");
if(force_entropy) {
if(!seeded) {
unsigned int seed = 0;
s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x79850
movl %eax, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
je 0x5ba3d
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5bb49
testb $0x1, 0x382... | /macressler[P]curl/lib/rand.c |
Curl_rand_hex | CURLcode Curl_rand_hex(struct Curl_easy *data, unsigned char *rnd,
size_t num)
{
CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
const char *hex = "0123456789abcdef";
unsigned char buffer[128];
unsigned char *bufp = buffer;
DEBUGASSERT(num > 1);
#ifdef __clang_analyzer__
/* This silen... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x2b, -0x24(%rbp)
leaq 0x26e8e(%rip), %rax # 0x82a13
movq %rax, -0x30(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0xb8(%rbp)
jmp 0x5bb99
movq -0x20(%rbp), %rax
shrq %rax
cmpq $0x80, %rax
jae 0x5bbb6
m... | /macressler[P]curl/lib/rand.c |
Curl_cert_hostcheck | int Curl_cert_hostcheck(const char *match_pattern, const char *hostname)
{
char *matchp;
char *hostp;
int res = 0;
if(!match_pattern || !*match_pattern ||
!hostname || !*hostname) /* sanity check */
;
else {
matchp = strdup(match_pattern);
if(matchp) {
hostp = strdup(hostname);
i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5bcd7
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5bcd7
cmpq $0x0, -0x10(%rbp)
je 0x5bcd7
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x5bcd9
jmp 0x5bd4a
leaq 0x37d80(%rip), %rax ... | /macressler[P]curl/lib/hostcheck.c |
Curl_conncache_init | int Curl_conncache_init(struct conncache *connc, int size)
{
int rc;
/* allocate a new easy handle to use when closing cached connections */
connc->closure_handle = curl_easy_init();
if(!connc->closure_handle)
return 1; /* bad */
rc = Curl_hash_init(&connc->hash, size, Curl_hash_str,
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x9250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x5c003
movl $0x1, -0x4(%rbp)
jmp 0x5c061
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x1e2c1(%rip)... | /macressler[P]curl/lib/conncache.c |
hashkey | static void hashkey(struct connectdata *conn, char *buf,
size_t len) /* something like 128 is fine */
{
const char *hostname;
if(conn->bits.socksproxy)
hostname = conn->socks_proxy.host.name;
else if(conn->bits.httpproxy)
hostname = conn->http_proxy.host.name;
else if(conn->bits.con... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x38f(%rax)
je 0x5c2e2
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5c331
movq -0x8(%rbp), %rax
testb $0x1, 0x38e(%rax)
je 0x5c300
movq -0x8(%rbp... | /macressler[P]curl/lib/conncache.c |
Curl_conncache_add_conn | CURLcode Curl_conncache_add_conn(struct conncache *connc,
struct connectdata *conn)
{
CURLcode result;
struct connectbundle *bundle;
struct connectbundle *new_bundle = NULL;
struct Curl_easy *data = conn->data;
/* *find_bundle() locks the connection cache */
bundle = Curl_c... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0xc68(%rax), %rsi
callq 0x5c200
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5c418
mov... | /macressler[P]curl/lib/conncache.c |
bundle_add_conn | static CURLcode bundle_add_conn(struct connectbundle *cb_ptr,
struct connectdata *conn)
{
Curl_llist_insert_next(&cb_ptr->conn_list, cb_ptr->conn_list.tail, conn,
&conn->bundle_node);
conn->bundle = cb_ptr;
cb_ptr->num_connections++;
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
callq 0x3d2b0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x738(%rax)
movq... | /macressler[P]curl/lib/conncache.c |
Curl_conncache_remove_conn | void Curl_conncache_remove_conn(struct connectdata *conn, bool lock)
{
struct Curl_easy *data = conn->data;
struct connectbundle *bundle = conn->bundle;
struct conncache *connc = data->state.conn_cache;
/* The bundle pointer can be NULL, since this function can be called
due to a failed connection attempt... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x738(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0xc68(%rax), %rax
movq %rax, -0x28(%rbp)
cmp... | /macressler[P]curl/lib/conncache.c |
Curl_conncache_foreach | bool Curl_conncache_foreach(struct Curl_easy *data,
struct conncache *connc,
void *param,
int (*func)(struct connectdata *conn, void *param))
{
struct curl_hash_iterator iter;
struct curl_llist_element *curr;
struct curl_hash_elem... | 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 0x5c878
movb $0x0, -0x1(%rbp)
jmp 0x5c963
movq -0x10(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x5c899
movq -0x10(%rbp), %rdi
movl $0x5, %esi
movl $0x2, %edx
call... | /macressler[P]curl/lib/conncache.c |
Curl_conncache_return_conn | bool Curl_conncache_return_conn(struct connectdata *conn)
{
struct Curl_easy *data = conn->data;
/* data->multi->maxconnects can be negative, deal with it. */
size_t maxconnects =
(data->multi->maxconnects < 0) ? data->multi->num_easy * 4:
data->multi->maxconnects;
struct connectdata *conn_candidate = ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
cmpq $0x0, 0x150(%rax)
jge 0x5ca35
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movl 0x18(%rax), %eax
shll $0x2, %eax
cltq
movq %rax, -0x28(%rbp)
... | /macressler[P]curl/lib/conncache.c |
Curl_conncache_extract_oldest | struct connectdata *
Curl_conncache_extract_oldest(struct Curl_easy *data)
{
struct conncache *connc = data->state.conn_cache;
struct curl_hash_iterator iter;
struct curl_llist_element *curr;
struct curl_hash_element *he;
timediff_t highscore =- 1;
timediff_t score;
struct curltime now;
struct connectda... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xc68(%rax), %rax
movq %rax, -0x10(%rbp)
movq $-0x1, -0x40(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x70(%rbp)
callq 0xb150
movq %rax, -0x80(%rbp)
movl %edx, -0x78(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x78(... | /macressler[P]curl/lib/conncache.c |
Curl_pipeline_penalized | bool Curl_pipeline_penalized(struct Curl_easy *data,
struct connectdata *conn)
{
if(data) {
bool penalized = FALSE;
curl_off_t penalty_size =
Curl_multi_content_length_penalty_size(data->multi);
curl_off_t chunk_penalty_size =
Curl_multi_chunk_length_penalty_size(d... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5d0a0
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x42c40
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x42c70
movq %rax, -0x30(%rbp)
movq $-0x... | /macressler[P]curl/lib/pipeline.c |
Curl_add_handle_to_pipeline | CURLcode Curl_add_handle_to_pipeline(struct Curl_easy *handle,
struct connectdata *conn)
{
struct curl_llist_element *sendhead = conn->send_pipe.head;
struct curl_llist *pipeline;
CURLcode result;
pipeline = &conn->send_pipe;
result = addHandleToPipeline(handle, pipeline... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x448(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x448, %rax # imm = 0x448
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5d140
movl %eax, -0x... | /macressler[P]curl/lib/pipeline.c |
smb_setup_connection | static CURLcode smb_setup_connection(struct connectdata *conn)
{
struct smb_request *req;
/* Initialize the request state */
conn->data->req.protop = req = calloc(1, sizeof(struct smb_request));
if(!req)
return CURLE_OUT_OF_MEMORY;
/* Parse the URL path */
return smb_parse_url_path(conn);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
leaq 0x35e2b(%rip), %rax # 0x93a68
callq *(%rax)
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x1e8(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x5dc64
movl $0x1b, -0x4(%rbp)
jmp 0x... | /macressler[P]curl/lib/smb.c |
curl_mime_init | curl_mime *curl_mime_init(struct Curl_easy *easy)
{
curl_mime *mime;
mime = (curl_mime *) malloc(sizeof *mime);
if(mime) {
mime->easy = easy;
mime->parent = NULL;
mime->firstpart = NULL;
mime->lastpart = NULL;
/* Get a part boundary. */
mime->boundary = malloc(24 + MIME_RAND_BOUNDARY_CH... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x40, %edi
leaq 0x338e0(%rip), %rax # 0x93a48
callq *(%rax)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6022a
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), ... | /macressler[P]curl/lib/mime.c |
mime_file_free | static void mime_file_free(void *ptr)
{
curl_mimepart *part = (curl_mimepart *) ptr;
if(part->fp) {
fclose(part->fp);
part->fp = NULL;
}
Curl_safefree(part->data);
part->data = NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x60858
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x9980
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
jmp 0x6085a
leaq 0x331ef(%rip), %rax # 0x93a50... | /macressler[P]curl/lib/mime.c |
slist_size | static size_t slist_size(struct curl_slist *s,
size_t overhead, const char *skip)
{
size_t size = 0;
size_t skiplen = skip? strlen(skip): 0;
for(; s; s = s->next)
if(!skip || !match_header(s, skip, skiplen))
size += strlen(s->data) + overhead;
return size;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x61542
movq -0x18(%rbp), %rdi
callq 0x93b0
movq %rax, -0x30(%rbp)
jmp 0x6154a
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x6154a
movq -0x30(%rbp), %rax
movq %... | /macressler[P]curl/lib/mime.c |
search_header | static char *search_header(struct curl_slist *hdrlist, const char *hdr)
{
size_t len = strlen(hdr);
char *value = NULL;
for(; !value && hdrlist; hdrlist = hdrlist->next)
value = match_header(hdrlist, hdr, len);
return value;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x93b0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
jne 0x61dbc
cmpq $0x0, -0x8(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
... | /macressler[P]curl/lib/mime.c |
setstropt_userpwd | static CURLcode setstropt_userpwd(char *option, char **userp, char **passwdp)
{
CURLcode result = CURLE_OK;
char *user = NULL;
char *passwd = NULL;
/* Parse the login details if specified. It not then we treat NULL as a hint
to clear the existing data */
if(option) {
result = Curl_parse_login_detail... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6cbee
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x93b0
movq %rax, -0x38(%rbp)
cmp... | /macressler[P]curl/lib/setopt.c |
curl_easy_setopt | CURLcode curl_easy_setopt(struct Curl_easy *data, CURLoption tag, ...)
{
va_list arg;
CURLcode result;
if(!data)
return CURLE_BAD_FUNCTION_ARGUMENT;
va_start(arg, tag);
result = Curl_vsetopt(data, tag, arg);
va_end(arg);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x6cceb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp... | /macressler[P]curl/lib/setopt.c |
Curl_auth_create_plain_message | CURLcode Curl_auth_create_plain_message(struct Curl_easy *data,
const char *userp,
const char *passwdp,
char **outptr, size_t *outlen)
{
CURLcode result;
char *plainauth;
size_t ulen;
size_t p... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x93b0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rd... | /macressler[P]curl/lib/vauth/cleartext.c |
Curl_auth_create_login_message | CURLcode Curl_auth_create_login_message(struct Curl_easy *data,
const char *valuep, char **outptr,
size_t *outlen)
{
size_t vlen = strlen(valuep);
if(!vlen) {
/* Calculate an empty reply */
*outptr = strdup("=");
if(*outptr... | 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 -0x18(%rbp), %rdi
callq 0x93b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6dab8
leaq 0x14f6d(%rip), %rdi # 0x829e0
leaq 0x25fe6(%rip), %rax # 0x93a60
callq *(%rax... | /macressler[P]curl/lib/vauth/cleartext.c |
Curl_auth_decode_cram_md5_message | CURLcode Curl_auth_decode_cram_md5_message(const char *chlg64, char **outptr,
size_t *outlen)
{
CURLcode result = CURLE_OK;
size_t chlg64len = strlen(chlg64);
*outptr = NULL;
*outlen = 0;
/* Decode the challenge if necessary */
if(chlg64len && *chlg64 != '=')
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x93b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x6db85
movq -0x8(%... | /macressler[P]curl/lib/vauth/cram.c |
Curl_auth_create_cram_md5_message | CURLcode Curl_auth_create_cram_md5_message(struct Curl_easy *data,
const char *chlg,
const char *userp,
const char *passwdp,
char **outptr, size_t *... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %r8, -0x58(%rbp)
movq %r9, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movq $0x0, -0x70(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x6dbdf
movq ... | /macressler[P]curl/lib/vauth/cram.c |
Curl_auth_create_digest_http_message | CURLcode Curl_auth_create_digest_http_message(struct Curl_easy *data,
const char *userp,
const char *passwdp,
const unsigned char *request,
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x44(%rbp)
subl $0x2, %eax
j... | /macressler[P]curl/lib/vauth/digest.c |
Curl_auth_create_digest_http_message | static CURLcode _Curl_auth_create_digest_http_message(
struct Curl_easy *data,
const char *userp,
const char *passwdp,
const unsigned char *request,
const unsigned char *uripath,
struct digestdata *digest,
... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq 0x28(%rbp), %rax
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 $0x0, -0x1d8(%rbp)
mo... | /macressler[P]curl/lib/vauth/digest.c |
auth_digest_get_key_value | static bool auth_digest_get_key_value(const char *chlg,
const char *key,
char *value,
size_t max_val_len,
char end_char)
{
char *find_pos;
size_t i;
find_pos = s... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x91d0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6fb8f
movb $0x0, -0x1(%rbp)
jmp 0x6f... | /macressler[P]curl/lib/vauth/digest.c |
auth_digest_string_quoted | static char *auth_digest_string_quoted(const char *source)
{
char *dest, *d;
const char *s = source;
size_t n = 1; /* null terminator */
/* Calculate size needed */
while(*s) {
++n;
if(*s == '"' || *s == '\\') {
++n;
}
++s;
}
dest = malloc(n);
if(dest) {
s = source;
d = d... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6fc93
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x6fc79
m... | /macressler[P]curl/lib/vauth/digest.c |
Curl_auth_decode_ntlm_type2_message | CURLcode Curl_auth_decode_ntlm_type2_message(struct Curl_easy *data,
const char *type2msg,
struct ntlmdata *ntlm)
{
static const char type2_marker[] = { 0x02, 0x00, 0x00, 0x00 };
/* NTLM type-2 message structure:
I... | 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 $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x93b0
cmpq $0x0, %rax
je 0x6fdad
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x6fdad
movq... | /macressler[P]curl/lib/vauth/ntlm.c |
Curl_auth_create_ntlm_type1_message | CURLcode Curl_auth_create_ntlm_type1_message(struct Curl_easy *data,
const char *userp,
const char *passwdp,
struct ntlmdata *ntlm,
char **o... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x558, %rsp # imm = 0x558
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -0x58(%rbp)
leaq 0x13489(%rip), %rax # 0x834ac
movq %rax, -0x468(%r... | /macressler[P]curl/lib/vauth/ntlm.c |
Curl_auth_create_ntlm_type3_message | CURLcode Curl_auth_create_ntlm_type3_message(struct Curl_easy *data,
const char *userp,
const char *passwdp,
struct ntlmdata *ntlm,
char **o... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xbf8, %rsp # imm = 0xBF8
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %r8, -0x58(%rbp)
movq %r9, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movl $0x18, -0x498(%rbp)
leaq -0x4b0... | /macressler[P]curl/lib/vauth/ntlm.c |
ossl_connect_common | static CURLcode ossl_connect_common(struct connectdata *conn,
int sockindex,
bool nonblocking,
bool *done)
{
CURLcode result;
struct Curl_easy *data = conn->data;
struct ssl_connect_data *connssl = &conn->s... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x290, %rax # imm = 0x290
movslq -0x14(%rbp), %rcx
i... | /macressler[P]curl/lib/vtls/openssl.c |
ossl_connect_step1 | static CURLcode ossl_connect_step1(struct connectdata *conn, int sockindex)
{
CURLcode result = CURLE_OK;
char *ciphers;
struct Curl_easy *data = conn->data;
SSL_METHOD_QUAL SSL_METHOD *req_method = NULL;
X509_LOOKUP *lookup = NULL;
curl_socket_t sockfd = conn->sock[sockindex];
struct ssl_connect_data *co... | pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp # imm = 0x370
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x258(%rax,%rcx,4)... | /macressler[P]curl/lib/vtls/openssl.c |
ossl_connect_step2 | static CURLcode ossl_connect_step2(struct connectdata *conn, int sockindex)
{
struct Curl_easy *data = conn->data;
int err;
struct ssl_connect_data *connssl = &conn->ssl[sockindex];
long * const certverifyresult = SSL_IS_PROXY() ?
&data->set.proxy_ssl.certverifyresult : &data->set.ssl.certverifyresult;
DE... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x290, %rax # imm = 0x290
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax... | /macressler[P]curl/lib/vtls/openssl.c |
ossl_connect_step3 | static CURLcode ossl_connect_step3(struct connectdata *conn, int sockindex)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct ssl_connect_data *connssl = &conn->ssl[sockindex];
DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);
if(SSL_SET_OPTION(primary.sessionid)) {
bool i... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x290, %rax # imm = 0x290
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -... | /macressler[P]curl/lib/vtls/openssl.c |
ossl_recv | static ssize_t ossl_recv(struct connectdata *conn, /* connection data */
int num, /* socketindex */
char *buf, /* store read data here */
size_t buffersize, /* max amount to read */
... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x290, %rax # imm = 0x290
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq ... | /macressler[P]curl/lib/vtls/openssl.c |
ossl_send | static ssize_t ossl_send(struct connectdata *conn,
int sockindex,
const void *mem,
size_t len,
CURLcode *curlcode)
{
/* SSL_write() is said to return 'int' while write() and send() returns
'size_t' */
int err;
... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x290, %rax # imm = 0x290
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq ... | /macressler[P]curl/lib/vtls/openssl.c |
ssl_tls_trace | static void ssl_tls_trace(int direction, int ssl_ver, int content_type,
const void *buf, size_t len, SSL *ssl,
void *userp)
{
struct Curl_easy *data;
const char *msg_name, *tls_rt_name;
char ssl_buf[1024];
char unknown[32];
int msg_type, txt_len;
const cha... | pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp # imm = 0x490
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq $0x0, -0x470(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x478(%rbp)
cmpq $0x0, -0x478(%rbp)
j... | /macressler[P]curl/lib/vtls/openssl.c |
set_ssl_version_min_max | static CURLcode
set_ssl_version_min_max(long *ctx_options, struct connectdata *conn,
int sockindex)
{
#if (OPENSSL_VERSION_NUMBER < 0x1000100FL) || !defined(TLS1_3_VERSION)
/* convoluted #if condition just to avoid compiler warnings on unused
variable */
struct Curl_easy *data = conn->d... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movl $0x2, %eax
cmpl 0x178(%rcx), %eax
jne 0x7457a
movq -0x10(%rbp), %rcx
addq $0x2c0, %rcx # imm = 0x2C0
movq -0x10(%rbp), %rax
movl 0x25c(%rax), %esi
movl $0x1, %eax
xorl %... | /macressler[P]curl/lib/vtls/openssl.c |
select_next_proto_cb | static int
select_next_proto_cb(SSL *ssl,
unsigned char **out, unsigned char *outlen,
const unsigned char *in, unsigned int inlen,
void *arg)
{
struct connectdata *conn = (struct connectdata*) arg;
(void)ssl;
#ifdef USE_NGHTTP2
if(conn->data->set.ht... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
l... | /macressler[P]curl/lib/vtls/openssl.c |
cert_stuff | static
int cert_stuff(struct connectdata *conn,
SSL_CTX* ctx,
char *cert_file,
const char *cert_type,
char *key_file,
const char *key_type,
char *key_passwd)
{
struct Curl_easy *data = conn->data;
char error_buffer[256];
boo... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
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), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movb $0x1, -0x141(%rbp)
movq... | /macressler[P]curl/lib/vtls/openssl.c |
ossl_keylog_callback | static void ossl_keylog_callback(const SSL *ssl, const char *line)
{
(void)ssl;
/* Using fputs here instead of fprintf since libcurl's fprintf replacement
may not be thread-safe. */
if(keylog_file_fp && line && *line) {
char stackbuf[256];
char *buf;
size_t linelen = strlen(line);
if(linele... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x1ea65(%rip) # 0x93d40
je 0x753cc
cmpq $0x0, -0x10(%rbp)
je 0x753cc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x753cc
movq -0x10(%rbp), %rdi
callq 0x93b0
movq %rax, -0x1... | /macressler[P]curl/lib/vtls/openssl.c |
tls_rt_type | static const char *tls_rt_type(int type)
{
switch(type) {
#ifdef SSL3_RT_HEADER
case SSL3_RT_HEADER:
return "TLS header";
#endif
case SSL3_RT_CHANGE_CIPHER_SPEC:
return "TLS change cipher";
case SSL3_RT_ALERT:
return "TLS alert";
case SSL3_RT_HANDSHAKE:
return "TLS handshake";
case SSL3_RT_A... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x14, %eax
je 0x7542b
jmp 0x753f4
movl -0x10(%rbp), %eax
subl $0x15, %eax
je 0x75438
jmp 0x753fe
movl -0x10(%rbp), %eax
subl $0x16, %eax
je 0x75445
jmp 0x75408
movl -0x10(%rbp), %eax
subl $0x17, %eax
je 0x75452
jmp 0x754... | /macressler[P]curl/lib/vtls/openssl.c |
ssl_msg_type | static const char *ssl_msg_type(int ssl_ver, int msg)
{
#ifdef SSL2_VERSION_MAJOR
if(ssl_ver == SSL2_VERSION_MAJOR) {
switch(msg) {
case SSL2_MT_ERROR:
return "Error";
case SSL2_MT_CLIENT_HELLO:
return "Client hello";
case SSL2_MT_CLIENT_MASTER_KEY:
return "Client key";
... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x75550
movl -0x10(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x16, %rax
ja 0x7554e
movq -0x18(%rbp), %rax
leaq 0xe088(%rip), %rcx # 0x83528
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe68e(%rip), %rax ... | /macressler[P]curl/lib/vtls/openssl.c |
do_file_type | static int do_file_type(const char *type)
{
if(!type || !type[0])
return SSL_FILETYPE_PEM;
if(strcasecompare(type, "PEM"))
return SSL_FILETYPE_PEM;
if(strcasecompare(type, "DER"))
return SSL_FILETYPE_ASN1;
if(strcasecompare(type, "ENG"))
return SSL_FILETYPE_ENGINE;
if(strcasecompare(type, "P12... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7563c
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x75645
movl $0x1, -0x4(%rbp)
jmp 0x756c4
movq -0x10(%rbp), %rdi
leaq 0xe99a(%rip), %rsi # 0x83fea
callq 0x36690
cmpl $0x0, %eax
je 0x75663
movl $0x1, -0x4(%rbp)
jmp 0x7... | /macressler[P]curl/lib/vtls/openssl.c |
passwd_callback | static int passwd_callback(char *buf, int num, int encrypting,
void *global_passwd)
{
DEBUGASSERT(0 == encrypting);
if(!encrypting) {
int klen = curlx_uztosi(strlen((char *)global_passwd));
if(num > klen) {
memcpy(buf, global_passwd, klen + 1);
return klen;
}
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x756e8
cmpl $0x0, -0x18(%rbp)
jne 0x7572a
movq -0x20(%rbp), %rdi
callq 0x93b0
movq %rax, %rdi
callq 0x57290
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl... | /macressler[P]curl/lib/vtls/openssl.c |
ssl_ui_reader | static int ssl_ui_reader(UI *ui, UI_STRING *uis)
{
const char *password;
switch(UI_get_string_type(uis)) {
case UIT_PROMPT:
case UIT_VERIFY:
password = (const char *)UI_get0_user_data(ui);
if(password && (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD)) {
UI_set_result(ui, uis, password);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa330
decl %eax
subl $0x1, %eax
ja 0x757d3
jmp 0x75792
movq -0x10(%rbp), %rdi
callq 0x93e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x757d1
movq -0x18(%rbp), %rdi
callq 0x9310
andl $0x2, %eax
... | /macressler[P]curl/lib/vtls/openssl.c |
ssl_ui_writer | static int ssl_ui_writer(UI *ui, UI_STRING *uis)
{
switch(UI_get_string_type(uis)) {
case UIT_PROMPT:
case UIT_VERIFY:
if(UI_get0_user_data(ui) &&
(UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD)) {
return 1;
}
default:
break;
}
return (UI_method_get_writer(UI_OpenSSL()))(ui, u... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa330
decl %eax
subl $0x1, %eax
ja 0x7584d
jmp 0x75822
movq -0x10(%rbp), %rdi
callq 0x93e0
cmpq $0x0, %rax
je 0x7584b
movq -0x18(%rbp), %rdi
callq 0x9310
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7584b
mov... | /macressler[P]curl/lib/vtls/openssl.c |
get_ssl_version_txt | static const char *
get_ssl_version_txt(SSL *ssl)
{
if(!ssl)
return "";
switch(SSL_version(ssl)) {
#ifdef TLS1_3_VERSION
case TLS1_3_VERSION:
return "TLSv1.3";
#endif
#if OPENSSL_VERSION_NUMBER >= 0x1000100FL
case TLS1_2_VERSION:
return "TLSv1.2";
case TLS1_1_VERSION:
return "TLSv1.1";
#endif... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x75923
leaq 0xdb92(%rip), %rax # 0x834ac
movq %rax, -0x8(%rbp)
jmp 0x759cd
movq -0x10(%rbp), %rdi
callq 0x94c0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $0x2, %eax
je 0x759b5
jmp 0x75938
movl -0x14(%rbp), %eax
subl $0x... | /macressler[P]curl/lib/vtls/openssl.c |
servercert | static CURLcode servercert(struct connectdata *conn,
struct ssl_connect_data *connssl,
bool strict)
{
CURLcode result = CURLE_OK;
int rc;
long lerr, len;
struct Curl_easy *data = conn->data;
X509 *issuer;
FILE *fp;
char buffer[2048];
const char *ptr;... | pushq %rbp
movq %rsp, %rbp
subq $0x900, %rsp # imm = 0x900
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movl $0x2, %eax
cmpl 0x178(%rcx), %eax
jne ... | /macressler[P]curl/lib/vtls/openssl.c |
get_cert_chain | static CURLcode get_cert_chain(struct connectdata *conn,
struct ssl_connect_data *connssl)
{
CURLcode result;
STACK_OF(X509) *sk;
int i;
struct Curl_easy *data = conn->data;
int numcerts;
BIO *mem;
sk = SSL_get_peer_cert_chain(BACKEND->handle);
if(!sk) {
return CURLE... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x9170
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x765c6
mov... | /macressler[P]curl/lib/vtls/openssl.c |
x509_name_oneline | static int x509_name_oneline(X509_NAME *a, char *buf, size_t size)
{
#if 0
return X509_NAME_oneline(a, buf, size);
#else
BIO *bio_out = BIO_new(BIO_s_mem());
BUF_MEM *biomem;
int rc;
if(!bio_out)
return 1; /* alloc failed! */
rc = X509_NAME_print_ex(bio_out, a, 0, XN_FLAG_SEP_SPLUS_SPC);
BIO_get_mem... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x9850
movq %rax, %rdi
callq 0xa050
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x76f68
movl $0x1, -0x4(%rbp)
jmp 0x76ff6
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
movl $0x300... | /macressler[P]curl/lib/vtls/openssl.c |
verifyhost | static CURLcode verifyhost(struct connectdata *conn, X509 *server_cert)
{
bool matched = FALSE;
int target = GEN_DNS; /* target type, GEN_DNS or GEN_IPADD */
size_t addrlen = 0;
struct Curl_easy *data = conn->data;
STACK_OF(GENERAL_NAME) *altnames;
#ifdef ENABLE_IPV6
struct in6_addr addr;
#else
struct in_... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x2, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x4c(%rbp)
movb $0x0, -0x4d(%rbp)
movb $0x0, -0x4e(%rbp)
movq -0x10(%rbp), %rcx
movl ... | /macressler[P]curl/lib/vtls/openssl.c |
verifystatus | static CURLcode verifystatus(struct connectdata *conn,
struct ssl_connect_data *connssl)
{
int i, ocsp_status;
const unsigned char *p;
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
OCSP_RESPONSE *rsp = NULL;
OCSP_BASICRESP *br = NULL;
X509_STORE *st = N... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8... | /macressler[P]curl/lib/vtls/openssl.c |
pkp_pin_peer_pubkey | static CURLcode pkp_pin_peer_pubkey(struct Curl_easy *data, X509* cert,
const char *pinnedpubkey)
{
/* Scratch */
int len1 = 0, len2 = 0;
unsigned char *buff1 = NULL, *temp = NULL;
/* Result is returned to caller */
CURLcode result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;
/* i... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x5a, -0x3c(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x779dc
movl $0x0, -0x4(%rbp)
jmp 0x77aa3
cmpq $0x0, -0x18(%rbp)... | /macressler[P]curl/lib/vtls/openssl.c |
X509V3_ext | static int X509V3_ext(struct Curl_easy *data,
int certnum,
CONST_EXTS STACK_OF(X509_EXTENSION) *exts)
{
int i;
size_t j;
if((int)sk_X509_EXTENSION_num(exts) <= 0)
/* no extensions, bail out */
return 1;
for(i = 0; i < (int)sk_X509_EXTENSION_num(exts); i++) {... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x77e00
movq %rax, %rdi
callq 0x94a0
cmpl $0x0, %eax
jg 0x77ae8
movl $0x1, -0x4(%rbp)
jmp 0x77d3f
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %ea... | /macressler[P]curl/lib/vtls/openssl.c |
pubkey_show | static void pubkey_show(struct Curl_easy *data,
BIO *mem,
int num,
const char *type,
const char *name,
#ifdef HAVE_OPAQUE_RSA_DSA_DH
const
#endif
BIGNUM *bn)
{
char *ptr;
c... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x20, %esi
leaq 0xc784(%rip), %rdx # 0x8450b
movb $0x0, %al
ca... | /macressler[P]curl/lib/vtls/openssl.c |
asn1_object_dump | static int asn1_object_dump(ASN1_OBJECT *a, char *buf, size_t len)
{
int i, ilen;
ilen = (int)len;
if(ilen < 0)
return 1; /* buffer too big */
i = i2t_ASN1_OBJECT(buf, ilen, a);
if(i >= ilen)
return 1; /* buffer too small */
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x77e3a
movl $0x1, -0x4(%rbp)
jmp 0x77e65
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x9280
movl %eax,... | /macressler[P]curl/lib/vtls/openssl.c |
Curl_ssl_config_matches | bool
Curl_ssl_config_matches(struct ssl_primary_config* data,
struct ssl_primary_config* needle)
{
if((data->version == needle->version) &&
(data->version_max == needle->version_max) &&
(data->verifypeer == needle->verifypeer) &&
(data->verifyhost == needle->verifyhost) &&
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x78063
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x78063
movq -0x10(%rbp), %rax
movb 0x10(%ra... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_clone_primary_ssl_config | bool
Curl_clone_primary_ssl_config(struct ssl_primary_config *source,
struct ssl_primary_config *dest)
{
dest->version = source->version;
dest->version_max = source->version_max;
dest->verifypeer = source->verifypeer;
dest->verifyhost = source->verifyhost;
dest->verifystatus = so... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb 0x10(%rax), %cl
movq -0x18(%rbp)... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_free_primary_ssl_config | void Curl_free_primary_ssl_config(struct ssl_primary_config* sslc)
{
Curl_safefree(sslc->CApath);
Curl_safefree(sslc->CAfile);
Curl_safefree(sslc->clientcert);
Curl_safefree(sslc->random_file);
Curl_safefree(sslc->egdsocket);
Curl_safefree(sslc->cipher_list);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1b76d(%rip), %rax # 0x93a50
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x782fe
leaq 0x1b74b(%rip), %rax # 0x93a50
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_backend | int Curl_ssl_backend(void)
{
#ifdef USE_SSL
multissl_init(NULL);
return Curl_ssl->info.id;
#else
return (int)CURLSSLBACKEND_NONE;
#endif
} | pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, %edi
callq 0x783d0
movq 0x1b6cc(%rip), %rax # 0x93a90
movl (%rax), %eax
popq %rbp
retq
nopl (%rax,%rax)
| /macressler[P]curl/lib/vtls/vtls.c |
multissl_init | static int multissl_init(const struct Curl_ssl *backend)
{
const char *env;
char *env_tmp;
int i;
if(Curl_ssl != &Curl_ssl_multi)
return 1;
if(backend) {
Curl_ssl = backend;
return 0;
}
if(!available_backends[0])
return 1;
env = env_tmp = curl_getenv("CURL_SSL_BACKEND");
#ifdef CURL_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1a8cd(%rip), %rax # 0x92cb0
cmpq %rax, 0x1b6a6(%rip) # 0x93a90
je 0x783f8
movl $0x1, -0x4(%rbp)
jmp 0x784d6
cmpq $0x0, -0x10(%rbp)
je 0x78416
movq -0x10(%rbp), %rax
movq %rax, 0x1b686(%rip) # 0x93a90
movl $0x0, -0x4(%rbp)
jmp 0x784d6
... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_connect | CURLcode
Curl_ssl_connect(struct connectdata *conn, int sockindex)
{
CURLcode result;
if(conn->bits.proxy_ssl_connected[sockindex]) {
result = ssl_connect_init_proxy(conn, sockindex);
if(result)
return result;
}
if(!ssl_prefs_check(conn->data))
return CURLE_SSL_CONNECT_ERROR;
/* mark this... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
testb $0x1, 0x3a9(%rax,%rcx)
je 0x78583
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x78610
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x78581
movl -0x18(%rbp), %eax
mo... | /macressler[P]curl/lib/vtls/vtls.c |
ssl_prefs_check | static bool ssl_prefs_check(struct Curl_easy *data)
{
/* check for CURLOPT_SSLVERSION invalid parameter value */
const long sslver = data->set.ssl.primary.version;
if((sslver < 0) || (sslver >= CURL_SSLVERSION_LAST)) {
failf(data, "Unrecognized parameter value passed via CURLOPT_SSLVERSION");
return FALSE... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x5e8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x78779
cmpq $0x8, -0x18(%rbp)
jl 0x78791
movq -0x10(%rbp), %rdi
leaq 0xc1bb(%rip), %rsi # 0x8493f
movb $0x0, %al
callq 0x19f90
movb $0x0, -0x1(%rbp)
jmp... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_connect_nonblocking | CURLcode
Curl_ssl_connect_nonblocking(struct connectdata *conn, int sockindex,
bool *done)
{
CURLcode result;
if(conn->bits.proxy_ssl_connected[sockindex]) {
result = ssl_connect_init_proxy(conn, sockindex);
if(result)
return result;
}
if(!ssl_prefs_check(conn->data))... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
testb $0x1, 0x3a9(%rax,%rcx)
je 0x78834
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x78610
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x78832
mo... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_getsessionid | bool Curl_ssl_getsessionid(struct connectdata *conn,
void **ssl_sessionid,
size_t *idsize, /* set 0 if unknown */
int sockindex)
{
struct curl_ssl_session *check;
struct Curl_easy *data = conn->data;
size_t i;
long *general_age;
... | 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 -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movb $0x1, -0x49(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x2, 0x178(%rcx)
movb %al, -0x65(%rbp)
jne 0x789af
m... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_delsessionid | void Curl_ssl_delsessionid(struct connectdata *conn, void *ssl_sessionid)
{
size_t i;
struct Curl_easy *data = conn->data;
for(i = 0; i < data->set.general_ssl.max_ssl_sessions; i++) {
struct curl_ssl_session *check = &data->state.session[i];
if(check->sessionid == ssl_sessionid) {
Curl_ssl_kill_s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x738(%rcx), %rax
jae 0x78dd7
movq -0x20(%rbp), %rax
movq 0x4cd0(%rax), %rax
movq -0x18(%rbp),... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_close_all | void Curl_ssl_close_all(struct Curl_easy *data)
{
size_t i;
/* kill the session ID cache if not shared */
if(data->state.session && !SSLSESSION_SHARED(data)) {
for(i = 0; i < data->set.general_ssl.max_ssl_sessions; i++)
/* the single-killer function handles empty table slots */
Curl_ssl_kill_sessi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4cd0(%rax)
je 0x7926d
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x79201
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x7926d
movq $0x0, -0x10(%rbp)
movq -0x10(%... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_getsock | int Curl_ssl_getsock(struct connectdata *conn, curl_socket_t *socks,
int numsocks)
{
struct ssl_connect_data *connssl = &conn->ssl[FIRSTSOCKET];
if(!numsocks)
return GETSOCK_BLANK;
if(connssl->connecting_state == ssl_connect_2_writing) {
/* write mode */
socks[0] = conn->sock[FI... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x290, %rax # imm = 0x290
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x792bc
movl $0x0, -0x4(%rbp)
jmp 0x79309
movq -0x28(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x792df
movq -0x10... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_free_certinfo | void Curl_ssl_free_certinfo(struct Curl_easy *data)
{
int i;
struct curl_certinfo *ci = &data->info.certs;
if(ci->num_of_certs) {
/* free all individual lists used */
for(i = 0; i<ci->num_of_certs; i++) {
curl_slist_free_all(ci->certinfo[i]);
ci->certinfo[i] = NULL;
}
free(ci->certin... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x5158, %rax # imm = 0x5158
addq $0xd8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x79639
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x7960f... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_init_certinfo | CURLcode Curl_ssl_init_certinfo(struct Curl_easy *data, int num)
{
struct curl_certinfo *ci = &data->info.certs;
struct curl_slist **table;
/* Free any previous certificate information structures */
Curl_ssl_free_certinfo(data);
/* Allocate the required certificate information structures */
table = calloc... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x5158, %rax # imm = 0x5158
addq $0xd8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x795a0
leaq 0x1a3f5(%rip), %rax # 0x93a68
movq (%rax), %rax
movslq -0x14(%rbp), %rdi
movl... | /macressler[P]curl/lib/vtls/vtls.c |
Curl_ssl_push_certinfo_len | CURLcode Curl_ssl_push_certinfo_len(struct Curl_easy *data,
int certnum,
const char *label,
const char *value,
size_t valuelen)
{
struct curl_certinfo *ci = &data->info.certs... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x5158, %rax # imm = 0x5158
addq $0xd8, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9... | /macressler[P]curl/lib/vtls/vtls.c |
parallel_inc(void*) | void *parallel_inc(void * arg){
auto p = reinterpret_cast<Argument *>(arg);
while(*(p->x) != p->n);
//usleep(1);
std::cout << "thread #" << p->n << std::endl;
++*(p->x);
return nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x2cc1(%rip), %rdi # 0x4fc8
leaq 0xcf6(%rip), %rsi # 0x3004
callq 0x2140
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rax
incq (%rax)
xorl %eax, %eax
popq %rbx
retq
| /ant-tr-v[P]treading_at_mipt/all_at_one.cpp |
parse_arg(int, char**) | ulong parse_arg(int argc, char *argv[]){
ulong res;
if(argc < 2)
throw std::runtime_error("Incorrect input");
try{
res = std::stoul(argv[1]);
}catch(...){
throw std::runtime_error("Parsing failed");
}
return res;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jle 0x2377
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2070
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x25c3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq... | /ant-tr-v[P]treading_at_mipt/all_at_one.cpp |
main | int main(int argc, char *argv[]) {
ulong N;
try{
N = parse_arg(argc, argv);
}catch(std::runtime_error &err){
std::cerr << err.what();
return -1;
}
std::vector<Argument> args(N);
std::vector<pthread_t> threads(N);
ulong X = 0;
for(ulong i = N - 1; i > 0; --i){
args[i] = {&X, i};
int r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
callq 0x2331
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0x25ea
leaq 0x8(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x263c
andq $0x0, (%rsp)
movq %rbx, %r12
shlq $0x4, %r12
addq $-0x10, %r12
le... | /ant-tr-v[P]treading_at_mipt/all_at_one.cpp |
TestHarness::AddType(int, int, char const*) | void TestHarness::AddType(int type, int weight, const char* name) {
Type t;
t.name = name;
t.type = type;
t.weight = weight;
types_.push_back(t);
total_weight_ += weight;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %rcx, %rdi
callq 0xa2a0
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
xo... | /alk[P]gperftools/src/tests/tcmalloc_unittest.cc |
TCMallocTest_ManyThreads_Test::TestBody() | TEST(TCMallocTest, ManyThreads) {
printf("Testing threaded allocation/deallocation (%d threads)\n",
FLAGS_numthreads);
std::vector<std::unique_ptr<TesterThread>> ptrs;
ptrs.reserve(FLAGS_numthreads);
// Note, the logic inside PassObject requires us to create all
// TesterThreads first, before start... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x3b692(%rip), %rdi # 0x4921c
xorl %ebx, %ebx
movl $0xa, %esi
xorl %eax, %eax
callq 0xa080
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0xa, %esi
callq 0x15d9c
leaq -... | /alk[P]gperftools/src/tests/tcmalloc_unittest.cc |
TCMallocTest_Ranges_Test::TestBody() | TEST(TCMallocTest, Ranges) {
static const int MB = 1048576;
void* a = malloc(MB);
void* b = malloc(MB);
base::MallocRange::Type releasedType =
TestingPortal::Get()->HaveSystemRelease() ? base::MallocRange::UNMAPPED : base::MallocRange::FREE;
CheckRangeCallback(a, base::MallocRange::INUSE, MB);
CheckRan... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x100000, %edi # imm = 0x100000
callq 0xad80
movq %rax, %rbx
movl $0x100000, %edi # imm = 0x100000
callq 0xad80
movq %rax, %r14
callq 0x15fe6
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movzbl %al, %r1... | /alk[P]gperftools/src/tests/tcmalloc_unittest.cc |
testing::AssertionResult testing::internal::CmpHelperOpFailure<unsigned long, int>(char const*, char const*, unsigned long const&, int const&, char const*) | AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << Form... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %r9, -0x38(%rbp)
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x1ba60
leaq 0x2fb3b(%rip), %rsi # 0x49f50
movq %r12, %rdi
callq 0x1... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest.h |
testing::internal::RE::Init(char const*) | void RE::Init(const char* regex) {
pattern_ = regex;
// NetBSD (and Android, which takes its regex implemntation from NetBSD) does
// not include the GNU regex extensions (such as Perl style character classes
// like \w) in REG_EXTENDED. REG_EXTENDED is only specified to include the
// [[:alpha:]] style char... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq %rsi, %rdi
callq 0xa2a0
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0xaac0
movq %r15, %rdi
callq 0xa2a0
leaq 0xa(%rax), %r12
movq %r1... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-port.cc |
testing::internal::CapturedStream::~CapturedStream() | ~CapturedStream() { remove(filename_.c_str()); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xac60
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x1d5d0
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa0c0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /alk[P]gperftools/vendor/googletest/googletest/src/gtest-port.cc |
testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0xa460
leaq 0x2daa9(%rip), %rsi # 0x4b1f7
movl $0xe, %edx
movq %rax, %rdi
callq 0xa7a0
cmpq $0x83, %r14
ja 0x1d76b
movq %r15, %rdi
xorl %esi, %esi
jmp 0x1d79f
movl $0x40, %edx... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*) | static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
switch (c) {
case L'\'':
*os << "'";
return kAsIs;
case L'"':
*os << "\\\"";
return kSpecialEscape;
default:
return PrintAsCharLiteralTo(c, os);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x21, %edi
jg 0x1e370
cmpl $0xd, %r14d
ja 0x1e3f7
movl %r14d, %eax
leaq 0x2ce5e(%rip), %rcx # 0x4b1bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2ceb8(%rip), %rsi # 0x4b226
jmp 0x1e3da... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
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.