name string | code string | asm string | file string |
|---|---|---|---|
HTTPAPI_CloseConnection | void HTTPAPI_CloseConnection(HTTP_HANDLE handle)
{
HTTP_HANDLE_DATA* httpHandleData = (HTTP_HANDLE_DATA*)handle;
if (httpHandleData != NULL)
{
free(httpHandleData->hostURL);
httpHandleData->hostURL = NULL;
curl_easy_cleanup(httpHandleData->curl);
#ifdef USE_OPENSSL
#ifndef OPENSSL_NO... | testq %rdi, %rdi
je 0x80f84
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1c630
movq $0x0, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x1c650
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x80f6d
callq 0x1c930
movq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x80f7b
callq 0x1c630
movq %rbx, %rdi
popq %rbx
j... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/httpapi_curl.c |
HTTPAPI_ExecuteRequest | HTTPAPI_RESULT HTTPAPI_ExecuteRequest(HTTP_HANDLE handle, HTTPAPI_REQUEST_TYPE requestType, const char* relativePath,
HTTP_HEADERS_HANDLE httpHeadersHandle, const unsigned char* content,
size_t contentLength, unsigned int* statusCode,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
testq %r14, %r14
sete %al
orb %cl, %al
jne 0x80fc4
movq %r9, %r12
movq %r8, %r13
testq %r8, %r8
setne %al
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0x8102b
c... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/httpapi_curl.c |
HeadersWriteFunction | static size_t HeadersWriteFunction(void *ptr, size_t size, size_t nmemb, void *userdata)
{
HTTP_HEADERS_HANDLE responseHeadersHandle = (HTTP_HEADERS_HANDLE)userdata;
char* headerLine = (char*)ptr;
if (headerLine != NULL)
{
char* token = strtok(headerLine, "\r\n");
while ((token != NULL)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x82380
movq %rcx, %r15
leaq 0xcf0b(%rip), %rsi # 0x8f231
callq 0x1c7f0
testq %rax, %rax
je 0x82380
movq %rax, %r13
leaq 0xcef7(%rip), %r12 # 0x8f231
cmpb $0x0, (%r13)
je 0x82380
mo... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/httpapi_curl.c |
HTTPAPI_CloneOption | HTTPAPI_RESULT HTTPAPI_CloneOption(const char* optionName, const void* value, const void** savedValue)
{
HTTPAPI_RESULT result;
if (
(optionName == NULL) ||
(value == NULL) ||
(savedValue == NULL)
)
{
result = HTTPAPI_INVALID_ARG;
LogError("invalid argument(NU... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0x82d83
callq 0x7e153
movl $0x2, %ebx
testq %rax, %rax
je 0x82f7e
movq %rax, %r10
leaq 0x3393d(%rip), %rsi # 0xb669b
leaq 0x34060(%rip), %rdx... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/httpapi_curl.c |
tlsio_openssl_init | int tlsio_openssl_init(void)
{
(void)SSL_library_init();
SSL_load_error_strings();
ERR_load_BIO_strings();
OpenSSL_add_all_algorithms();
if (openssl_static_locks_install() != 0)
{
LogInfo("Failed to install static locks in OpenSSL!");
return MU_FAILURE;
}
openssl_dynam... | pushq %rbp
pushq %rbx
pushq %rax
xorl %edi, %edi
xorl %esi, %esi
callq 0x1c480
movl $0x200002, %edi # imm = 0x200002
xorl %esi, %esi
callq 0x1c480
callq 0x1c1a0
movl $0xc, %edi
xorl %esi, %esi
callq 0x1c290
cmpq $0x0, 0x52b7e(%rip) # 0xd5f58
je 0x83458
callq 0x7e153
testq %rax, %rax
je 0x83413
movq %rax, %r... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/tlsio_openssl.c |
on_underlying_io_bytes_received | static void on_underlying_io_bytes_received(void* context, const unsigned char* buffer, size_t size)
{
TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context;
int written = BIO_write(tls_io_instance->in_bio, buffer, (int)size);
if (written != (int)size)
{
tls_io_instance->tlsio_state = TL... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x1c590
cmpl %r14d, %eax
jne 0x83fbf
movl 0x68(%rbx), %eax
cmpl $0x4, %eax
je 0x83fe7
cmpl $0x2, %eax
jne 0x840db
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
p... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/tlsio_openssl.c |
tlsio_openssl_dowork | void tlsio_openssl_dowork(CONCRETE_IO_HANDLE tls_io)
{
if (tls_io == NULL)
{
LogError("NULL tls_io.");
}
else
{
TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io;
switch (tls_io_instance->tlsio_state)
{
case TLSIO_STATE_OPENING_UNDERLYING_IO:
... | pushq %rbx
testq %rdi, %rdi
je 0x8451c
movq %rdi, %rbx
movl 0x68(%rdi), %eax
cmpl $0x4, %eax
ja 0x844ec
movl $0x16, %ecx
btl %eax, %ecx
jae 0x844ec
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x843a7
movl 0x68(%rbx), %eax
testl %eax, %eax
je 0x84551
movq (%rbx), %rdi
callq 0x79722
cmpl $0x3, 0x68(%rbx)
jne 0x... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/tlsio_openssl.c |
load_ecc_key | static int load_ecc_key(SSL_CTX* ssl_ctx, EVP_PKEY* evp_key)
{
int result;
/* Codes_SRS_X509_OPENSSL_07_004: [ x509_openssl_add_ecc_credentials shall import the certification using by the EVP_PKEY. ] */
if (SSL_CTX_use_PrivateKey(ssl_ctx, evp_key) != 1)
{
LogError("Failed SSL_CTX_use_PrivateKey"... | pushq %rbx
callq 0x1c450
xorl %ebx, %ebx
cmpl $0x1, %eax
je 0x85c2c
callq 0x7e153
movl $0x80, %ebx
testq %rax, %rax
je 0x85c2c
movq %rax, %r10
leaq 0x32319(%rip), %rsi # 0xb7f25
leaq 0x32651(%rip), %rdx # 0xb8264
leaq 0x32657(%rip), %r9 # 0xb8271
xorl %edi, %edi
movl $0x7f, %ecx
movl $0x1, %r8d
xorl %eax, ... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/x509_openssl.c |
hmacReset | int hmacReset(HMACContext *ctx, enum SHAversion whichSha,
const unsigned char *key, int key_len)
{
int i, blocksize, hashsize;
/* inner padding - key XORd with ipad */
unsigned char k_ipad[USHA_Max_Message_Block_Size];
/* temporary buffer when keylen > blocksize */
unsigned char tempkey[USHAMa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %ecx, %r12d
movl $0x1, %ecx
testq %rdi, %rdi
je 0x863f6
movq %rdx, %r13
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %edi
callq 0x86629
movl %eax, %ebp
movl %eax, 0x8(%r14)
movl %r15d, %edi
callq 0x86640
mov... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/src/hmac.c |
destroy_socket_io_instance | static void destroy_socket_io_instance(SOCKET_IO_INSTANCE* instance)
{
if (instance->dns_resolver != NULL)
{
dns_resolver_destroy(instance->dns_resolver);
}
free(instance->hostname);
free(instance->target_mac_address);
if (instance->pending_io_list != NULL)
{
singlylinkedli... | pushq %rbx
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
testq %rdi, %rdi
je 0x8689e
callq 0x8858c
movq 0x38(%rbx), %rdi
callq 0x1c630
movq 0x48(%rbx), %rdi
callq 0x1c630
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x868be
callq 0x79ad3
movq %rbx, %rdi
popq %rbx
jmp 0x1c630
| /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/socketio_berkeley.c |
socketio_dowork | void socketio_dowork(CONCRETE_IO_HANDLE socket_io)
{
if (socket_io != NULL)
{
SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io;
signal(SIGPIPE, SIG_IGN);
if (socket_io_instance->io_state == IO_STATE_OPEN)
{
LIST_ITEM_HANDLE first_pending_io = s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x873b8
movq %rdi, %rbx
movl $0x1, %esi
movl $0xd, %edi
callq 0x1c620
movl 0x50(%rbx), %eax
cmpl $0x1, %eax
je 0x87232
cmpl $0x2, %eax
jne 0x873b8
movq 0x58(%rbx), %rdi
callq 0x79c50
testq %rax, %rax
je 0x87368
movq %rax, %... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/socketio_berkeley.c |
socketio_setoption | int socketio_setoption(CONCRETE_IO_HANDLE socket_io, const char* optionName, const void* value)
{
int result;
if (socket_io == NULL ||
optionName == NULL ||
value == NULL)
{
result = MU_FAILURE;
}
else
{
SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANC... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
movl $0x4ba, %ebp # imm = 0x4BA
jne 0x87eca
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30986(%rip), %rsi # 0xb8756
movq %r15, %rdi
cal... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/adapters/socketio_berkeley.c |
SHA1Finalize | static void SHA1Finalize(SHA1Context *context, uint8_t Pad_Byte)
{
int i;
SHA1PadMessage(context, Pad_Byte);
/* message may be sensitive, clear it out */
for (i = 0; i < SHA1_Message_Block_Size; ++i)
context->Message_Block[i] = 0;
context->Length_Low = 0; /* and clear length */
context-... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movswq 0x1c(%rdi), %rcx
leaq 0x1e(%rdi), %r14
leal 0x1(%rcx), %eax
movw %ax, 0x1c(%rdi)
cmpq $0x38, %rcx
jl 0x88a9f
movb %sil, (%r14,%rcx)
cmpw $0x3f, %ax
jg 0x88a95
leal 0x1(%rax), %ecx
movw %cx, 0x1c(%rbx)
movswq %ax, %rax
movb $0x0, 0x1e(%rbx,%rax)
movzwl 0x1c(%rbx), ... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/src/sha1.c |
SHA224_256Reset | static int SHA224_256Reset(SHA256Context *context, uint32_t *H0)
{
int result;
if (!context)
{
result = shaNull;
}
else
{
context->Length_Low = 0;
context->Length_High = 0;
context->Message_Block_Index = 0;
context->Intermediate_Hash[0] = H0[0];
c... | testq %rdi, %rdi
je 0x88bc5
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movw $0x0, 0x28(%rdi)
movl (%rsi), %ecx
movl %ecx, (%rdi)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rsi), %ecx
movl %ecx, 0x8(%rdi)
movl 0xc(%rsi), %ecx
movl %ecx, 0xc(%rdi)
movl 0x10(%rsi), %ecx
movl %ecx, 0x10(%rdi)
movl 0x14(%rsi), %ecx
movl... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/src/sha224.c |
SHA256Input | int SHA256Input(SHA256Context *context, const uint8_t *message_array, unsigned int length)
{
int result;
uint32_t addTemp;
if (!length)
{
result = shaSuccess;
}
else if (!context || !message_array)
{
result = shaNull;
}
else if (context->Computed)
{
result... | testl %edx, %edx
je 0x88c0d
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0x1, %eax
orb %cl, %dl
jne 0x88c81
cmpl $0x0, 0x6c(%rbx)
je 0x88c10
movl $0x3, 0x70(%rbx)
movl $0x3, %eax
jmp 0x88c81
xorl %eax, %eax
retq
movl 0x70(%rbx... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/c-utility/src/sha224.c |
json_object_getn_value | static JSON_Value * json_object_getn_value(const JSON_Object *object, const char *name, size_t name_len) {
unsigned long hash = 0;
parson_bool_t found = PARSON_FALSE;
size_t cell_ix = 0;
size_t item_ix = 0;
if (!object || !name) {
return NULL;
}
hash = hash_string(name, name_len);
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x89fc1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0x89fc4
movl $0x1505, %edi # imm = 0x1505
xorl %eax, %eax
movzbl (%rsi,%rax), %r8d
testq %r8, %r8
je 0x89fcb
movq %rdi, %rcx
shlq $0x5, %rcx
addq %rdi, %rcx
addq %r... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_object_dotget_value | JSON_Value * json_object_dotget_value(const JSON_Object *object, const char *name) {
const char *dot_position = strchr(name, '.');
if (!dot_position) {
return json_object_get_value(object, name);
}
object = json_value_get_object(json_object_getn_value(object, name, dot_position - name));
ret... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x1c200
testq %rax, %rax
je 0x8a17f
movq %rax, %r14
movq %r14, %rdx
subq %r15, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x89f7a
testq %rax, %rax
je 0x8a162
cmpl $0x4, 0x8(%rax)
jne 0x8a162
movq 0x10(%rax), %rbx
jmp... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_array_get_string_len | JSON_Value * json_array_get_value(const JSON_Array *array, size_t index) {
if (array == NULL || index >= json_array_get_count(array)) {
return NULL;
}
return array->items[index];
} | testq %rdi, %rdi
je 0x8a357
cmpq %rsi, 0x10(%rdi)
jbe 0x8a357
movq 0x8(%rdi), %rax
movq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0x8a357
cmpl $0x2, 0x8(%rax)
jne 0x8a357
movq 0x18(%rax), %rax
retq
xorl %eax, %eax
retq
| /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_value_init_string_with_len | JSON_Value * json_value_init_string_with_len(const char *string, size_t length) {
char *copy = NULL;
JSON_Value *value;
if (string == NULL) {
return NULL;
}
if (!is_valid_utf8(string, length)) {
return NULL;
}
copy = parson_strndup(string, length);
if (copy == NULL) {
... | testq %rdi, %rdi
je 0x8a777
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jle 0x8a72b
leaq (%r14,%rbx), %rcx
xorl %eax, %eax
movq %r14, %rdx
movzbl (%rdx), %esi
cmpl $0xf4, %esi
ja 0x8a785
movl %esi, %edi
andb $-0x2, %dil
cmpb $-0x40, %dil
je 0x8a785
movl %esi, %edi
andl $-0x40, %edi... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_serialize_to_file | JSON_Status json_serialize_to_file(const JSON_Value *value, const char *filename) {
JSON_Status return_code = JSONSuccess;
FILE *fp = NULL;
char *serialized_string = json_serialize_to_string(value);
if (serialized_string == NULL) {
return JSONFailure;
}
fp = fopen(filename, "w");
if ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x8b2dd
testq %rax, %rax
je 0x8b2c1
movq %rax, %rbx
leaq 0x292aa(%rip), %rsi # 0xb4531
movq %r14, %rdi
callq 0x1c610
testq %rax, %rax
je 0x8b2c8
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c5d0
cmpl $-0x1, %eax
sete %bpl
movq %r14, %rdi
callq 0x1c5... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_array_replace_string_with_len | JSON_Status json_array_replace_string_with_len(JSON_Array *array, size_t i, const char *string, size_t len) {
JSON_Value *value = json_value_init_string_with_len(string, len);
if (value == NULL) {
return JSONFailure;
}
if (json_array_replace_value(array, i, value) != JSONSuccess) {
json_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x8a573
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x8b5ee
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8b509
testl %eax, %eax
je 0x8b5ec
movq ... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_array_append_string | JSON_Status json_array_append_string(JSON_Array *array, const char *string) {
JSON_Value *value = json_value_init_string(string);
if (value == NULL) {
return JSONFailure;
}
if (json_array_append_value(array, value) != JSONSuccess) {
json_value_free(value);
return JSONFailure;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x8a556
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x8b7ff
movq %rax, %r14
testq %r15, %r15
je 0x8b7f7
cmpq $0x0, (%r14)
jne 0x8b7f7
movq %r15, %rdi
movq %r14, %rsi
callq 0x8ab12
testl %eax, %eax
je 0x8b807
movq %r14, %rdi
c... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_object_get_cell_ix | static size_t json_object_get_cell_ix(const JSON_Object *object, const char *key, size_t key_len, unsigned long hash, parson_bool_t *out_found) {
size_t cell_ix = hash & (object->cell_capacity - 1);
size_t cell = 0;
size_t ix = 0;
unsigned int i = 0;
unsigned long hash_to_check = 0;
const char *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x40(%rdi), %r12
leaq -0x1(%r12), %rsi
movq %r12, 0x28(%rsp)
movl $0x0, (%r8)
subq $0x1, %r12
movq %r12, 0x30(%rsp)
jb 0x8bbf4
movq %rdi, %r13
movq %r8, 0x10(%rsp)
andq %rcx, %rsi
movq 0x8(... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_object_grow_and_rehash | static JSON_Status json_object_grow_and_rehash(JSON_Object *object) {
JSON_Value *wrapping_value = NULL;
JSON_Object new_object;
char *key = NULL;
JSON_Value *value = NULL;
unsigned int i = 0;
size_t new_capacity = MAX(object->cell_capacity * 2, STARTING_CAPACITY);
JSON_Status res = json_obj... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
addq %rax, %rax
cmpq $0x11, %rax
movl $0x10, %r13d
cmovaeq %rax, %r13
movq $0x0, 0x40(%rsp)
movq %r13, 0x50(%rsp)
leaq (,%r13,8), %rdi
movq %rdi, %rax
subq %r13, %rax
movabsq $-0x3333333333333333, %r... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_object_dotset_number | JSON_Status json_object_dotset_number(JSON_Object *object, const char *name, double number) {
JSON_Value *value = json_value_init_number(number);
if (value == NULL) {
return JSONFailure;
}
if (json_object_dotset_value(object, name, value) != JSONSuccess) {
json_value_free(value);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %xmm0, %rax
btrq $0x3f, %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jg 0x8c296
movq %rsi, %r14
movq %rdi, %r15
movq %xmm0, (%rsp)
movl $0x20, %edi
callq *0x49aa0(%rip) ... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_validate | JSON_Status json_validate(const JSON_Value *schema, const JSON_Value *value) {
JSON_Value *temp_schema_value = NULL, *temp_value = NULL;
JSON_Array *schema_array = NULL, *value_array = NULL;
JSON_Object *schema_object = NULL, *value_object = NULL;
JSON_Value_Type schema_type = JSONError, value_type = JS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x8c5d7
movl 0x8(%rdi), %edx
movl 0x8(%rsi), %ecx
cmpl %ecx, %edx
setne %al
cmpl $0x1, %edx
setne %r8b
testb %al, %r8b
je 0x8c5eb
movl $0xffffffff, %eax # imm = 0xFFFFF... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_array_resize | static JSON_Status json_array_resize(JSON_Array *array, size_t new_capacity) {
JSON_Value **new_items = NULL;
if (new_capacity == 0) {
return JSONFailure;
}
new_items = (JSON_Value**)parson_malloc(new_capacity * sizeof(JSON_Value*));
if (new_items == NULL) {
return JSONFailure;
}... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x8cf56
movq %rsi, %r14
movq %rdi, %r15
leaq (,%rsi,8), %rdi
callq *0x48de3(%rip) # 0xd5cf8
testq %rax, %rax
je 0x8cf56
movq %rax, %r12
movq 0x8(%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rs... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_object_deinit | static void json_object_deinit(JSON_Object *object, parson_bool_t free_keys, parson_bool_t free_values) {
unsigned int i = 0;
for (i = 0; i < object->count; i++) {
if (free_keys) {
parson_free(object->names[i]);
}
if (free_values) {
json_value_free(object->values[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
cmpq $0x0, 0x30(%rdi)
je 0x8cfba
movl %edx, %ebp
movl %esi, %r14d
movl $0x1, %r12d
xorl %r13d, %r13d
testl %r14d, %r14d
je 0x8cf9e
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rdi
callq *0x48d52(%rip) ... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
json_serialize_string | static int json_serialize_string(const char *string, size_t len, char *buf) {
size_t i = 0;
char c = '\0';
int written = -1, written_total = 0;
APPEND_STRING("\"");
for (i = 0; i < len; i++) {
c = string[i];
switch (c) {
case '\"': APPEND_STRING("\\\""); break;
... | testq %rdx, %rdx
je 0x8d027
movw $0x22, (%rdx)
incq %rdx
jmp 0x8d029
xorl %edx, %edx
testq %rsi, %rsi
je 0x8d416
movl $0x1, %eax
xorl %ecx, %ecx
leaq 0x2c54c(%rip), %r8 # 0xb958c
movzbl (%rdi,%rcx), %r10d
cmpq $0x2f, %r10
ja 0x8d06f
movslq (%r8,%r10,4), %r9
addq %r8, %r9
jmpq *%r9
movl $0x6, %r9d
testq %rdx, %rdx
... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/deps/parson/parson.c |
CVodeInitB | int CVodeInitB(void* cvode_mem, int which, CVRhsFnB fB, sunrealtype tB0,
N_Vector yB0)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void* cvodeB_mem;
int flag;
/* Check if cvode_mem exists */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf5fb
cmpl $0x0, 0xa78(%rdi)
je 0xf61e
movq 0xa70(%rdi), %r15
cmpl %esi, 0x38(%r15)
jle 0xf63f
movq %rcx, %rbx
movq %rdx, %r14
addq $0x30, %r15
movq (%r15), %r15
testq %r15, %r15
je 0xf672
cmpl %esi, (%r15)
je 0xf672
addq $0x78, %r15
jmp 0xf5e4... | /LLNL[P]sundials/src/cvodes/cvodea.c |
CVArhsQ | static int CVArhsQ(sunrealtype t, N_Vector yB, N_Vector qBdot, void* cvode_mem)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
/* int flag; */
int retval;
cv_mem = (CVodeMem)cvode_mem;
ca_mem = cv_mem->cv_adj_mem;
cvB_mem = ca_mem->ca_bckpbCrt;
/* Get forward solution from interpolation */... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa70(%rdx), %r12
movq 0x40(%r12), %r15
movq 0xa8(%r12), %rcx
cmpl $0x0, 0xbc(%r12)
movq 0x1f8(%r12), %rsi
je 0xfbda
movq 0x200(%r12), %rdx
jmp 0xfbdc
xorl %edx, %edx
movq %rax, %rdi
movsd %xmm0, (%rsp)
callq *%r... | /LLNL[P]sundials/src/cvodes/cvodea.c |
CVodeQuadReInitB | int CVodeQuadReInitB(void* cvode_mem, int which, N_Vector yQB0)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void* cvodeB_mem;
int flag;
/* Check if cvode_mem exists */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (CV_M... | pushq %rbx
testq %rdi, %rdi
je 0xfd41
cmpl $0x0, 0xa78(%rdi)
je 0xfd64
movq 0xa70(%rdi), %rax
cmpl %esi, 0x38(%rax)
jle 0xfd85
addq $0x30, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xfdaf
cmpl %esi, (%rax)
je 0xfdaf
addq $0x78, %rax
jmp 0xfd2f
leaq 0x25549(%rip), %rcx # 0x35291
leaq 0x2532e(%rip), %r8 # 0x350... | /LLNL[P]sundials/src/cvodes/cvodea.c |
CVodeQuadSVtolerancesB | int CVodeQuadSVtolerancesB(void* cvode_mem, int which, sunrealtype reltolQB,
N_Vector abstolQB)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void* cvodeB_mem;
int flag;
/* Check if cvode_mem exists */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __... | pushq %rbx
testq %rdi, %rdi
je 0xfe96
cmpl $0x0, 0xa78(%rdi)
je 0xfeb9
movq 0xa70(%rdi), %rax
cmpl %esi, 0x38(%rax)
jle 0xfeda
addq $0x30, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xff04
cmpl %esi, (%rax)
je 0xff04
addq $0x78, %rax
jmp 0xfe84
leaq 0x2541c(%rip), %rcx # 0x352b9
leaq 0x251d9(%rip), %r8 # 0x350... | /LLNL[P]sundials/src/cvodes/cvodea.c |
CVodeB | int CVodeB(void* cvode_mem, sunrealtype tBout, int itaskB)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem, tmp_cvB_mem;
CVckpntMem ck_mem;
int sign, flag = 0;
sunrealtype tfuzz, tBret, tBn;
sunbooleantype gotCheckpoint, isActive, reachedTBout;
/* Check if cvode_mem exists */
if (cvode_mem == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rdi, %rdi
je 0xff6f
movq %rdi, %rbx
cmpl $0x0, 0xa78(%rdi)
je 0xff94
movq 0xa70(%rbx), %r13
cmpl $0x0, 0x38(%r13)
je 0xffba
cmpl $0x0, 0x10(%r13)
je 0xfff7
leaq 0x25380(%rip), %rcx # 0x352d0
leaq 0x25126(%rip), %r8 # 0x35... | /LLNL[P]sundials/src/cvodes/cvodea.c |
CVodeSetStabLimDetB | int CVodeSetStabLimDetB(void* cvode_mem, int which, sunbooleantype stldetB)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void* cvodeB_mem;
int flag;
/* Check if cvode_mem exists */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
... | pushq %rbx
testq %rdi, %rdi
je 0x11098
cmpl $0x0, 0xa78(%rdi)
je 0x110bb
movq 0xa70(%rdi), %rax
cmpl %esi, 0x38(%rax)
jle 0x110dc
addq $0x30, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x11106
cmpl %esi, (%rax)
je 0x11106
addq $0x78, %rax
jmp 0x11086
leaq 0x2453a(%rip), %rcx # 0x355d9
leaq 0x2448a(%rip), %r8 #... | /LLNL[P]sundials/src/cvodes/cvodea_io.c |
CVodeSetInitStepB | int CVodeSetInitStepB(void* cvode_mem, int which, sunrealtype hinB)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void* cvodeB_mem;
int flag;
/* Check if cvode_mem exists */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (... | pushq %rbx
testq %rdi, %rdi
je 0x11143
cmpl $0x0, 0xa78(%rdi)
je 0x11166
movq 0xa70(%rdi), %rax
cmpl %esi, 0x38(%rax)
jle 0x11187
addq $0x30, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x111b1
cmpl %esi, (%rax)
je 0x111b1
addq $0x78, %rax
jmp 0x11131
leaq 0x244a3(%rip), %rcx # 0x355ed
leaq 0x243df(%rip), %r8 #... | /LLNL[P]sundials/src/cvodes/cvodea_io.c |
CVodeSetQuadErrConB | int CVodeSetQuadErrConB(void* cvode_mem, int which, sunbooleantype errconQB)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void* cvodeB_mem;
int flag;
/* Check if cvode_mem exists */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
... | pushq %rbx
testq %rdi, %rdi
je 0x11404
cmpl $0x0, 0xa78(%rdi)
je 0x11427
movq 0xa70(%rdi), %rax
cmpl %esi, 0x38(%rax)
jle 0x11448
addq $0x30, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x11472
cmpl %esi, (%rax)
je 0x11472
addq $0x78, %rax
jmp 0x113f2
leaq 0x2422b(%rip), %rcx # 0x35636
leaq 0x2411e(%rip), %r8 #... | /LLNL[P]sundials/src/cvodes/cvodea_io.c |
CVodeGetAdjCVodeBmem | void* CVodeGetAdjCVodeBmem(void* cvode_mem, int which)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void* cvodeB_mem;
/* Check if cvode_mem exists */
if (cvode_mem == NULL)
{
cvProcessError(NULL, 0, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (NULL);
}
cv_mem = (CVodeMem)cvo... | pushq %rbx
testq %rdi, %rdi
je 0x114af
cmpl $0x0, 0xa78(%rdi)
je 0x114d1
movq 0xa70(%rdi), %rax
cmpl %esi, 0x38(%rax)
jle 0x114f1
addq $0x30, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1151b
cmpl %esi, (%rax)
je 0x1151b
addq $0x78, %rax
jmp 0x1149d
leaq 0x24194(%rip), %rcx # 0x3564a
leaq 0x24073(%rip), %r8 #... | /LLNL[P]sundials/src/cvodes/cvodea_io.c |
CVodeGetAdjDataPointPolynomial | int CVodeGetAdjDataPointPolynomial(void* cvode_mem, int which, sunrealtype* t,
int* order, N_Vector y)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVdtpntMem* dt_mem;
CVpolynomialDataMem content;
/* Check if cvode_mem exists */
if (cvode_mem == NULL)
{
cvProcessError(NULL, ... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x11726
cmpl $0x0, 0xa78(%rdi)
je 0x11749
movq 0xa70(%rdi), %rax
cmpl $0x2, 0x88(%rax)
jne 0x1176a
movq %rcx, %rbx
movq 0x78(%rax), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rdx)
movq 0x8(%rax), %r14
testq %r8, %r8
je 0x1171c
... | /LLNL[P]sundials/src/cvodes/cvodea_io.c |
cvSensRhs1InternalDQ | int cvSensRhs1InternalDQ(SUNDIALS_MAYBE_UNUSED int Ns, sunrealtype t, N_Vector y,
N_Vector ydot, int is, N_Vector yS, N_Vector ySdot,
void* cvode_mem, N_Vector ytemp, N_Vector ftemp)
{
CVodeMem cv_mem;
int retval, method;
int nfel = 0, which;
sunrealtype psave, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r13
movq %r8, %rbp
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r15
movsd %xmm0, 0x8(%rsp)
movq 0xc0(%rsp), %r14
movsd 0x28(%r14), %xmm0
maxsd 0x8(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x11cb5
ucomisd %xmm1,... | /LLNL[P]sundials/src/cvodes/cvodes.c |
CVodeInit | int CVodeInit(void* cvode_mem, CVRhsFn f, sunrealtype t0, N_Vector y0)
{
CVodeMem cv_mem;
sunbooleantype nvectorOK, allocOK;
sunindextype lrw1, liw1;
int i, k, retval;
SUNNonlinearSolver NLS;
/* Check cvode_mem */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FIL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x122a4
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x122eb
movq %rsi, %r15
testq %rsi, %rsi
je 0x1230f
movq 0x8(%r14), %rax
cmpq $0x0, 0x8(%rax)
je 0x122c7
cmpq $0x0, 0x18(%rax)
je 0x122c7
cmpq $0x0, 0x58(%ra... | /LLNL[P]sundials/src/cvodes/cvodes.c |
cvFreeVectors | static void cvFreeVectors(CVodeMem cv_mem)
{
int j, maxord;
maxord = cv_mem->cv_qmax_alloc;
N_VDestroy(cv_mem->cv_ewt);
N_VDestroy(cv_mem->cv_acor);
N_VDestroy(cv_mem->cv_tempv);
N_VDestroy(cv_mem->cv_ftemp);
N_VDestroy(cv_mem->cv_vtemp1);
N_VDestroy(cv_mem->cv_vtemp2);
N_VDestroy(cv_mem->cv_vtemp3)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x830(%rdi), %r14
movq 0x1b8(%rdi), %rdi
callq 0xc7c0
movq 0x1c8(%rbx), %rdi
callq 0xc7c0
movq 0x1d0(%rbx), %rdi
callq 0xc7c0
movq 0x1d8(%rbx), %rdi
callq 0xc7c0
movq 0x1e0(%rbx), %rdi
callq 0xc7c0
movq 0x1e8(%rbx), %rdi
callq 0xc7c0
movq 0x1f0(%rbx), %rdi
callq 0... | /LLNL[P]sundials/src/cvodes/cvodes.c |
CVodeReInit | int CVodeReInit(void* cvode_mem, sunrealtype t0, N_Vector y0)
{
CVodeMem cv_mem;
int i, k;
/* Check cvode_mem */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem)cvode_mem;
SUNDIALS_MARK_FUNCTION... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x129df
movq %rdi, %r14
cmpl $0x0, 0x848(%rdi)
je 0x12a02
testq %rsi, %rsi
je 0x12a26
movsd %xmm0, 0x408(%r14)
movl $0x1, 0x3c0(%r14)
movabsq $0x200000002, %rax # imm = 0x200000002
movq %rax, 0x3cc(%r14)
movsd 0x5e0(%r14), %xmm0
movsd %xmm0, 0x5c8(%r14)
andq $0x... | /LLNL[P]sundials/src/cvodes/cvodes.c |
CVodeSStolerances | int CVodeSStolerances(void* cvode_mem, sunrealtype reltol, sunrealtype abstol)
{
CVodeMem cv_mem;
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem)cvode_mem;
if (cv_mem->cv_MallocDone == SUNFALSE)
{... | pushq %rbx
testq %rdi, %rdi
je 0x12a93
cmpl $0x0, 0x848(%rdi)
je 0x12ab6
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x12ad7
leaq 0x23066(%rip), %rcx # 0x35adf
leaq 0x22ee0(%rip), %r8 # 0x35960
leaq 0x2306a(%rip), %r9 # 0x35af1
pushq $-0x16
popq %rbx
movl %ebx, %esi
movl $0x401, %edx # imm = 0x... | /LLNL[P]sundials/src/cvodes/cvodes.c |
cvEwtSet | int cvEwtSet(N_Vector ycur, N_Vector weight, void* data)
{
CVodeMem cv_mem;
int flag = 0;
/* data points to cv_mem here */
cv_mem = (CVodeMem)data;
switch (cv_mem->cv_itol)
{
case CV_SS: flag = cvEwtSetSS(cv_mem, ycur, weight); break;
case CV_SV: flag = cvEwtSetSV(cv_mem, ycur, weight); break;
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl 0x24(%rdx), %eax
xorl %ebx, %ebx
cmpl $0x2, %eax
je 0x12ba4
cmpl $0x1, %eax
jne 0x12c03
leaq 0x1d0(%r15), %r12
movq 0x1d0(%r15), %rsi
callq 0xc130
movsd 0x28(%r15), %xmm0
movq 0x1d0(%r15), %rdi
movq %rdi, %rsi
callq 0xc140
movq ... | /LLNL[P]sundials/src/cvodes/cvodes.c |
CVodeQuadInit | int CVodeQuadInit(void* cvode_mem, CVQuadRhsFn fQ, N_Vector yQ0)
{
CVodeMem cv_mem;
sunbooleantype allocOK;
sunindextype lrw1Q, liw1Q;
/* Check cvode_mem */
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x12f2b
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %rdx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xc980
movq (%r12), %rax
movq %rax, 0x708(%rbx)
movq (%r13), %ra... | /LLNL[P]sundials/src/cvodes/cvodes.c |
cvSensAllocVectors | static sunbooleantype cvSensAllocVectors(CVodeMem cv_mem, N_Vector tmpl)
{
int i, j;
/* Allocate yS */
cv_mem->cv_yS = N_VCloneVectorArray(cv_mem->cv_Ns, tmpl);
if (cv_mem->cv_yS == NULL) { return (SUNFALSE); }
/* Allocate ewtS */
cv_mem->cv_ewtS = N_VCloneVectorArray(cv_mem->cv_Ns, tmpl);
if (cv_mem->c... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl 0x90(%rdi), %edi
callq 0xcaf0
movq %rax, 0x2f8(%rbx)
xorl %r14d, %r14d
testq %rax, %rax
je 0x1393f
movl 0x90(%rbx), %edi
movq %r15, %rsi
callq 0xcaf0
movq %rax, 0x2f0(%rbx)
testq %rax, %rax
je 0x138a3
movl 0x90(%rbx), %edi
movq ... | /LLNL[P]sundials/src/cvodes/cvodes.c |
cvSensFreeVectors | static void cvSensFreeVectors(CVodeMem cv_mem)
{
int j, maxord;
maxord = cv_mem->cv_qmax_allocS;
N_VDestroyVectorArray(cv_mem->cv_yS, cv_mem->cv_Ns);
N_VDestroyVectorArray(cv_mem->cv_ewtS, cv_mem->cv_Ns);
N_VDestroyVectorArray(cv_mem->cv_acorS, cv_mem->cv_Ns);
N_VDestroyVectorArray(cv_mem->cv_tempvS, cv_m... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x838(%rdi), %r14
movq 0x2f8(%rdi), %rdi
movl 0x90(%rbx), %esi
callq 0xcb90
movq 0x2f0(%rbx), %rdi
movl 0x90(%rbx), %esi
callq 0xcb90
movq 0x300(%rbx), %rdi
movl 0x90(%rbx), %esi
callq 0xcb90
movq 0x308(%rbx), %rdi
movl 0x90(%rbx), %esi
callq 0xcb90
movq 0x310(%rb... | /LLNL[P]sundials/src/cvodes/cvodes.c |
cvHandleFailure | static int cvHandleFailure(CVodeMem cv_mem, int flag)
{
/* Set vector of absolute weighted local errors */
/*
N_VProd(acor, ewt, tempv);
N_VAbs(tempv, tempv);
*/
/* Depending on flag, print error message and return error flag */
switch (flag)
{
case CV_ERR_FAILURE:
cvProcessError(cv_mem, CV_ERR_... | pushq %rbx
leal 0x3a(%rsi), %eax
cmpl $0x37, %eax
ja 0x1b0b4
leaq 0x1a7d9(%rip), %rcx # 0x35858
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x408(%rdi), %xmm0
leaq 0x1ba5f(%rip), %rcx # 0x36af6
leaq 0x1a8c2(%rip), %r8 # 0x35960
leaq 0x1bfea(%rip), %r9 # 0x3708f
pushq $-0x3a
popq %rbx
m... | /LLNL[P]sundials/src/cvodes/cvodes.c |
CVodeGetSens1 | int CVodeGetSens1(void* cvode_mem, sunrealtype* tret, int is, N_Vector ySout)
{
CVodeMem cv_mem;
int flag;
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem)cvode_mem;
SUNDIALS_MARK_FUNCTION_BEGIN(CV... | testq %rdi, %rdi
je 0x1c957
movsd 0x410(%rdi), %xmm0
movsd %xmm0, (%rsi)
xorl %esi, %esi
jmp 0xc0a0
pushq %rbx
leaq 0x19d8f(%rip), %rcx # 0x366ee
leaq 0x18ffa(%rip), %r8 # 0x35960
leaq 0x18766(%rip), %r9 # 0x350d3
pushq $-0x15
popq %rbx
xorl %edi, %edi
movl %ebx, %esi
movl $0xfc8, %edx # imm = ... | /LLNL[P]sundials/src/cvodes/cvodes.c |
CVodeGetTolScaleFactor | int CVodeGetTolScaleFactor(void* cvode_mem, sunrealtype* tolsfact)
{
CVodeMem cv_mem;
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem)cvode_mem;
*tolsfact = cv_mem->cv_tolsf;
return (CV_SUCCESS);... | pushq %rbx
testq %rdi, %rdi
je 0x224f2
movsd 0x828(%rdi), %xmm0
movsd %xmm0, (%rsi)
xorl %ebx, %ebx
jmp 0x2251a
leaq 0x159fd(%rip), %rcx # 0x37ef6
leaq 0x152f0(%rip), %r8 # 0x377f0
leaq 0x12bcc(%rip), %r9 # 0x350d3
pushq $-0x15
popq %rbx
xorl %edi, %edi
movl %ebx, %esi
movl $0x651, %edx # imm =... | /LLNL[P]sundials/src/cvodes/cvodes_io.c |
CVodeGetErrWeights | int CVodeGetErrWeights(void* cvode_mem, N_Vector eweight)
{
CVodeMem cv_mem;
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem)cvode_mem;
N_VScale(ONE, cv_mem->cv_ewt, eweight);
return (CV_SUCCESS)... | pushq %rbx
testq %rdi, %rdi
je 0x2253c
movq 0x1b8(%rdi), %rdi
movsd 0x12b1d(%rip), %xmm0 # 0x35050
callq 0xc140
xorl %ebx, %ebx
jmp 0x22564
leaq 0x159ca(%rip), %rcx # 0x37f0d
leaq 0x152a6(%rip), %r8 # 0x377f0
leaq 0x12b82(%rip), %r9 # 0x350d3
pushq $-0x15
popq %rbx
xorl %edi, %edi
movl %ebx, %esi
movl ... | /LLNL[P]sundials/src/cvodes/cvodes_io.c |
CVodeSetJacFnB | int CVodeSetJacFnB(void* cvode_mem, int which, CVLsJacFnB jacB)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
CVLsMemB cvlsB_mem;
void* cvodeB_mem;
int retval;
/* access relevant memory structures */
retval = cvLs_AccessLMemB(cvode_mem, which, __func__, &cv_mem, &ca_mem,
... | pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x129af(%rip), %rdx # 0x3902a
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x18(%rsp), %r9
callq 0xc770
testl %eax, %eax
je 0x26699
addq $0x30, %rsp
popq %rbx
retq
movq 0x10(%rsp), %rax
movq %rbx, (%rax)
movq 0x18(%rsp), %ra... | /LLNL[P]sundials/src/cvodes/cvodes_ls.c |
cvLsJacBSWrapper | static int cvLsJacBSWrapper(sunrealtype t, N_Vector yB, N_Vector fyB,
SUNMatrix JB, void* cvode_mem, N_Vector tmp1B,
N_Vector tmp2B, N_Vector tmp3B)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
CVLsMemB cvlsB_mem;
int retval;
/* access relev... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %rbp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movsd %xmm0, 0x8(%rsp)
leaq 0x128a4(%rip), %rsi # 0x391ad
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rax
leaq 0x20(%rsp), %r8
leaq 0x18(%rsp), %r9
movq %rcx, ... | /LLNL[P]sundials/src/cvodes/cvodes_ls.c |
cvLsPrecSetupBWrapper | static int cvLsPrecSetupBWrapper(sunrealtype t, N_Vector yB, N_Vector fyB,
sunbooleantype jokB, sunbooleantype* jcurPtrB,
sunrealtype gammaB, void* cvode_mem)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
CVLsMemB cvlsB_mem;
int retval... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rax
movsd %xmm1, 0x10(%rsp)
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm0, 0x8(%rsp)
leaq 0x12642(%rip), %rsi # 0x391be
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x... | /LLNL[P]sundials/src/cvodes/cvodes_ls.c |
CVodeSetPreconditionerBS | int CVodeSetPreconditionerBS(void* cvode_mem, int which,
CVLsPrecSetupFnBS psetupBS,
CVLsPrecSolveFnBS psolveBS)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void* cvodeB_mem;
CVLsMemB cvlsB_mem;
CVLsPrecSetupFn cvls_psetup;
CVLsPrecSolve... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x12346(%rip), %rdx # 0x390a6
leaq 0x20(%rsp), %rcx
leaq 0x18(%rsp), %r8
leaq 0x10(%rsp), %r9
callq 0xc770
testl %eax, %eax
je 0x26d80
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rsp), %rax
mov... | /LLNL[P]sundials/src/cvodes/cvodes_ls.c |
cvNlsLSetup | static int cvNlsLSetup(sunbooleantype jbad, sunbooleantype* jcur, void* cvode_mem)
{
CVodeMem cv_mem;
int retval;
if (cvode_mem == NULL)
{
cvProcessError(NULL, CV_MEM_NULL, __LINE__, __func__, __FILE__, MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem)cvode_mem;
/* if the nonlinear solv... | pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0x27f3f
movq %rdx, %rbx
movq %rsi, %r14
testl %edi, %edi
je 0x27f6c
movl $0x1, 0x780(%rbx)
pushq $0x1
popq %rsi
jmp 0x27f72
leaq 0x11570(%rip), %rcx # 0x394b6
leaq 0x1137b(%rip), %r8 # 0x392c8
leaq 0xd17f(%rip), %r9 # 0x350d3
pushq $-0x15
popq %r... | /LLNL[P]sundials/src/cvodes/cvodes_nls.c |
N_VDestroy_Serial | void N_VDestroy_Serial(N_Vector v)
{
if (v == NULL) { return; }
/* free content */
if (v->content != NULL)
{
/* free data array if it's owned by the vector */
if (NV_OWN_DATA_S(v) && NV_DATA_S(v) != NULL)
{
free(NV_DATA_S(v));
NV_DATA_S(v) = NULL;
}
free(v->content);
v->cont... | testq %rdi, %rdi
je 0x2b5af
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2b59d
cmpl $0x0, 0x8(%rdi)
je 0x2b594
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2b594
movq %rax, %rdi
callq 0xc070
movq (%rbx), %rdi
andq $0x0, 0x10(%rdi)
callq 0xc070
andq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
callq 0xc070
mov... | /LLNL[P]sundials/src/nvector/serial/nvector_serial.c |
SUNLinSolFree_Band | SUNErrCode SUNLinSolFree_Band(SUNLinearSolver S)
{
/* return if S is already free */
if (S == NULL) { return SUN_SUCCESS; }
/* delete items from contents, then delete generic structure */
if (S->content)
{
if (PIVOTS(S))
{
free(PIVOTS(S));
PIVOTS(S) = NULL;
}
free(S->content);
... | testq %rdi, %rdi
je 0x2f321
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2f30f
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2f306
movq %rax, %rdi
callq 0xc070
movq (%rbx), %rdi
andq $0x0, 0x8(%rdi)
callq 0xc070
andq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
callq 0xc070
movq %rbx, %rdi
callq 0xc070
popq %rb... | /LLNL[P]sundials/src/sunlinsol/band/sunlinsol_band.c |
SUNLinSolSolve_SPFGMR | int SUNLinSolSolve_SPFGMR(SUNLinearSolver S, SUNDIALS_MAYBE_UNUSED SUNMatrix A,
N_Vector x, N_Vector b, sunrealtype delta)
{
SUNFunctionBegin(S->sunctx);
/* local data and shortcut variables */
N_Vector *V, *Z, xcor, vtemp, s1, s2;
sunrealtype **Hes, *givens, *yg, *res_norm;
sunreal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movsd %xmm0, 0x78(%rsp)
movq %rcx, %r8
movq %rdi, %r15
movq (%rdi), %rbp
movslq (%rbp), %r14
movl 0x8(%rbp), %eax
movl %eax, 0x8c(%rsp)
movl 0xc(%rbp), %eax
movl %eax, 0x38(%rsp)
movq 0x60(%rbp), %rax
movq %rax,... | /LLNL[P]sundials/src/sunlinsol/spfgmr/sunlinsol_spfgmr.c |
SUNLinSol_SPGMR | SUNLinearSolver SUNLinSol_SPGMR(N_Vector y, int pretype, int maxl,
SUNContext sunctx)
{
SUNFunctionBegin(sunctx);
SUNLinearSolver S;
SUNLinearSolverContent_SPGMR content;
/* check for legal pretype and maxl values; if illegal use defaults */
if ((pretype != SUN_PREC_NONE) && (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl $0x4, %esi
cmovbl %esi, %ebp
testl %edx, %edx
pushq $0x5
popq %r12
cmovgl %edx, %r12d
movq %rcx, %rdi
callq 0xc660
movq %rax, %r14
movq 0x8(%rax), %rax
movq 0x13f11(%rip), %rcx # 0x44c98
movq %rcx, (%rax)
movq 0x14067(%rip),... | /LLNL[P]sundials/src/sunlinsol/spgmr/sunlinsol_spgmr.c |
SUNLinSolInitialize_SPGMR | SUNErrCode SUNLinSolInitialize_SPGMR(SUNLinearSolver S)
{
int k;
SUNLinearSolverContent_SPGMR content;
SUNFunctionBegin(S->sunctx);
/* set shortcut to SPGMR memory structure */
content = SPGMR_CONTENT(S);
/* ensure valid options */
if (content->max_restarts < 0)
{
content->max_restarts = SUNSPGMR_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
cmpl $0x0, 0xc(%r14)
jns 0x30ef1
andl $0x0, 0xc(%r14)
movl 0x4(%r14), %eax
decl %eax
cmpl $0x3, %eax
jb 0x30f01
andl $0x0, 0x4(%r14)
cmpq $0x0, 0x60(%r14)
jne 0x30f1d
movl (%r14), %edi
incl %edi
movq 0x88(%r14), %rsi
callq 0xcaf0
movq %rax, 0x60(%... | /LLNL[P]sundials/src/sunlinsol/spgmr/sunlinsol_spgmr.c |
SUNLinSolSetup_SPGMR | int SUNLinSolSetup_SPGMR(SUNLinearSolver S, SUNDIALS_MAYBE_UNUSED SUNMatrix A)
{
SUNFunctionBegin(S->sunctx);
int status = SUN_SUCCESS;
/* Set shortcuts to SPGMR memory structures */
SUNPSetupFn Psetup = SPGMR_CONTENT(S)->Psetup;
void* PData = SPGMR_CONTENT(S)->PData;
/* no solver-specific setup i... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rcx
movq 0x38(%rcx), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x31025
movq %rdi, %r14
movq 0x48(%rcx), %rdi
callq *%rax
movq (%r14), %rcx
testl %eax, %eax
je 0x31025
movl $0xfffffcda, %eax # imm = 0xFFFFFCDA
movl $0x324, %ebx # imm = 0x324
cmovsl %eax, %eb... | /LLNL[P]sundials/src/sunlinsol/spgmr/sunlinsol_spgmr.c |
SUNLinSol_SPGMRSetGSType | SUNErrCode SUNLinSol_SPGMRSetGSType(SUNLinearSolver S, int gstype)
{
SUNFunctionBegin(S->sunctx);
/* Check for legal gstype */
SUNAssert(gstype == SUN_MODIFIED_GS || gstype == SUN_CLASSICAL_GS,
SUN_ERR_ARG_OUTOFRANGE);
/* Set pretype */
SPGMR_CONTENT(S)->gstype = gstype;
return SUN_SUCCESS;
} | movq (%rdi), %rax
movl %esi, 0x8(%rax)
xorl %eax, %eax
retq
| /LLNL[P]sundials/src/sunlinsol/spgmr/sunlinsol_spgmr.c |
SUNLinSol_SPTFQMR | SUNLinearSolver SUNLinSol_SPTFQMR(N_Vector y, int pretype, int maxl,
SUNContext sunctx)
{
SUNFunctionBegin(sunctx);
SUNLinearSolver S;
SUNLinearSolverContent_SPTFQMR content;
/* check for legal pretype and maxl values; if illegal use defaults */
if ((pretype != SUN_PREC_NONE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
cmpl $0x4, %esi
cmovael %eax, %ebp
testl %edx, %edx
pushq $0x5
popq %r12
cmovgl %edx, %r12d
movq %rcx, %rdi
callq 0xc660
movq %rax, %r14
movq 0x8(%rax), %rax
movq 0x133e7(%rip), %rcx # 0x44f28
movq %rcx, (%rax)
mo... | /LLNL[P]sundials/src/sunlinsol/sptfqmr/sunlinsol_sptfqmr.c |
SUNNonlinSolSolve_FixedPoint | int SUNNonlinSolSolve_FixedPoint(SUNNonlinearSolver NLS,
SUNDIALS_MAYBE_UNUSED N_Vector y0,
N_Vector ycor, N_Vector w, sunrealtype tol,
SUNDIALS_MAYBE_UNUSED sunbooleantype callSetup,
void... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, 0xb8(%rsp)
movsd %xmm0, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %rdi, %r13
movq (%rdi), %rcx
movq 0x68(%rcx), %rbx
movq 0x70(%rcx), %r15
movq 0x88(%rcx), %rax
movq %rax, 0xa0(%rsp)
andl $0x0, 0x90(%rcx)
movq %rdx, %r12
xorps %xmm... | /LLNL[P]sundials/src/sunnonlinsol/fixedpoint/sunnonlinsol_fixedpoint.c |
unhexify | int unhexify( unsigned char *output, const char *input, size_t *olen )
{
unsigned char c;
size_t j;
*olen = strlen( input );
if( *olen % 2 != 0 || *olen / 2 > MBEDTLS_PSK_MAX_LEN )
return( -1 );
*olen /= 2;
for( j = 0; j < *olen * 2; j += 2 )
{
c = input[j];
HEX2NUM... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x100e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x10af8
movq -0x20(%rbp), %rax
movq ... | /Dragonchang[P]https_client/mbedtls/programs/ssl/ssl_server2.c |
mbedtls_debug_print_buf | void mbedtls_debug_print_buf( const mbedtls_ssl_context *ssl, int level,
const char *file, int line, const char *text,
const unsigned char *buf, size_t len )
{
char str[DEBUG_BUF_SIZE];
char txt[17];
size_t i, idx = 0;
if( ssl->conf == NULL || ssl->conf->f_db... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x260(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x145c3
movq -0x8(%rbp), %r... | /Dragonchang[P]https_client/mbedtls/library/debug.c |
mbedtls_ssl_ciphersuite_uses_ec | int mbedtls_ssl_ciphersuite_uses_ec( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x3, %eax
subl $0x2, %eax
jb 0x163d9
jmp 0x163cc
movl -0x14(%rbp), %eax
addl $-0x8, %eax
subl $0x2, %eax
ja 0x163e2
jmp 0x163d9
movl $0x1, -0x4(%rbp)
jmp 0x163e9
movl $0x0, -0x4(%rbp)
movl -0x4(%... | /Dragonchang[P]https_client/mbedtls/library/ssl_ciphersuites.c |
ssl_write_certificate_request | static int ssl_write_certificate_request( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
size_t dn_size, total_dn_size; /* excluding length bytes */
size_t ct_len, sa_len; /* incl... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl $0xffff8f80, -0x14(%rbp) # imm = 0xFFFF8F80
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
addq $0x4000, %rax # imm = 0x4000
movq %rax, -0x58(%rbp)
movq ... | /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
ssl_write_encrypt_then_mac_ext | static void ssl_write_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
const mbedtls_ssl_ciphersuite_t *suite = NULL;
const mbedtls_cipher_info_t *cipher = NULL... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0x94(%rax)
je 0x1ce17
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%... | /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
mbedtls_ssl_ticket_free | void mbedtls_ssl_ticket_free( mbedtls_ssl_ticket_context *ctx )
{
mbedtls_cipher_free( &ctx->keys[0].ctx );
mbedtls_cipher_free( &ctx->keys[1].ctx );
#if defined(MBEDTLS_THREADING_C)
mbedtls_mutex_free( &ctx->mutex );
#endif
mbedtls_zeroize( ctx, sizeof( mbedtls_ssl_ticket_context ) );
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x40520
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
callq 0x40520
movq -0x8(%rbp), %rdi
movl $0xd8, %esi
callq 0x1e640
addq $0x10, %rsp
popq %rbp
retq
nop
| /Dragonchang[P]https_client/mbedtls/library/ssl_ticket.c |
mbedtls_ssl_write_certificate | int mbedtls_ssl_write_certificate( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t i, n;
const mbedtls_x509_crt *crt;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate"... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0xffff8f80, -0x14(%rbp) # imm = 0xFFFF8F80
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x56b23(%rip), %rdx # 0x7b788
movl $0x100b, %ecx # imm = 0x1... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_check_curve | int mbedtls_ssl_check_curve( const mbedtls_ssl_context *ssl, mbedtls_ecp_group_id grp_id )
{
const mbedtls_ecp_group_id *gid;
if( ssl->conf->curve_list == NULL )
return( -1 );
for( gid = ssl->conf->curve_list; *gid != MBEDTLS_ECP_DP_NONE; gid++ )
if( *gid == grp_id )
return( 0 ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0xf0(%rax)
jne 0x25a65
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25aab
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmp... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_check_cert_usage | int mbedtls_ssl_check_cert_usage( const mbedtls_x509_crt *cert,
const mbedtls_ssl_ciphersuite_t *ciphersuite,
int cert_endpoint,
uint32_t *flags )
{
int ret = 0;
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
int usage = 0;
#endif
#if defi... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x25b44
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x40(%rbp)
subq $0xb, %rax
ja 0x25b42
movq -0x4... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_write_change_cipher_spec | int mbedtls_ssl_write_change_cipher_spec( mbedtls_ssl_context *ssl )
{
int ret;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write change cipher spec" ) );
ssl->out_msgtype = MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC;
ssl->out_msglen = 1;
ssl->out_msg[0] = 1;
ssl->state++;
if( ( ret = mbedtls_ssl_write_re... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x55b8c(%rip), %rdx # 0x7b788
movl $0x119a, %ecx # imm = 0x119A
leaq 0x564ee(%rip), %r8 # 0x7c0f6
movb $0x0, %al
callq 0x14340
movq -0x10(%rbp), %rax
movl $0x14, 0x150(%rax)
movq -0x10(%rbp)... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_append_key_cert | static int ssl_append_key_cert( mbedtls_ssl_key_cert **head,
mbedtls_x509_crt *cert,
mbedtls_pk_context *key )
{
mbedtls_ssl_key_cert *new;
new = mbedtls_calloc( 1, sizeof( mbedtls_ssl_key_cert ) );
if( new == NULL )
return( MBEDTLS_ER... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x101c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x277f7
movl $0xffff8100, -0x4(%rbp) # imm = 0xFFFF8100
jmp 0x27868
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_get_max_frag_len | size_t mbedtls_ssl_get_max_frag_len( const mbedtls_ssl_context *ssl )
{
size_t max_len;
/*
* Assume mfl_code is correct since it was checked when set
*/
max_len = mfl_code_to_length[ssl->conf->mfl_code];
/*
* Check if a smaller max length was negotiated
*/
if( ssl->session_out ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x174(%rax), %eax
shrl $0x7, %eax
andl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x73bda(%rip), %rax # 0x9c200
movl (%rax,%rcx,4), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x28678
mo... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_write_split | static int ssl_write_split( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
int ret;
if( ssl->conf->cbc_record_splitting ==
MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED ||
len <= 1 ||
ssl->minor_ver > MBEDTLS_SSL_MINOR_VERSION_1 ||
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x174(%rax), %eax
shrl $0xd, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x295e6
cmpq $0x1, -0x20(%rbp)
jbe 0x295e6
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jg 0... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_md_alg_from_hash | mbedtls_md_type_t mbedtls_ssl_md_alg_from_hash( unsigned char hash )
{
switch( hash )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_SSL_HASH_MD5:
return( MBEDTLS_MD_MD5 );
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_SSL_HASH_SHA1:
return( MBEDTLS_MD_SHA1 );
#endif
#if def... | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x2a0a5
movq -0x10(%rbp), %rax
leaq 0x516de(%rip), %rcx # 0x7b744
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x4(%rbp)
jmp 0x2a0ac
movl $0... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_write_max_fragment_length_ext | static void ssl_write_max_fragment_length_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
const unsigned char *end = ssl->out_msg + MBEDTLS_SSL_MAX_CONTENT_LEN;
*olen = ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
addq $0x4000, %rax # imm = 0x4000
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8... | /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
mbedtls_ssl_safer_memcmp | static inline int mbedtls_ssl_safer_memcmp( const void *a, const void *b, size_t n )
{
size_t i;
const unsigned char *A = (const unsigned char *) a;
const unsigned char *B = (const unsigned char *) b;
unsigned char diff = 0;
for( i = 0; i < n; i++ )
diff |= A[i] ^ B[i];
return( diff );... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x31e47
movq -0x28(%rbp), %rax
movq -0... | /Dragonchang[P]https_client/mbedtls/include/mbedtls/ssl_internal.h |
x509_get_crl_ext | static int x509_get_crl_ext( unsigned char **p,
const unsigned char *end,
mbedtls_x509_buf *ext )
{
int ret;
size_t len = 0;
/* Get explicit tag */
if( ( ret = mbedtls_x509_get_ext( p, end, ext, 0) ) != 0 )
{
if( ret == MBEDTLS_ERR_A... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x39160
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x333ee
cmpl $-0x62, -0x24(%rbp)
jne 0x333e... | /Dragonchang[P]https_client/mbedtls/library/x509_crl.c |
mbedtls_x509_crl_info | int mbedtls_x509_crl_info( char *buf, size_t size, const char *prefix,
const mbedtls_x509_crl *crl )
{
int ret;
size_t n;
char *p;
const mbedtls_x509_crl_entry *entry;
p = buf;
n = size;
ret = mbedtls_snprintf( p, n, "%sCRL version : %d",
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x30(%... | /Dragonchang[P]https_client/mbedtls/library/x509_crl.c |
mbedtls_x509_crt_info | int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
const mbedtls_x509_crt *crt )
{
int ret;
size_t n;
char *p;
char key_size_str[BEFORE_COLON];
p = buf;
n = size;
if( NULL == crt )
{
ret = mbedtls_snprintf( p, n, "\nCertificate is uninitia... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jne 0x34984
movq -0x48(%rbp), %rdi
movq -0... | /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
x509_info_cert_type | static int x509_info_cert_type( char **buf, size_t *size,
unsigned char ns_cert_type )
{
int ret;
size_t n = *size;
char *p = *buf;
const char *sep = "";
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x52e30(%rip), %rax # 0x88222
movq %rax, -0x38(%rbp)
movz... | /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
x509_check_wildcard | static int x509_check_wildcard( const char *cn, mbedtls_x509_buf *name )
{
size_t i;
size_t cn_idx = 0, cn_len = strlen( cn );
if( name->len < 3 || name->p[0] != '*' || name->p[1] != '.' )
return( 0 );
for( i = 0; i < cn_len; ++i )
{
if( cn[i] == '.' )
{
cn_idx ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x100e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x3, 0x8(%rax)
jb 0x36601
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x3660... | /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
mbedtls_x509_crt_free | void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
{
mbedtls_x509_crt *cert_cur = crt;
mbedtls_x509_crt *cert_prv;
mbedtls_x509_name *name_cur;
mbedtls_x509_name *name_prv;
mbedtls_x509_sequence *seq_cur;
mbedtls_x509_sequence *seq_prv;
if( crt == NULL )
return;
do
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x371f0
jmp 0x373ae
jmp 0x371f2
movq -0x10(%rbp), %rdi
addq $0x148, %rdi # imm = 0x148
callq 0x59780
movq -0x10(%rbp), %rax
movq 0x218(%rax), %rdi
callq 0x10030
movq -0x10(... | /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
x509_get_version | static int x509_get_version( unsigned char **p,
const unsigned char *end,
int *ver )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) != 0 )
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0xa0, %ecx
callq 0x3a1e0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x37413
cmpl $-0x62, -0x24(%rbp)
jne 0x3740b
movq -0x20(%rbp), %r... | /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
x509_string_cmp | static int x509_string_cmp( const mbedtls_x509_buf *a, const mbedtls_x509_buf *b )
{
if( a->tag == b->tag &&
a->len == b->len &&
memcmp( a->p, b->p, b->len ) == 0 )
{
return( 0 );
}
if( ( a->tag == MBEDTLS_ASN1_UTF8_STRING || a->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x37ffb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x37ffb
movq -0x10(%rbp), %rax
movq 0x10(%ra... | /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
mbedtls_asn1_get_int | int mbedtls_asn1_get_int( unsigned char **p,
const unsigned char *end,
int *val )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
return( ret );
if( len == 0 || len > sizeof( int ) || ( **p & 0x80 ) != 0... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x2, %ecx
callq 0x3a1e0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x3a32a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3a3a6
c... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_get_alg_null | int mbedtls_asn1_get_alg_null( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_buf *alg )
{
int ret;
mbedtls_asn1_buf params;
memset( ¶ms, 0, sizeof(mbedtls_asn1_buf) );
if( ( ret = mbedtls_asn1_get_alg( p, end, alg, ¶ms ) ) != 0 )
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x10140
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x3a6f0
movl %eax, -0x24(%rbp)
cmpl $0x... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mpi_mul_hlp | __attribute__ ((noinline))
#endif
void mpi_mul_hlp( size_t i, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d, mbedtls_mpi_uint b )
{
mbedtls_mpi_uint c = 0, t = 0;
#if defined(MULADDC_HUIT)
for( ; i >= 8; i -= 8 )
{
MULADDC_INIT
MULADDC_HUIT
MULADDC_STOP
}
for( ; i > 0; i-- )
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x10, -0x10(%rbp)
jb 0x3d2b0
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rbx
xorq %r8, %r8
mov... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
add_zeros_and_len_padding | static void add_zeros_and_len_padding( unsigned char *output,
size_t output_len, size_t data_len )
{
size_t padding_len = output_len - data_len;
unsigned char i = 0;
for( i = 1; i < padding_len; i++ )
output[data_len + i - 1] = 0x00;
output[output_len - 1]... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movb $0x1, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae 0x4150f
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzb... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_write_tag | int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
unsigned char *tag, size_t tag_len )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_ENCRYPT != ctx->operation )
return( MBEDTLS_ERR_CIPHER_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x4179f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x4179f
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x417a8
movl $0xffff9f00, -0x4(%rbp) # imm = 0... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
arc4_ctx_alloc | static void * arc4_ctx_alloc( void )
{
mbedtls_arc4_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_arc4_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_arc4_init( ctx );
return( ctx );
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x108, %esi # imm = 0x108
callq 0x101c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4203c
movq $0x0, -0x8(%rbp)
jmp 0x4204d
movq -0x10(%rbp), %rdi
callq 0x6dee0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0... | /Dragonchang[P]https_client/mbedtls/library/cipher_wrap.c |
dhm_check_range | static int dhm_check_range( const mbedtls_mpi *param, const mbedtls_mpi *P )
{
mbedtls_mpi L, U;
int ret = MBEDTLS_ERR_DHM_BAD_INPUT_DATA;
mbedtls_mpi_init( &L ); mbedtls_mpi_init( &U );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &L, 2 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &U, P, 2 ) );
if( mbed... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffcf80, -0x44(%rbp) # imm = 0xFFFFCF80
leaq -0x28(%rbp), %rdi
callq 0x3aa30
leaq -0x40(%rbp), %rdi
callq 0x3aa30
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x3b190
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
je 0x45d31
jmp 0... | /Dragonchang[P]https_client/mbedtls/library/dhm.c |
mbedtls_ecp_curve_info_from_tls_id | const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_tls_id( uint16_t tls_id )
{
const mbedtls_ecp_curve_info *curve_info;
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
if( curve_info->tls_id == tls_id )
re... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0xa(%rbp)
callq 0x473f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4753b
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4752b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x475... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_ecp_check_pub_priv | int mbedtls_ecp_check_pub_priv( const mbedtls_ecp_keypair *pub, const mbedtls_ecp_keypair *prv )
{
int ret;
mbedtls_ecp_point Q;
mbedtls_ecp_group grp;
if( pub->grp.id == MBEDTLS_ECP_DP_NONE ||
pub->grp.id != prv->grp.id ||
mbedtls_mpi_cmp_mpi( &pub->Q.X, &prv->Q.X ) ||
mbedtls_... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49daa
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x49daa
movq -0x10(%rbp), %rdi
addq $0x110, %rdi # imm ... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
ecp_comb_fixed | static void ecp_comb_fixed( unsigned char x[], size_t d,
unsigned char w, const mbedtls_mpi *m )
{
size_t i, j;
unsigned char c, cc, adjust;
memset( x, 0, d+1 );
/* First get the classical comb values (except for x_d = 0) */
for( i = 0; i < d; i++ )
for( j = 0; ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
xorl %esi, %esi
callq 0x10140
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4b285
... | /Dragonchang[P]https_client/mbedtls/library/ecp.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.