name string | code string | asm string | file string |
|---|---|---|---|
ftp_state_port_resp | static CURLcode ftp_state_port_resp(struct connectdata *conn,
int ftpcode)
{
struct Curl_easy *data = conn->data;
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 (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0... | /macressler[P]curl/lib/ftp.c |
ftp_state_get_resp | static CURLcode ftp_state_get_resp(struct connectdata *conn,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct FTP *ftp = data->req.protop;
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 (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x96, -0x14(%rbp)
je 0x1ec86
cmpl $0x7d, -0x1... | /macressler[P]curl/lib/ftp.c |
ftp_state_loggedin | static CURLcode ftp_state_loggedin(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
if(conn->ssl[FIRSTSOCKET].use) {
/* PBSZ = PROTECTION BUFFER SIZE.
The 'draft-murray-auth-ftp-ssl' (draft 12, page 7) says:
Specifically, the PROT command MUST be preceded by a PBSZ
command and a PBSZ comma... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x290(%rax)
je 0x1f08c
movq -0x10(%rbp), %rdi
addq $0x628, %rdi # imm = 0x628
leaq 0x5d5ba(%rip), %rsi # 0x7c61c
xorl %edx, %edx
movb $0x0, %al
callq 0x550c0
movl %eax, -0x14(%rbp)... | /macressler[P]curl/lib/ftp.c |
ftp_state_cwd | static CURLcode ftp_state_cwd(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(conn);
else {
ftpc->count2 = 0; /* count2 counts failed CWDs */
/* count3 is set to allow a MKD... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x92(%rax)
je 0x1f0ef
movq -0x10(%rbp), %rdi
callq 0x1dc10
movl %eax, -0x14(%rbp)
jmp 0x1f23d
movq -0x20(%... | /macressler[P]curl/lib/ftp.c |
ftp_state_retr | static CURLcode ftp_state_retr(struct connectdata *conn,
curl_off_t filesize)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct FTP *ftp = data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(data->set.max_filesize && (filesize > dat... | 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 (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %ra... | /macressler[P]curl/lib/ftp.c |
ftp_state_ul_setup | static CURLcode ftp_state_ul_setup(struct connectdata *conn,
bool sizechecked)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->req.protop;
struct Curl_easy *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
int seekerr = CURL_SEEKFUNC_OK;
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 (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq... | /macressler[P]curl/lib/ftp.c |
ftp_state_type | static CURLcode ftp_state_type(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->req.protop;
struct Curl_easy *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
/* If we have selected NOBODY and HEADER, it means that we only want file
information. Which in... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0... | /macressler[P]curl/lib/ftp.c |
ftp_nb_type | static CURLcode ftp_nb_type(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(conn, newstate);
return ftp_state_type_resp(conn, 200,... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %dl
movl $0x49, %eax
movl $0x41, %ecx
testb $0x1, %dl
cmovnel %ecx, %ea... | /macressler[P]curl/lib/ftp.c |
ftp_state_size | static CURLcode ftp_state_size(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer == FTPTRANSFER_INFO) && ftpc->file) {
/* if a "head"-like request is being made (on a file) */
/* we know ftpc->... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x1fa... | /macressler[P]curl/lib/ftp.c |
ftp_state_rest | static CURLcode ftp_state_rest(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer != FTPTRANSFER_BODY) && ftpc->file) {
/* if a "head"-like request is being made (on a file) */
/* Determine if s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x1fb3... | /macressler[P]curl/lib/ftp.c |
ftp_state_use_port | static CURLcode ftp_state_use_port(struct connectdata *conn,
ftpport fcmd) /* start with this */
{
CURLcode result = CURLE_OK;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct Curl_easy *data = conn->data;
curl_socket_t portsock = CURL_SOCKET_BAD;
char myhost[256] = "";
... | pushq %rbp
movq %rsp, %rbp
subq $0xaf0, %rsp # imm = 0xAF0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp... | /macressler[P]curl/lib/ftp.c |
ftp_state_list | static CURLcode ftp_state_list(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
/* If this output is to be machine-parsed, the NLST command might be better
to use, since the LIST command output is not specified or standard in any
way. It has turned out that t... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x5098(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, 0x778(%rax)
jne 0x20c5e
cmpq $0x0, -0x4... | /macressler[P]curl/lib/ftp.c |
control_address | static char *control_address(struct connectdata *conn)
{
/* Returns the control connection IP address.
If a proxy tunnel is used, returns the original host name instead, because
the effective control connection address is the proxy address,
not the ftp host. */
if(conn->bits.tunnel_proxy || conn->bit... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x399(%rax)
jne 0x20e32
movq -0x10(%rbp), %rax
testb $0x1, 0x38f(%rax)
je 0x20e43
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20e51
movq -0x10(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%r... | /macressler[P]curl/lib/ftp.c |
ftp_epsv_disable | static CURLcode ftp_epsv_disable(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
if(conn->bits.ipv6) {
/* We can't disable EPSV when doing IPv6, so this is instead a fail */
failf(conn->data, "Failed EPSV attempt, exiting\n");
return CURLE_WEIRD_SERVER_REPLY;
}
infof(conn->data, "Failed EP... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x393(%rax)
je 0x20ea1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x5bc91(%rip), %rsi # 0x7cb1f
movb $0x0, %al
callq 0x19f90
movl $0x8, -0x4(%rbp)
jmp 0x20f27
movq -0x10(%rbp), %rax
movq (... | /macressler[P]curl/lib/ftp.c |
AllowServerConnect | static CURLcode AllowServerConnect(struct connectdata *conn, bool *connected)
{
struct Curl_easy *data = conn->data;
time_t timeout_ms;
CURLcode result = CURLE_OK;
*connected = FALSE;
infof(data, "Preparing for accepting server on data port\n");
/* Save the time we start accepting server connect */
Curl... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rdi
leaq 0x5bba5(%rip), %rsi # 0x7cc39
movb $0x0, %al
callq 0x19d00
movq -0x20(... | /macressler[P]curl/lib/ftp.c |
InitiateTransfer | static CURLcode InitiateTransfer(struct connectdata *conn)
{
struct Curl_easy *data = conn->data;
struct FTP *ftp = data->req.protop;
CURLcode result = CURLE_OK;
if(conn->bits.ftp_use_data_ssl) {
/* since we only have a plaintext TCP connection here, we must now
* do the TLS stuff */
infof(data, "... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x39e(%rax)
je 0x21220
movq -0x18(%rbp), %rdi
leaq 0x5bbc1(%ri... | /macressler[P]curl/lib/ftp.c |
ftp_timeleft_accept | static timediff_t ftp_timeleft_accept(struct Curl_easy *data)
{
timediff_t timeout_ms = DEFAULT_ACCEPT_TIMEOUT;
timediff_t other;
struct curltime now;
if(data->set.accepttimeout > 0)
timeout_ms = data->set.accepttimeout;
now = Curl_now();
/* check if the generic timeout possibly is set shorter */
o... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0xea60, -0x18(%rbp) # imm = 0xEA60
movq -0x10(%rbp), %rax
cmpq $0x0, 0x340(%rax)
jle 0x21311
movq -0x10(%rbp), %rax
movq 0x340(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0xb150
movq %rax, -0x40(%rbp)
movl %edx, -0x38(%rbp)
movq -0x40(%rbp), %rax
... | /macressler[P]curl/lib/ftp.c |
ReceivedServerConnect | static CURLcode ReceivedServerConnect(struct connectdata *conn, bool *received)
{
struct Curl_easy *data = conn->data;
curl_socket_t ctrl_sock = conn->sock[FIRSTSOCKET];
curl_socket_t data_sock = conn->sock[SECONDARYSOCKET];
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
int res... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x258(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x25c(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq ... | /macressler[P]curl/lib/ftp.c |
AcceptServerConnect | static CURLcode AcceptServerConnect(struct connectdata *conn)
{
struct Curl_easy *data = conn->data;
curl_socket_t sock = conn->sock[SECONDARYSOCKET];
curl_socket_t s = CURL_SOCKET_BAD;
#ifdef ENABLE_IPV6
struct Curl_sockaddr_storage add;
#else
struct sockaddr_in add;
#endif
curl_socklen_t size = (curl_sock... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x25c(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x80, -0xa4(%rbp)
movl -0x1c(%rbp), %edi
leaq -0xa0(%rbp), %rsi
l... | /macressler[P]curl/lib/ftp.c |
ftp_sendquote | static
CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
{
struct curl_slist *item;
ssize_t nread;
int ftpcode;
CURLcode result;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
item = quote;
while(item) {
if(item->data) {
char *cmd = item->... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x21914
movq -0x20(%rbp... | /macressler[P]curl/lib/ftp.c |
ftp_parse_url_path | static
CURLcode ftp_parse_url_path(struct connectdata *conn)
{
struct Curl_easy *data = conn->data;
/* the ftp struct is already inited in ftp_connect() */
struct FTP *ftp = data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
const char *slash_pos; /* position of the first '/' char in curpos */
co... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x5... | /macressler[P]curl/lib/ftp.c |
ftp_regular_transfer | static
CURLcode ftp_regular_transfer(struct connectdata *conn,
bool *dophase_done)
{
CURLcode result = CURLE_OK;
bool connected = FALSE;
struct Curl_easy *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
data->req.size = -1; /* make sure this is unknown at this point... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq $-0... | /macressler[P]curl/lib/ftp.c |
ftp_block_statemach | static CURLcode ftp_block_statemach(struct connectdata *conn)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
CURLcode result = CURLE_OK;
while(ftpc->state != FTP_STOP) {
result = Curl_pp_statemach(pp, TRUE);
if(result)
break;
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xbc(%rax)
je 0x22b91
movq -0x18(%rbp), %rdi
movl $0x1, %esi
ca... | /macressler[P]curl/lib/ftp.c |
Curl_freeset | void Curl_freeset(struct Curl_easy *data)
{
/* Free all dynamic strings stored in the data->set substructure. */
enum dupstring i;
for(i = (enum dupstring)0; i < STRING_LAST; i++) {
Curl_safefree(data->set.str[i]);
}
if(data->change.referer_alloc) {
Curl_safefree(data->change.referer);
data->chan... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3a, -0xc(%rbp)
jae 0x22c66
jmp 0x22c2b
leaq 0x70e1e(%rip), %rax # 0x93a50
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
movq 0x7f0(%rcx,%rdx,8), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ec... | /macressler[P]curl/lib/url.c |
Curl_close | CURLcode Curl_close(struct Curl_easy *data)
{
struct Curl_multi *m;
if(!data)
return CURLE_OK;
Curl_expire_clear(data); /* shut off timers */
m = data->multi;
if(m)
/* This handle is still part of a multi handle, take care of this first
and detach this handle from there. */
curl_multi_r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x22d4f
movl $0x0, -0x4(%rbp)
jmp 0x23089
movq -0x10(%rbp), %rdi
callq 0x3eb50
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22d82
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdi
... | /macressler[P]curl/lib/url.c |
Curl_open | CURLcode Curl_open(struct Curl_easy **curl)
{
CURLcode result;
struct Curl_easy *data;
/* Very simple start-up: alloc the struct, init it with zeroes and return */
data = calloc(1, sizeof(struct Curl_easy));
if(!data) {
/* this is a very serious error */
DEBUGF(fprintf(stderr, "Error: calloc of Curl_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x5258, %esi # imm = 0x5258
leaq 0x7055b(%rip), %rax # 0x93a68
callq *(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2352a
jmp 0x2351c
jmp 0x2351e
movl $0x1b, -0x4(%rbp)
jmp 0x236d7
movq -0x20(%rbp), %rax
... | /macressler[P]curl/lib/url.c |
Curl_disconnect | CURLcode Curl_disconnect(struct connectdata *conn, bool dead_connection)
{
struct Curl_easy *data;
if(!conn)
return CURLE_OK; /* this is closed and fine already */
data = conn->data;
if(!data) {
DEBUGF(fprintf(stderr, "DISCONNECT without easy handle, ignoring\n"));
return CURLE_OK;
}
/*
* I... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x23707
movl $0x0, -0x4(%rbp)
jmp 0x23894
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x23729
jmp 0x2371b
jmp 0x2371d
movl $0x0... | /macressler[P]curl/lib/url.c |
conn_free | static void conn_free(struct connectdata *conn)
{
if(!conn)
return;
/* possible left-overs from the async name resolvers */
Curl_resolver_cancel(conn);
/* close the SSL stuff before we close any sockets since they will/may
write to the sockets */
Curl_ssl_close(conn, FIRSTSOCKET);
Curl_ssl_close(... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x23958
jmp 0x23eea
movq -0x8(%rbp), %rdi
callq 0x58ff0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x79310
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x79310
movq -0x8(%rbp), %rcx
movl $0xffffffff, %eax # imm = 0xFFFFFFF... | /macressler[P]curl/lib/url.c |
Curl_removeHandleFromPipeline | int Curl_removeHandleFromPipeline(struct Curl_easy *handle,
struct curl_llist *pipeline)
{
if(pipeline) {
struct curl_llist_element *curr;
curr = pipeline->head;
while(curr) {
if(curr->ptr == handle) {
Curl_llist_remove(pipeline, curr, NULL);
return... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x23f50
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x23f4e
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x23f40
movq -0x18(%rbp), %rdi... | /macressler[P]curl/lib/url.c |
Curl_verboseconnect | void Curl_verboseconnect(struct connectdata *conn)
{
if(conn->data->set.verbose)
infof(conn->data, "Connected to %s (%s) port %ld (#%ld)\n",
conn->bits.socksproxy ? conn->socks_proxy.host.dispname :
conn->bits.httpproxy ? conn->http_proxy.host.dispname :
conn->bits.conn_to_host ? con... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x7a8(%rax)
je 0x242c8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x38f(%rax)
je 0x24239
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x... | /macressler[P]curl/lib/url.c |
Curl_protocol_connecting | CURLcode Curl_protocol_connecting(struct connectdata *conn,
bool *done)
{
CURLcode result = CURLE_OK;
if(conn && conn->handler->connecting) {
*done = FALSE;
result = conn->handler->connecting(conn, done);
}
else
*done = TRUE;
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x243e5
movq -0x8(%rbp), %rax
movq 0x3d0(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x243e5
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x3d0(%rax), %rax
movq 0x30(%... | /macressler[P]curl/lib/url.c |
Curl_protocol_connect | CURLcode Curl_protocol_connect(struct connectdata *conn,
bool *protocol_done)
{
CURLcode result = CURLE_OK;
*protocol_done = FALSE;
if(conn->bits.tcpconnect[FIRSTSOCKET] && conn->bits.protoconnstart) {
/* We already are connected, get back. This may happen when the connect
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x395(%rax)
je 0x244cd
movq -0x10(%rbp), %rax
testb $0x1, 0x397(%rax)
je 0x244cd
movq -0x10(%rbp), %rax
movq 0x3d0(%rax), %rax
cmpq... | /macressler[P]curl/lib/url.c |
Curl_parse_login_details | CURLcode Curl_parse_login_details(const char *login, const size_t len,
char **userp, char **passwdp,
char **optionsp)
{
CURLcode result = CURLE_OK;
char *ubuf = NULL;
char *pbuf = NULL;
char *obuf = NULL;
const char *psep = NULL;
const char... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
cmpq $0x0, -0x20(%rbp)
je... | /macressler[P]curl/lib/url.c |
Curl_connect | CURLcode Curl_connect(struct Curl_easy *data,
struct connectdata **in_connect,
bool *asyncp,
bool *protocol_done)
{
CURLcode result;
*asyncp = FALSE; /* assume synchronous resolves by default */
/* call the stuff that needs to be called */
resu... | 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 -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x24c90
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x24c34
mo... | /macressler[P]curl/lib/url.c |
create_conn | static CURLcode create_conn(struct Curl_easy *data,
struct connectdata **in_connect,
bool *async)
{
CURLcode result = CURLE_OK;
struct connectdata *conn;
struct connectdata *conn_temp = NULL;
size_t urllen;
char *user = NULL;
char *passwd = NULL;
cha... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x52(%rbp)
movb $0x1, -0x53(%rbp)
movb $0x0, -0x54(%rbp)
movb $0x0, -0x55(%rbp)
m... | /macressler[P]curl/lib/url.c |
allocate_conn | static struct connectdata *allocate_conn(struct Curl_easy *data)
{
struct connectdata *conn = calloc(1, sizeof(struct connectdata));
if(!conn)
return NULL;
#ifdef USE_SSL
/* The SSL backend-specific data (ssl_backend_data) objects are allocated as
a separate array to ensure suitable alignment.
Note... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x758, %esi # imm = 0x758
leaq 0x6dcab(%rip), %rax # 0x93a68
callq *(%rax)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x25dd7
movq $0x0, -0x8(%rbp)
jmp 0x2638f
leaq 0x6dcb2(%rip), %rax # 0x93a90
movq (%rax... | /macressler[P]curl/lib/url.c |
parseurlandfillconn | static CURLcode parseurlandfillconn(struct Curl_easy *data,
struct connectdata *conn,
bool *prot_missing,
char **userp, char **passwdp,
char **optionsp)
{
char *at;
char *f... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
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 0x5098(%rax), %rax
movq %rax, -0x50(%rbp)
leaq 0x5d0d3(%rip), %rax # 0x834ac
movq ... | /macressler[P]curl/lib/url.c |
parse_remote_port | static CURLcode parse_remote_port(struct Curl_easy *data,
struct connectdata *conn)
{
char *portptr;
char endbracket;
/* Note that at this point, the IPv6 address cannot contain any scope
suffix as that has already been removed in the parseurlandfillconn()
function */
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rdi
leaq 0x55d8a(%rip), %rsi # 0x7d5cf
leaq -0x21(%rbp), %rdx
movb $0x0, %al
callq 0x9950
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x2790b
movsbl -0x21(%rbp), %ecx
movl $0x5d... | /macressler[P]curl/lib/url.c |
set_login | static CURLcode set_login(struct connectdata *conn,
const char *user, const char *passwd,
const char *options)
{
CURLcode result = CURLE_OK;
/* If our protocol needs a password and we have none, use the defaults */
if((conn->handler->flags & PROTOPT_NEEDSPWD) &... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x3d0(%rax), %rax
movl 0x84(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x27ec2
movq -0x8(%rbp), %rax
testb $0x1, 0x390(%rax)
jne 0... | /macressler[P]curl/lib/url.c |
fix_hostname | static CURLcode fix_hostname(struct connectdata *conn, struct hostname *host)
{
size_t len;
struct Curl_easy *data = conn->data;
#ifndef USE_LIBIDN2
(void)data;
(void)conn;
#elif defined(CURL_DISABLE_VERBOSE_STRINGS)
(void)conn;
#endif
/* set the name we use to display the host name */
host->dispname = ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x93b0
movq %rax, -0x20(%... | /macressler[P]curl/lib/url.c |
setup_connection_internals | static CURLcode setup_connection_internals(struct connectdata *conn)
{
const struct Curl_handler * p;
CURLcode result;
struct Curl_easy *data = conn->data;
/* in some case in the multi state-machine, we go back to the CONNECT state
and then a second (or third or...) call to this function will be made
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x230a0
movq -0x28(%rbp), %rdi
addq $0xc0, %rdi
xorl %esi, %esi
movl $0x130, %edx # imm = 0x130
callq 0x9520
movq -0x28(%rbp), %rax
movq $-0x1, 0xd0(... | /macressler[P]curl/lib/url.c |
setup_range | static CURLcode setup_range(struct Curl_easy *data)
{
struct UrlState *s = &data->state;
s->resume_from = data->set.set_resume_from;
if(s->resume_from || data->set.str[STRING_SET_RANGE]) {
if(s->rangestringalloc)
free(s->range);
if(s->resume_from)
s->range = aprintf("%" CURL_FORMAT_CURL_OFF_T... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xc68, %rax # imm = 0xC68
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x390(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x4448(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x4448(%rax)
jne 0x28330
movq -0x10(%... | /macressler[P]curl/lib/url.c |
prune_dead_connections | static void prune_dead_connections(struct Curl_easy *data)
{
struct curltime now = Curl_now();
time_t elapsed = Curl_timediff(now, data->state.conn_cache->last_cleanup);
if(elapsed >= 1000L) {
struct prunedead prune;
prune.data = data;
prune.extracted = NULL;
while(Curl_conncache_foreach(data, da... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0xb150
movq %rax, -0x18(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xc68(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movq 0x40(%rax), %rdx
movl 0x48(%rax), %ecx
callq 0xb180
movq %rax, -0x20(%rbp)
cmpq $0x3e8, -0x20(%rbp)... | /macressler[P]curl/lib/url.c |
ConnectionExists | static bool
ConnectionExists(struct Curl_easy *data,
struct connectdata *needle,
struct connectdata **usethis,
bool *force_reuse,
bool *waitpipe)
{
struct connectdata *check;
struct connectdata *chosen = 0;
bool foundPendingCandidate = FALSE;
i... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x291b0
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x4dd... | /macressler[P]curl/lib/url.c |
reuse_conn | static void reuse_conn(struct connectdata *old_conn,
struct connectdata *conn)
{
free_fixed_hostname(&old_conn->http_proxy.host);
free_fixed_hostname(&old_conn->socks_proxy.host);
free(old_conn->http_proxy.host.rawalloc);
free(old_conn->socks_proxy.host.rawalloc);
/* free the SSL conf... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x150, %rdi # imm = 0x150
callq 0x238a0
movq -0x8(%rbp), %rdi
addq $0x110, %rdi # imm = 0x110
callq 0x238a0
leaq 0x6a789(%rip), %rax # 0x93a50
movq (%rax), %rax
movq -0x8(%rbp),... | /macressler[P]curl/lib/url.c |
resolve_server | static CURLcode resolve_server(struct Curl_easy *data,
struct connectdata *conn,
bool *async)
{
CURLcode result = CURLE_OK;
timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
/*************************************************************
* Re... | 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 -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x3ad90
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x38a(%rax)
je 0x2984a
movq -0x18(%rbp), %r... | /macressler[P]curl/lib/url.c |
findprotocol | static CURLcode findprotocol(struct Curl_easy *data,
struct connectdata *conn,
const char *protostr)
{
const struct Curl_handler * const *pp;
const struct Curl_handler *p;
/* Scan protocol handler table and match against 'protostr' to set a few
varia... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x68155(%rip), %rax # 0x91c60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x29bbc
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%r... | /macressler[P]curl/lib/url.c |
curl_version | char *curl_version(void)
{
static bool initialized;
static char version[200];
char *ptr = version;
size_t len;
size_t left = sizeof(version);
if(initialized)
return version;
strcpy(ptr, LIBCURL_NAME "/" LIBCURL_VERSION);
len = strlen(ptr);
left -= len;
ptr += len;
if(left > 1) {
len = C... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x67b01(%rip), %rax # 0x93be0
movq %rax, -0x10(%rbp)
movq $0xc8, -0x20(%rbp)
testb $0x1, 0x67ade(%rip) # 0x93bd0
je 0x2c104
leaq 0x67ae5(%rip), %rax # 0x93be0
movq %rax, -0x8(%rbp)
jmp 0x2c1f0
movq -0x10(%rbp), %rdi
leaq 0x51a1e(%rip), %rsi # 0x7db2d
call... | /macressler[P]curl/lib/version.c |
GetEnv | static
char *GetEnv(const char *variable)
{
#if defined(_WIN32_WCE) || defined(CURL_WINDOWS_APP)
(void)variable;
return NULL;
#else
#ifdef WIN32
char env[MAX_PATH]; /* MAX_PATH is from windef.h */
char *temp = getenv(variable);
env[0] = '\0';
if(temp != NULL)
ExpandEnvironmentStringsA(temp, env, sizeof(... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9c20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2c312
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2c312
leaq 0x6775d(%rip), %rax # 0x93a60
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
... | /macressler[P]curl/lib/getenv.c |
curl_easy_escape | char *curl_easy_escape(struct Curl_easy *data, const char *string,
int inlength)
{
size_t alloc;
char *ns;
char *testing_ptr = NULL;
unsigned char in; /* we need to treat the characters unsigned */
size_t newlen;
size_t strindex = 0;
size_t length;
CURLcode result;
if(inlength ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x50(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2c396
movq $0x0, -0x8(%rbp)
jmp 0x2c50c
cmpl $0x0, -0x1c(%rbp)
je 0x2c3a6
movslq -0x1c(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x2c3b... | /macressler[P]curl/lib/escape.c |
curl_easy_unescape | char *curl_easy_unescape(struct Curl_easy *data, const char *string,
int length, int *olen)
{
char *str = NULL;
if(length >= 0) {
size_t inputlen = length;
size_t outputlen;
CURLcode res = Curl_urldecode(data, 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 0x2c5f0
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30... | /macressler[P]curl/lib/escape.c |
Curl_isunreserved | static 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 ... | 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 0x2c646
movq -0x10(%rbp), %rax
leaq 0x5155d(%rip), %rcx # 0x7db94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x2c64... | /macressler[P]curl/lib/escape.c |
Curl_urldecode | CURLcode Curl_urldecode(struct Curl_easy *data,
const char *string, size_t length,
char **ostring, size_t *olen,
bool reject_ctrl)
{
size_t alloc = (length?length:strlen(string)) + 1;
char *ns = malloc(alloc);
unsigned char in;
size_t strin... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2c698
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x2c6a5
movq -0x18(%rbp), ... | /macressler[P]curl/lib/escape.c |
addbyter | static int addbyter(int output, FILE *data)
{
struct nsprintf *infop = (struct nsprintf *)data;
unsigned char outc = (unsigned char)output;
if(infop->length < infop->max) {
/* only do this if we haven't reached max length yet */
infop->buffer[0] = outc; /* store */
infop->buffer++; /* increase pointe... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2ddce
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movq (%rax),... | /macressler[P]curl/lib/mprintf.c |
curl_msnprintf | int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = curl_mvsnprintf(buffer, maxlength, format, ap_save);
va_end(ap_save);
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x2de1b
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/mprintf.c |
curl_maprintf | char *curl_maprintf(const char *format, ...)
{
va_list ap_save; /* argument pointer */
int retcode;
struct asprintf info;
info.buffer = NULL;
info.len = 0;
info.alloc = 0;
info.fail = 0;
va_start(ap_save, format);
retcode = dprintf_formatf(&info, alloc_addbyter, format, ap_save);
va_end(ap_save);
... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
testb %al, %al
je 0x2ded1
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(... | /macressler[P]curl/lib/mprintf.c |
alloc_addbyter | static int alloc_addbyter(int output, FILE *data)
{
struct asprintf *infop = (struct asprintf *)data;
unsigned char outc = (unsigned char)output;
if(!infop->buffer) {
infop->buffer = malloc(32);
if(!infop->buffer) {
infop->fail = 1;
return -1; /* fail */
}
infop->alloc = 32;
infop... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2e04d
movl $0x20, %edi
leaq 0x65a45(%rip), %rax # 0x93a48
callq *(%rax)
movq %rax, %rcx
mo... | /macressler[P]curl/lib/mprintf.c |
curl_mvaprintf | char *curl_mvaprintf(const char *format, va_list ap_save)
{
int retcode;
struct asprintf info;
info.buffer = NULL;
info.len = 0;
info.alloc = 0;
info.fail = 0;
retcode = dprintf_formatf(&info, alloc_addbyter, format, ap_save);
if((-1 == retcode) || info.fail) {
if(info.alloc)
free(info.buffe... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq -0x182(%rip), %rsi # 0x2dfd0
callq 0x2c900
movl %eax, -0x1c... | /macressler[P]curl/lib/mprintf.c |
curl_msprintf | int curl_msprintf(char *buffer, const char *format, ...)
{
va_list ap_save; /* argument pointer */
int retcode;
va_start(ap_save, format);
retcode = dprintf_formatf(&buffer, storebuffer, format, ap_save);
va_end(ap_save);
*buffer = 0; /* we terminate this with a zero byte */
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x2e20b
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/mprintf.c |
curl_mprintf | int curl_mprintf(const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = dprintf_formatf(stdout, fputc, format, ap_save);
va_end(ap_save);
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2e2f8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp... | /macressler[P]curl/lib/mprintf.c |
curl_mfprintf | int curl_mfprintf(FILE *whereto, const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = dprintf_formatf(whereto, fputc, format, ap_save);
va_end(ap_save);
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2e3a8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp... | /macressler[P]curl/lib/mprintf.c |
dprintf_Pass1 | static int dprintf_Pass1(const char *format, va_stack_t *vto, char **endpos,
va_list arglist)
{
char *fmt = (char *)format;
int param_num = 0;
long this_param;
long width;
long precision;
int flags;
long max_param = 0;
long i;
while(*fmt) {
if(*fmt++ == '%') {
if(*f... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2eb7c
movq -0x30(%rb... | /macressler[P]curl/lib/mprintf.c |
dprintf_DollarString | static long dprintf_DollarString(char *input, char **end)
{
int number = 0;
while(ISDIGIT(*input)) {
number *= 10;
number += *input-'0';
input++;
}
if(number && ('$'==*input++)) {
*end = input;
return number;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x6d3c0
cmpl $0x0, %eax
je 0x2f2bd
imull $0xa, -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x1c... | /macressler[P]curl/lib/mprintf.c |
telnet_do | static CURLcode telnet_do(struct connectdata *conn, bool *done)
{
CURLcode result;
struct Curl_easy *data = conn->data;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
#ifdef USE_WINSOCK
HMODULE wsock2;
WSOCK2_FUNC close_event_func;
WSOCK2_FUNC create_event_func;
WSOCK2_FUNC event_select_func;
WSOCK2_FU... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%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 $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movb $0x1, -0x71(%rbp)
movq -0x28(%rbp), %rax
movq ... | /macressler[P]curl/lib/telnet.c |
getinfo_slist | static CURLcode getinfo_slist(struct Curl_easy *data, CURLINFO info,
struct curl_slist **param_slistp)
{
union {
struct curl_certinfo *to_certinfo;
struct curl_slist *to_slist;
} ptr;
switch(info) {
case CURLINFO_SSL_ENGINES:
*param_slistp = Curl_ssl_engines_list(da... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0xffbfffe5, %eax # imm = 0xFFBFFFE5
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0x12, %eax
ja 0x333e7
movq -0x50(%rbp), %rax
leaq 0x4b55f(%rip), %rcx # 0x7e824
movslq ... | /macressler[P]curl/lib/getinfo.c |
readwrite_data | static CURLcode readwrite_data(struct Curl_easy *data,
struct connectdata *conn,
struct SingleRequest *k,
int *didwhat, bool *done,
bool *comeback)
{
CURLcode result = CURLE_OK;
ssize_t nread;... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %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)
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x51(%rbp)
movb $0x0, -0x52(%rbp)
movl $0x64, -0x58(%rbp)
movq -0x30(%rbp), %rax
m... | /macressler[P]curl/lib/transfer.c |
Curl_follow | CURLcode Curl_follow(struct Curl_easy *data,
char *newurl, /* the Location: string */
followtype type) /* see transfer.h */
{
#ifdef CURL_DISABLE_HTTP
(void)data;
(void)newurl;
(void)type;
/* Location: following will not happen when HTTP is disabled */
return CURLE... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movb $0x0, -0x1e(%rbp)
cmpl $0x3, -0x1c(%rbp)
jne 0x357db
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x258(%rax)
je 0x3571b
movq -0x10(%rbp), %rax
movq 0x250(%rax), %rax
movq -0x10(%rbp), %rcx... | /macressler[P]curl/lib/transfer.c |
concat_url | static char *concat_url(const char *base, const char *relurl)
{
/***
TRY to append this new path to the old URL
to the right of the host part. Oh crap, this is doomed to cause
problems in the future...
*/
char *newest;
char *protsep;
char *pathsep;
size_t newlen;
bool host_changed = FALSE;
con... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x5df2d(%rip), %rax # 0x93a60
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x35b54
movq $0x0, ... | /macressler[P]curl/lib/transfer.c |
data_pending | static int data_pending(const struct connectdata *conn)
{
/* in the case of libssh2, we can never be really sure that we have emptied
its internal buffers so we MUST always try until we get EAGAIN back */
return conn->handler->protocol&(CURLPROTO_SCP|CURLPROTO_SFTP) ||
#if defined(USE_NGHTTP2)
Curl_ssl_dat... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x3d0(%rax), %rax
movl 0x80(%rax), %ecx
andl $0x30, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jne 0x364f8
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x79570
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %... | /macressler[P]curl/lib/transfer.c |
easy_perform | static CURLcode easy_perform(struct Curl_easy *data, bool events)
{
struct Curl_multi *multi;
CURLMcode mcode;
CURLcode result = CURLE_OK;
SIGPIPE_VARIABLE(pipe_st);
if(!data)
return CURLE_BAD_FUNCTION_ARGUMENT;
if(data->set.errorbuffer)
/* clear this as early as possible */
data->set.errorbuf... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x36cb1
movl $0x2b, -0x4(%rbp)
jmp 0x36e21
movq -0x10(%rbp), %rax
cmpq $0x0, 0x200(%rax)
je 0x36ccd
movq -0x10(%rbp), %rax
movq 0x200(%rax), %rax
movb ... | /macressler[P]curl/lib/easy.c |
Curl_persistconninfo | void Curl_persistconninfo(struct connectdata *conn)
{
memcpy(conn->data->info.conn_primary_ip, conn->primary_ip, MAX_IPADR_LEN);
memcpy(conn->data->info.conn_local_ip, conn->local_ip, MAX_IPADR_LEN);
conn->data->info.conn_scheme = conn->handler->scheme;
conn->data->info.conn_protocol = conn->handler->protocol;
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x5158, %rdi # imm = 0x5158
addq $0x58, %rdi
movq -0x8(%rbp), %rsi
addq $0x1a2, %rsi # imm = 0x1A2
movl $0x2e, %edx
callq 0x97b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x5158, %rdi... | /macressler[P]curl/lib/connect.c |
Curl_updateconninfo | void Curl_updateconninfo(struct connectdata *conn, curl_socket_t sockfd)
{
curl_socklen_t len;
struct Curl_sockaddr_storage ssrem;
struct Curl_sockaddr_storage ssloc;
struct Curl_easy *data = conn->data;
if(conn->socktype == SOCK_DGRAM)
/* there's no connection! */
return;
if(!conn->bits.reuse && ... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x118(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0xc4(%rax)
jne 0x3b1b2
jmp 0x3b403
movq -0x8(%rbp), %rax
testb $0x1, 0x38a(%rax)
jne 0x3b3fa
movq -0x8(%rbp),... | /macressler[P]curl/lib/connect.c |
curl_multi_socket | CURLMcode curl_multi_socket(struct Curl_multi *multi, curl_socket_t s,
int *running_handles)
{
CURLMcode result;
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
result = multi_socket(multi, FALSE, s, 0, running_handles);
if(CURLM_OK >= result)
update_timer(multi);
r... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x1e0(%rax)
je 0x424f9
movl $0x8, -0x4(%rbp)
jmp 0x42526
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %r8
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x42530
m... | /macressler[P]curl/lib/multi.c |
multi_reconnect_request | static CURLcode multi_reconnect_request(struct connectdata **connp)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = *connp;
struct Curl_easy *data = conn->data;
/* This was a re-use of a connection and we got a write error in the
* DO-phase. Then we DISCONNECT this connection and have another attem... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x3c4c5(%rip), %rsi # 0x7f739
movb $0x0, %al
callq 0x19d00
movq -0x20(... | /macressler[P]curl/lib/multi.c |
tftp_tx | static CURLcode tftp_tx(tftp_state_data_t *state, tftp_event_t event)
{
struct Curl_easy *data = state->conn->data;
ssize_t sbytes;
int rblock;
CURLcode result = CURLE_OK;
struct SingleRequest *k = &data->req;
int cb; /* Bytes currently read */
switch(event) {
case TFTP_EVENT_ACK:
case TFTP_EVENT_OA... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
mo... | /macressler[P]curl/lib/tftp.c |
tftp_connect_for_rx | static CURLcode tftp_connect_for_rx(tftp_state_data_t *state,
tftp_event_t event)
{
CURLcode result;
#ifndef CURL_DISABLE_VERBOSE_STRINGS
struct Curl_easy *data = state->conn->data;
infof(data, "%s\n", "Connected for receive");
#endif
state->state = TFTP_STATE_RX;
result =... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x3aa11(%rip), %rsi # 0x841ea
leaq 0x37590(%rip), %rdx # 0x80d70
movb $0x0, %al
callq 0x19d00
movq -0x10(%rb... | /macressler[P]curl/lib/tftp.c |
tftp_parse_option_ack | static CURLcode tftp_parse_option_ack(tftp_state_data_t *state,
const char *ptr, int len)
{
const char *tmp = ptr;
struct Curl_easy *data = state->conn->data;
/* if OACK doesn't contain blksize option, the default (512) must be used */
state->blksize = TFTP_BLKSIZE_DEFAULT... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl $0x200, 0x154(%rax) # imm = 0x200
movq -0x2... | /macressler[P]curl/lib/tftp.c |
tftp_perform | static CURLcode tftp_perform(struct connectdata *conn, bool *dophase_done)
{
CURLcode result = CURLE_OK;
tftp_state_data_t *state = (tftp_state_data_t *)conn->proto.tftpc;
*dophase_done = FALSE;
result = tftp_state_machine(state, TFTP_EVENT_INIT);
if((state->state == TFTP_STATE_FIN) || res... | 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 0x628(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x48300
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %ra... | /macressler[P]curl/lib/tftp.c |
Curl_splay | struct Curl_tree *Curl_splay(struct curltime i,
struct Curl_tree *t)
{
struct Curl_tree N, *l, *r, *y;
long comp;
if(t == NULL)
return t;
N.smaller = N.larger = NULL;
l = r = &N;
for(;;) {
comp = compare(i, t->key);
if(comp < 0) {
if(t->smaller == NULL)
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x49d67
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a078
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x58(%rbp), %rax
... | /macressler[P]curl/lib/splay.c |
Curl_splayinsert | struct Curl_tree *Curl_splayinsert(struct curltime i,
struct Curl_tree *t,
struct Curl_tree *node)
{
static const struct curltime KEY_NOTUSED = {
(time_t)-1, (unsigned int)-1
}; /* will *NEVER* appear */
if(node == NULL)
return t;
i... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4a0bb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a2c8
cmpq $0x0, -0x20(%rbp)
je 0x4a1ae
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rdi
movl -0x10(%... | /macressler[P]curl/lib/splay.c |
Curl_splaygetbest | struct Curl_tree *Curl_splaygetbest(struct curltime i,
struct Curl_tree *t,
struct Curl_tree **removed)
{
static struct curltime tv_zero = {0, 0};
struct Curl_tree *x;
if(!t) {
*removed = NULL; /* none removed since there was no root */
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4a316
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x4a45b
movq -0x20(%rbp), %rdx
movq 0x49a07(%rip), %rdi # 0x93d28
movl 0x49a09... | /macressler[P]curl/lib/splay.c |
Curl_splayremovebyaddr | int Curl_splayremovebyaddr(struct Curl_tree *t,
struct Curl_tree *removenode,
struct Curl_tree **newroot)
{
static const struct curltime KEY_NOTUSED = {
(time_t)-1, (unsigned int)-1
}; /* will *NEVER* appear */
struct Curl_tree *x;
if(!t || !removenode)... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4a492
cmpq $0x0, -0x18(%rbp)
jne 0x4a49e
movl $0x1, -0x4(%rbp)
jmp 0x4a673
movq -0x18(%rbp), %rcx
movq $-0x1, %rax
cmpq 0x20(%rcx), %rax
jge 0x4a4b9
movl $0xffffffff, %eax #... | /macressler[P]curl/lib/splay.c |
imap_perform_list | static CURLcode imap_perform_list(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct IMAP *imap = data->req.protop;
char *mailbox;
if(imap->custom)
/* Send the custom request */
result = imap_sendf(conn, "%s%s", imap->custom,
im... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x4eef1
movq -0x10(%rbp), %rax
movq %rax, -0x40(%... | /macressler[P]curl/lib/imap.c |
imap_perform_search | static CURLcode imap_perform_search(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct IMAP *imap = conn->data->req.protop;
/* Check we have a query string */
if(!imap->query) {
failf(conn->data, "Cannot SEARCH without a query string.");
return CURLE_URL_MALFORMAT;
}
/* Send the SEARCH... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x4efde
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x32d6c(%rip), %rsi # 0x81d3a
movb $... | /macressler[P]curl/lib/imap.c |
imap_perform_fetch | static CURLcode imap_perform_fetch(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct IMAP *imap = conn->data->req.protop;
/* Check we have a UID */
if(!imap->uid) {
failf(conn->data, "Cannot FETCH without a UID.");
return CURLE_URL_MALFORMAT;
}
/* Send the FETCH command */
if(imap->... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x4f071
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x32d0c(%rip), %rsi # 0x81d6a
movb $... | /macressler[P]curl/lib/imap.c |
imap_get_message | static void imap_get_message(char *buffer, char **outptr)
{
size_t len = strlen(buffer);
char *message = NULL;
if(len > 2) {
/* Find the start of the message */
len -= 2;
for(message = buffer + 2; *message == ' ' || *message == '\t';
message++, len--)
;
/* Find the end of the messa... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x93b0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x18(%rbp)
jbe 0x4f43d
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x2... | /macressler[P]curl/lib/imap.c |
imap_dophase_done | static CURLcode imap_dophase_done(struct connectdata *conn, bool connected)
{
struct IMAP *imap = conn->data->req.protop;
(void)connected;
if(imap->transfer != FTPTRANSFER_BODY)
/* no data to transfer */
Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4fe27
movq -0x8(%rbp), %rdi
movl $0xffffffff, %r9d # imm = 0xFFFF... | /macressler[P]curl/lib/imap.c |
imap_perform_select | static CURLcode imap_perform_select(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct IMAP *imap = data->req.protop;
struct imap_conn *imapc = &conn->proto.imapc;
char *mailbox;
/* Invalidate old information as we are switching mailboxes */
Curl_safefree(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x30(%rbp)
leaq 0x4... | /macressler[P]curl/lib/imap.c |
pop3_connect | static CURLcode pop3_connect(struct connectdata *conn, bool *done)
{
CURLcode result = CURLE_OK;
struct pop3_conn *pop3c = &conn->proto.pop3c;
struct pingpong *pp = &pop3c->pp;
*done = FALSE; /* default to not done yet */
/* We always support persistent connections in POP3 */
connkeep(conn, "POP3 default"... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
xorl %es... | /macressler[P]curl/lib/pop3.c |
pop3_endofresp | static bool pop3_endofresp(struct connectdata *conn, char *line, size_t len,
int *resp)
{
struct pop3_conn *pop3c = &conn->proto.pop3c;
/* Do we have an error response? */
if(len >= 4 && !memcmp("-ERR", line, 4)) {
*resp = '-';
return TRUE;
}
/* Are we processing CAPA com... | 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 -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x30(%rbp)
cmpq $0x4, -0x20(%rbp)
jb 0x50c76
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl $0x5252452d, %e... | /macressler[P]curl/lib/pop3.c |
pop3_perform_upgrade_tls | static CURLcode pop3_perform_upgrade_tls(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct pop3_conn *pop3c = &conn->proto.pop3c;
/* Start the SSL connection */
result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &pop3c->ssldone);
if(!result) {
if(pop3c->state != POP3_UPGRADETLS)
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x74, %rdx
xorl %esi, %esi
callq 0x787f0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x50... | /macressler[P]curl/lib/pop3.c |
pop3_perform_apop | static CURLcode pop3_perform_apop(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct pop3_conn *pop3c = &conn->proto.pop3c;
size_t i;
MD5_context *ctxt;
unsigned char digest[MD5_DIGEST_LEN];
char secret[2 * MD5_DIGEST_LEN + 1];
/* Check we have a username and password to authenticate with and... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x390(%rax)
jne 0x51b87
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x50f30
movl -0x14(%rbp), %eax
movl %... | /macressler[P]curl/lib/pop3.c |
smtp_parse_custom_request | static CURLcode smtp_parse_custom_request(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct SMTP *smtp = data->req.protop;
const char *custom = data->set.str[STRING_CUSTOMREQUEST];
/* URL decode the custom request */
if(custom)
result = Curl_urldecode(d... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x820(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x543... | /macressler[P]curl/lib/smtp.c |
smtp_perform_mail | static CURLcode smtp_perform_mail(struct connectdata *conn)
{
char *from = NULL;
char *auth = NULL;
char *size = NULL;
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
/* Calculate the FROM parameter */
if(!data->set.str[STRING_MAIL_FROM])
/* Null reverse-path, RFC-5321, sect. 3.6.3 *... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x988(%rax)
jne 0x5464a
leaq 0x2db28(%rip), %rdi # 0x82163
... | /macressler[P]curl/lib/smtp.c |
curl_thread_create_thunk | static void *curl_thread_create_thunk(void *arg)
{
struct curl_actual_call * ac = arg;
unsigned int (*func)(void *) = ac->func;
void *real_arg = ac->arg;
free(ac);
(*func)(real_arg);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x3c8fe(%rip), %rax # 0x93a50
movq (%rax), %rax
movq -0x10(%rbp), %rd... | /macressler[P]curl/lib/curl_threads.c |
curlx_ultous | unsigned short curlx_ultous(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT);
#ifdef __IN... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x5721a
movq -0x8(%rbp), %rax
andq $0xffff, %rax # imm = 0xFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_ultouc | unsigned char curlx_ultouc(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR);
return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
#ifdef __INTEL_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x5723a
movq -0x8(%rbp), %rax
andq $0xff, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_sltous | unsigned short curlx_sltous(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(slnum & (long) CURL_M... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x5733a
jmp 0x5733c
jmp 0x5733e
movq -0x8(%rbp), %rax
andq $0xffff, %rax # imm = 0xFFFF
popq %rbp
retq
nopw (%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x5739a
jmp 0x5739c
jmp 0x5739e
movq -0x8(%rbp), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw (%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_sitouz | size_t curlx_sitouz(int sinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sinum >= 0);
return (size_t) sinum;
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x57419
movslq -0x4(%rbp), %rax
popq %rbp
retq
nop
| /macressler[P]curl/lib/warnless.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.