name string | code string | asm string | file string |
|---|---|---|---|
TPM2_HMAC | TPM_RC TPM2_HMAC(
TSS_DEVICE *tpm, // IN/OUT
TSS_SESSION *session, // IN/OUT
TPMI_DH_OBJECT handle, // IN
TPM2B_MAX_BUFFER *buffer, // IN
TPMI_ALG_HASH hashAlg, // IN
TPM2B_DIGEST ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3048, %rsp # imm = 0x3048
movq %r9, %rbx
movq %rcx, %r15
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movw %r8w, 0xa(%rsp)
movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq %r9, %xm... | /Azure[P]azure-utpm-c/src/tpm_codec.c |
TPM2_Hash | TPM_RC
TPM2_Hash(
TSS_DEVICE *tpm, // IN/OUT
TPM2B_MAX_BUFFER *data, // IN
TPMI_ALG_HASH hashAlg, // IN
TPMI_RH_HIERARCHY hierarchy, // IN [opt]
TPM2B_DIGEST *outHash, // OUT
TPMT_TK_HASHCHECK... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3088, %rsp # imm = 0x3088
movq %r9, %rbx
movq %r8, %r14
movq %rdi, %r15
movw %dx, 0xe(%rsp)
movl %ecx, 0x18(%rsp)
movl $0x1000, 0x8(%rsp) # imm = 0x1000
leaq 0x6c(%rsp), %rax
movq %rax, 0x10(%rsp)
andl $0x0, -0x4(%rax)
testq %rsi, ... | /Azure[P]azure-utpm-c/src/tpm_codec.c |
TPM2_Create | TPM_RC
TPM2_Create(
TSS_DEVICE *tpm, // IN/OUT
TSS_SESSION *session, // IN/OUT
TPMI_DH_OBJECT parentHandle, // IN
TPM2B_SENSITIVE_CREATE *inSensitive, // IN
TPM2B_PUBLIC *inPublic, // IN
TPM2B_DATA ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3188, %rsp # imm = 0x3188
movq %r9, %r13
movq %r8, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
leaq 0xc(%rsp), %rax
movl %edx, (%rax)
leaq 0x1c(%rsp), %rbp
movl $0x1000, (%rbp) # imm = 0x1000
leaq 0x16c(%rsp), %... | /Azure[P]azure-utpm-c/src/tpm_codec.c |
TPM2_EncryptDecrypt | TPM_RC
TPM2_EncryptDecrypt(
TSS_DEVICE *tpm, // IN/OUT
TSS_SESSION *session, // IN/OUT
TPMI_DH_OBJECT keyHandle, // IN
TPMI_YES_NO decrypt, // IN
TPM_ALG_ID cipherMode, // IN
TPM2B_IV ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3068, %rsp # imm = 0x3068
movq %r9, %r15
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movl %edx, 0x20(%rsp)
leaq 0x17(%rsp), %rdi
movb %cl, (%rdi)
leaq 0x26(%rsp), %r12
movw %r8w, (%r12)
leaq 0x10(%rsp), %r13
movl $0x1000, (%r13) # imm... | /Azure[P]azure-utpm-c/src/tpm_codec.c |
tpm_socket_create | TPM_SOCKET_HANDLE tpm_socket_create(const char* address, unsigned short port)
{
TPM_SOCKET_INFO* result;
if ((result = malloc(sizeof(TPM_SOCKET_INFO))) == NULL)
{
LogError("Failure: malloc socket communication info.");
}
else
{
#ifdef WIN32
WSADATA wsaData;
WSAStartup(MAK... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r15d
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x3300
testq %rax, %rax
je 0xc1cb
movq %rax, %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3110
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0xc201
... | /Azure[P]azure-utpm-c/src/tpm_socket_comm.c |
strtof_s | float strtof_s(const char* nptr, char** endptr)
{
int signal = 1;
double fraction;
int exponential;
char* runner = (char*)nptr;
double val;
/*Codes_SRS_CRT_ABSTRACTIONS_21_021: [If no conversion could be performed, the strtof_s returns the value 0.0.]*/
float result = 0.0;
/*Codes_SRS_... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl $0x1, 0x4(%rsp)
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
testq %rdi, %rdi
je 0xcaf1
movq %rdi, %r14
leaq 0x10(%rsp), %rsi
leaq 0x4(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x1c(%rsp), %r8
callq 0xcb06
decl %eax
cmpl $0x3, %eax
ja 0xcae3
leaq 0xfedf(%rip), %rcx ... | /Azure[P]azure-utpm-c/deps/c-utility/src/crt_abstractions.c |
splitFloatString | static FLOAT_STRING_TYPE splitFloatString(const char* nptr, char** endptr, int *signal, double *fraction, int *exponential)
{
FLOAT_STRING_TYPE result = FST_ERROR;
unsigned long long ullInteger = 0;
unsigned long long ullFraction = 0;
int integerSize = 0;
int fractionSize = 0;
char* startptr;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
movabsq $0x100003e00, %rax # imm = 0x100003E00
movq %r15, (%r12)
movzbl (%r15), %ecx
cmpq $0x20, %rcx
ja 0xcb43
btq %rcx, %rax
jae 0xcb43
incq %r15
jmp 0xcb2a
movl $0x1,... | /Azure[P]azure-utpm-c/deps/c-utility/src/crt_abstractions.c |
strtold_s | long double strtold_s(const char* nptr, char** endptr)
{
int signal = 1;
double fraction;
int exponential;
char* runner = (char*)nptr;
/*Codes_SRS_CRT_ABSTRACTIONS_21_031: [If no conversion could be performed, the strtold_s returns the value 0.0.]*/
long double result = 0.0;
/*Codes_SRS_CR... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl $0x1, 0xc(%rsp)
movq %rdi, 0x20(%rsp)
fldz
testq %rdi, %rdi
je 0xceeb
movq %rdi, %r14
fstp %st(0)
leaq 0x20(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x34(%rsp), %r8
callq 0xcb06
flds 0xfaa6(%rip) # 0x1c8a0
decl %eax
cmpl $0x3, %ea... | /Azure[P]azure-utpm-c/deps/c-utility/src/crt_abstractions.c |
mallocAndStrcpy_s | int mallocAndStrcpy_s(char** destination, const char* source)
{
int result;
int copied_result;
/*Codes_SRS_CRT_ABSTRACTIONS_99_036: [destination parameter or source parameter is NULL, the error code returned shall be EINVAL and destination shall not be modified.]*/
if ((destination == NULL) || (source =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xcf1d
pushq $0x16
popq %rbp
jmp 0xcf75
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3200
movq %rax, %r15
incq %r15
pushq $-0x1
popq %rdi
cmovneq %r15, %rdi
pushq $0xc
popq %rbp
cmpq $-0... | /Azure[P]azure-utpm-c/deps/c-utility/src/crt_abstractions.c |
size_tToString | int size_tToString(char* destination, size_t destinationSize, size_t value)
{
int result;
size_t pos;
/*the below loop gets the number in reverse order*/
/*Codes_SRS_CRT_ABSTRACTIONS_02_003: [If destination is NULL then unsignedIntToString shall fail.] */
/*Codes_SRS_CRT_ABSTRACTIONS_02_002: [If the... | testq %rdi, %rdi
sete %al
cmpq $0x2, %rsi
setb %cl
orb %al, %cl
movl $0x32e, %eax # imm = 0x32E
jne 0xd08c
decq %rsi
pushq $0x1
popq %r9
pushq $0xa
popq %r10
movq %rdx, %rcx
movq %rdx, %rax
xorl %edx, %edx
divq %r10
orb $0x30, %dl
movb %dl, -0x1(%rdi,%r9)
leaq 0x1(%r9), %r8
cmpq $0xa, %rcx
jb 0xd04d
movq %ra... | /Azure[P]azure-utpm-c/deps/c-utility/src/crt_abstractions.c |
substricmp | static int substricmp(const char* nptr, const char* subsrt)
{
int result = 0;
while (((*subsrt) != '\0') && (result == 0))
{
result = TOUPPER(*nptr) - TOUPPER(*subsrt);
nptr++;
subsrt++;
}
return result;
} | xorl %ecx, %ecx
xorl %eax, %eax
movzbl (%rsi,%rcx), %edx
testl %edx, %edx
je 0xd155
testl %eax, %eax
jne 0xd155
movsbl (%rdi,%rcx), %r8d
leal -0x61(%r8), %r9d
leal -0x20(%r8), %eax
cmpb $0x1a, %r9b
cmovael %r8d, %eax
movsbl %dl, %r8d
leal -0x61(%rdx), %r9d
addl $-0x20, %edx
cmpb $0x1a, %r9b
cmovael %r8d, %edx
subl %edx... | /Azure[P]azure-utpm-c/deps/c-utility/src/crt_abstractions.c |
LogBinary | void LogBinary(const char* comment, const void* data, size_t size)
{
char charBuf[LINE_SIZE + 1];
char hexBuf[LINE_SIZE * 3 + 1];
size_t countbuf = 0;
size_t i = 0;
const unsigned char* bufAsChar = (const unsigned char*)data;
const unsigned char* startPos = bufAsChar;
LOG(AZ_LOG_TRACE, LOG_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbp
leaq 0x205a7(%rip), %r13 # 0x2d730
movq (%r13), %r11
testq %r11, %r11
je 0xd1bf
movq %rdi, %r10
leaq 0xf7a2(%rip), %rsi # 0x1c93e
leaq 0xf800(%rip), %rdx # 0x1c9a3
leaq 0xf803(%rip), %r9 ... | /Azure[P]azure-utpm-c/deps/c-utility/src/xlogging.c |
platform_init | int platform_init(void)
{
int result = 0;
#ifdef USE_HTTP
#ifndef DONT_USE_UPLOADTOBLOB
if (HTTPAPIEX_Init() == HTTPAPIEX_ERROR)
{
LogError("HTTP for upload to blob failed on initialization.");
result = MU_FAILURE;
}
#endif /* DONT_USE_UPLOADTOBLOB */
#endif /* USE_HTTP */
#ifdef USE_OPE... | pushq %rax
callq 0xd458
cmpl $0x2, %eax
jne 0xd350
callq 0xd163
testq %rax, %rax
je 0xd34b
movq %rax, %r10
leaq 0xf69c(%rip), %rsi # 0x1c9cb
leaq 0xf705(%rip), %rdx # 0x1ca3b
leaq 0xf70c(%rip), %r9 # 0x1ca49
pushq $0x27
popq %rcx
pushq $0x1
popq %r8
xorl %edi, %edi
xorl %eax, %eax
callq *%r10
pushq $0x2... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/platform_linux.c |
platform_get_default_tlsio | const IO_INTERFACE_DESCRIPTION* platform_get_default_tlsio(void)
{
#if USE_CYCLONESSL
return tlsio_cyclonessl_get_interface_description();
#elif USE_WOLFSSL
return tlsio_wolfssl_get_interface_description();
#elif USE_MBEDTLS
return tlsio_mbedtls_get_interface_description();
#elif USE_BEARSSL
return tlsi... | jmp 0x1271c
| /Azure[P]azure-utpm-c/deps/c-utility/adapters/platform_linux.c |
platform_get_platform_info | STRING_HANDLE platform_get_platform_info(PLATFORM_INFO_OPTION options)
{
// No applicable options, so ignoring parameter
(void)options;
// Expected format: "(<runtime name>; <operating system name>; <platform>)"
STRING_HANDLE result;
struct utsname nnn;
if (uname(&nnn) == 0)
{
res... | subq $0x188, %rsp # imm = 0x188
leaq 0x2(%rsp), %rdi
callq 0x30a0
testl %eax, %eax
je 0xd3b3
callq 0xd163
testq %rax, %rax
je 0xd3a0
movq %rax, %r10
leaq 0xf647(%rip), %rsi # 0x1c9cb
leaq 0xf701(%rip), %rdx # 0x1ca8c
leaq 0xf715(%rip), %r9 # 0x1caa7
pushq $0x5a
popq %rcx
pushq $0x1
popq %rdi
... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/platform_linux.c |
platform_deinit | void platform_deinit(void)
{
#ifdef USE_HTTP
#ifndef DONT_USE_UPLOADTOBLOB
HTTPAPIEX_Deinit();
#endif /* DONT_USE_UPLOADTOBLOB */
#endif /* USE_HTTP */
#ifdef USE_OPENSSL
tlsio_openssl_deinit();
#elif USE_WOLFSSL
tlsio_wolfssl_deinit();
#endif
} | pushq %rax
callq 0xd488
popq %rax
jmp 0x1103c
nop
| /Azure[P]azure-utpm-c/deps/c-utility/adapters/platform_linux.c |
HTTPAPIEX_Init | HTTPAPIEX_RESULT HTTPAPIEX_Init(void)
{
HTTPAPIEX_RESULT result;
/*Codes_SRS_HTTPAPIEX_21_045: [If HTTPAPIEX_Init is calling more than once, it shall initialize the HTTP by calling HTTAPI_Init only once, and return success for all calls.] */
if (useGlobalInitialization == 0)
{
/*Codes_SRS_HTTPA... | movl 0x205c2(%rip), %eax # 0x2da20
testl %eax, %eax
jne 0xd478
pushq %rax
callq 0xe7ac
cmpl $0x1, %eax
leaq 0x8(%rsp), %rsp
jne 0xd484
movl 0x205a8(%rip), %eax # 0x2da20
incl %eax
movl %eax, 0x205a0(%rip) # 0x2da20
pushq $0x1
popq %rax
retq
pushq $0x2
jmp 0xd482
| /Azure[P]azure-utpm-c/deps/c-utility/src/httpapiex.c |
HTTPAPIEX_Create | HTTPAPIEX_HANDLE HTTPAPIEX_Create(const char* hostName)
{
HTTPAPIEX_HANDLE result;
/*Codes_SRS_HTTPAPIEX_02_001: [If parameter hostName is NULL then HTTPAPIEX_Create shall return NULL.]*/
if (hostName == NULL)
{
LogError("invalid (NULL) parameter");
result = NULL;
}
else
{
... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd4e5
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x3300
testq %rax, %rax
je 0xd511
movq %rax, %rbx
movq %r14, %rdi
callq 0x15c95
movq %rax, (%rbx)
testq %rax, %rax
je 0xd539
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x16d8c
movq %rax, 0x18(%r... | /Azure[P]azure-utpm-c/deps/c-utility/src/httpapiex.c |
HTTPAPIEX_ExecuteRequest | HTTPAPIEX_RESULT HTTPAPIEX_ExecuteRequest(HTTPAPIEX_HANDLE handle, HTTPAPI_REQUEST_TYPE requestType, const char* relativePath,
HTTP_HEADERS_HANDLE requestHttpHeadersHandle, BUFFER_HANDLE requestContent, unsigned int* statusCode,
HTTP_HEADERS_HANDLE responseHttpHeadersHandle, BUFFER_HANDLE responseContent)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0xd614
movl %esi, %r12d
leal -0x1(%r12), %eax
cmpl $0x6, %eax
jae 0xd65c
movq %r9, %rbp
movq %rdx, %rbx
movq %rdi, %r13
movq %rcx, 0x10(%rsp)
leaq 0xb(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %r8, %rdi
callq 0xdf4c
test... | /Azure[P]azure-utpm-c/deps/c-utility/src/httpapiex.c |
HTTPAPIEX_SetOption | HTTPAPIEX_RESULT HTTPAPIEX_SetOption(HTTPAPIEX_HANDLE handle, const char* optionName, const void* value)
{
HTTPAPIEX_RESULT result;
/*Codes_SRS_HTTPAPIEX_02_032: [If parameter handle is NULL then HTTPAPIEX_SetOption shall return HTTPAPIEX_INVALID_ARG.] */
/*Codes_SRS_HTTPAPIEX_02_033: [If parameter optionNa... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0xdcba
callq 0xd163
pushq $0x3
popq %rbx
testq %rax, %rax
je 0xdf3c
movq %rax, %r10
leaq 0x1fab3(%rip), %r11 # 0x2d740
subq $0x8, ... | /Azure[P]azure-utpm-c/deps/c-utility/src/httpapiex.c |
buildBufferIfNotExist | static int buildBufferIfNotExist(BUFFER_HANDLE originalRequestContent, bool* isOriginalRequestContent, BUFFER_HANDLE* toBeUsedRequestContent)
{
int result;
if (originalRequestContent == NULL)
{
*toBeUsedRequestContent = BUFFER_new();
if (*toBeUsedRequestContent == NULL)
{
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
testq %rdi, %rdi
je 0xdf63
movb $0x1, (%rbx)
movq %rdi, (%r14)
jmp 0xdf73
callq 0x13af4
movq %rax, (%r14)
testq %rax, %rax
je 0xdf7d
movb $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xd9, %eax
jmp 0xdf75
| /Azure[P]azure-utpm-c/deps/c-utility/src/httpapiex.c |
HTTPHeaders_Free | void HTTPHeaders_Free(HTTP_HEADERS_HANDLE handle)
{
/*Codes_SRS_HTTP_HEADERS_02_001: [If httpHeadersHandle is NULL then HTTPHeaders_Free shall perform no action.] */
if (handle == NULL)
{
/*do nothing*/
}
else
{
/*Codes_SRS_HTTP_HEADERS_99_005:[ Calling this API shall de-allocate... | testq %rdi, %rdi
je 0xe0b7
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x14c5e
movq %rbx, %rdi
popq %rbx
jmp 0x3500
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/httpheaders.c |
HTTPHeaders_GetHeader | HTTP_HEADERS_RESULT HTTPHeaders_GetHeader(HTTP_HEADERS_HANDLE handle, size_t index, char** destination)
{
HTTP_HEADERS_RESULT result = HTTP_HEADERS_OK;
/*Codes_SRS_HTTP_HEADERS_99_028:[ The function shall return NULL if the handle is invalid.]*/
/*Codes_SRS_HTTP_HEADERS_99_032:[ The function shall return H... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
jne 0xe522
callq 0xd163
pushq $0x2
popq %rbx
testq %rax, %rax
je 0xe64a
movq %rax, %r10
leaq 0x1f286(%rip), %r11 # 0x2d770
subq $0x8, %rsp
leaq 0xf683(%rip), %r14 ... | /Azure[P]azure-utpm-c/deps/c-utility/src/httpheaders.c |
HTTPHeaders_Clone | HTTP_HEADERS_HANDLE HTTPHeaders_Clone(HTTP_HEADERS_HANDLE handle)
{
HTTP_HEADERS_HANDLE_DATA* result;
/*Codes_SRS_HTTP_HEADERS_02_003: [If handle is NULL then HTTPHeaders_Clone shall return NULL.] */
if (handle == NULL)
{
result = NULL;
}
else
{
/*Codes_SRS_HTTP_HEADERS_02_00... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe729
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x35a0
testq %rax, %rax
je 0xe729
movq %rax, %rbx
movq (%r14), %rdi
callq 0x14caf
movq %rax, (%rbx)
testq %rax, %rax
jne 0xe72b
movq %rbx, %rdi
callq 0x3500
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
po... | /Azure[P]azure-utpm-c/deps/c-utility/src/httpheaders.c |
HTTPAPI_Init | HTTPAPI_RESULT HTTPAPI_Init(void)
{
HTTPAPI_RESULT result;
if (nUsersOfHTTPAPI == 0)
{
if (curl_global_init(CURL_GLOBAL_NOTHING) != 0)
{
result = HTTPAPI_INIT_FAILED;
LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result));
}
els... | pushq %r14
pushq %rbx
pushq %rax
movq 0x1f271(%rip), %rax # 0x2da28
testq %rax, %rax
je 0xe7d3
incq %rax
movq %rax, 0x1f262(%rip) # 0x2da28
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
callq 0x3120
testl %eax, %eax
je 0xe834
callq 0xd163
pushq $0x10
popq %rbx
tes... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/httpapi_curl.c |
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 0xeb47
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3500
andq $0x0, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x3510
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xeb35
callq 0x3780
andq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rdi
callq 0x3500
movq %rbx, %rdi
popq %rbx
jmp 0x3500
retq
| /Azure[P]azure-utpm-c/deps/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, %rbx
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0xeb87
movq %r9, %r14
movq %r8, %r13
testq %r8, %r8
setne %al
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0xebea
cal... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/httpapi_curl.c |
ContentWriteFunction | static size_t ContentWriteFunction(void *ptr, size_t size, size_t nmemb, void *userdata)
{
HTTP_RESPONSE_CONTENT_BUFFER* responseContentBuffer = (HTTP_RESPONSE_CONTENT_BUFFER*)userdata;
if ((userdata != NULL) &&
(ptr != NULL) &&
(size * nmemb > 0))
{
size_t malloc_size = safe_multipl... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
testq %rcx, %rcx
sete %al
testq %rdi, %rdi
sete %cl
movq %rdx, %rbx
imulq %rsi, %rbx
orb %al, %cl
jne 0xfe42
testq %rbx, %rbx
je 0xfd71
movq %rdi, %r12
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
pushq $-0x1
popq %rcx
je 0xfd78
... | /Azure[P]azure-utpm-c/deps/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, (%rsp)
testq %rdi, %rdi
je 0xfec5
movq %rcx, %r15
leaq 0xdd04(%rip), %r12 # 0x1db76
movq %r12, %rsi
callq 0x3680
movq %rax, %r13
pushq $0x3a
popq %rbp
testq %r13, %r13
je 0xfec5
cmpb $0x0, (%r13)
je 0xfec5
movq ... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/httpapi_curl.c |
HTTPAPI_SetOption | HTTPAPI_RESULT HTTPAPI_SetOption(HTTP_HANDLE handle, const char* optionName, const void* value)
{
HTTPAPI_RESULT result;
if (
(handle == NULL) ||
(optionName == NULL) ||
(value == NULL)
)
{
result = HTTPAPI_INVALID_ARG;
LogError("invalid parameter (NULL) passe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0xff40
callq 0xd163
pushq $0x2
popq %rbx
testq %rax, %rax
je 0x10600
movq %rax, %r10
leaq 0xd350(%rip), %rsi # 0x1d26d... | /Azure[P]azure-utpm-c/deps/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 0x108b8
callq 0xd163
pushq $0x2
popq %rbx
testq %rax, %rax
je 0x10ab3
movq %rax, %r10
leaq 0xc9d8(%rip), %rsi # 0x1d26d
leaq 0xd158(%rip), %... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/httpapi_curl.c |
log_ERR_get_error | static void log_ERR_get_error(const char* message)
{
char buf[128];
AZURE_UNREFERENCED_PARAMETER(buf);
unsigned long error;
int i;
if (message != NULL)
{
LogError("%s", message);
}
error = ERR_get_error();
for (i = 0; 0 != error; i++)
{
LogError(" [%d] %s", i,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
testq %rdi, %rdi
je 0x10e61
movq %rdi, %rbx
callq 0xd163
testq %rax, %rax
je 0x10e61
movq %rax, %r10
subq $0x8, %rsp
leaq 0xce1e(%rip), %rsi # 0x1dc5e
leaq 0xd369(%rip), %rdx # 0x1e1b0
leaq 0xbb7a(%rip), %r9 # 0x1c9c8
pus... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
tlsio_openssl_deinit | void tlsio_openssl_deinit(void)
{
openssl_dynamic_locks_uninstall();
openssl_static_locks_uninstall();
#if (OPENSSL_VERSION_NUMBER >= 0x00907000L) && (FIPS_mode_set)
FIPS_mode_set(0);
#endif
CRYPTO_set_locking_callback(NULL);
CRYPTO_set_id_callback(NULL);
ERR_free_strings();
EVP_cleanup();
... | pushq %rax
movq 0x1c9ec(%rip), %rdi # 0x2da30
testq %rdi, %rdi
je 0x1106f
movq (%rdi), %rax
testq %rax, %rax
je 0x11060
movq %rax, %rdi
callq 0x17c58
movq 0x1c9d0(%rip), %rdi # 0x2da30
callq 0x3500
andq $0x0, 0x1c9c3(%rip) # 0x2da30
popq %rax
retq
callq 0xd163
testq %rax, %rax
je 0x1106d
movq %rax, %r11
lea... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
tlsio_openssl_destroy | void tlsio_openssl_destroy(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;
engine_destroy(tls_io_instance);
if (tls_io_instance->certificate != NULL)
{
... | pushq %rbx
testq %rdi, %rdi
je 0x11377
movq %rdi, %rbx
callq 0x10dbc
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x112fa
callq 0x3500
andq $0x0, 0x70(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1130d
callq 0x3500
andq $0x0, 0x78(%rbx)
movq 0x80(%rbx), %rdi
callq 0x3500
andq $0x0, 0x80(%rbx)
movq 0x88(%rbx), %rdi
ca... | /Azure[P]azure-utpm-c/deps/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x3490
cmpl %r14d, %eax
jne 0x11a14
movl 0x68(%rbx), %eax
cmpl $0x4, %eax
je 0x11a3d
cmpl $0x2, %eax
jne 0x11b2c
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
p... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
on_underlying_io_error | static void on_underlying_io_error(void* context)
{
TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context;
switch (tls_io_instance->tlsio_state)
{
default:
break;
case TLSIO_STATE_OPENING_UNDERLYING_IO:
case TLSIO_STATE_IN_HANDSHAKE:
tls_io_instance->tlsio_state = TLSIO_... | movl 0x68(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x11b52
andl $0x0, 0x68(%rdi)
pushq $0x2
popq %rsi
jmp 0x11f8c
cmpl $0x4, %eax
je 0x12848
retq
| /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
tlsio_openssl_close | int tlsio_openssl_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context)
{
int result;
/* Codes_SRS_TLSIO_30_050: [ If the tlsio_handle parameter is NULL, tlsio_close_async shall log an error and return _FAILURE_. ]*/
if (tls_io == NULL)
{
LogError("... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x11bf7
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x68(%rdi), %eax
orl $0x2, %eax
cmpl $0x6, %eax
je 0x11bb0
callq 0xd163
testq %rax, %rax
je 0x11bb0
movq %rax, %r10
leaq 0xc0cc(%rip), %rsi # 0x1dc5e
leaq 0xc2e0(%rip), %rdx # 0x1de79
leaq 0xc2ed(... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
on_underlying_io_close_complete | static void on_underlying_io_close_complete(void* context)
{
TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context;
switch (tls_io_instance->tlsio_state)
{
default:
case TLSIO_STATE_NOT_OPEN:
case TLSIO_STATE_OPEN:
case TLSIO_STATE_IN_HANDSHAKE:
case TLSIO_STATE_HANDSHAKE_FAILED:... | pushq %rbx
movq %rdi, %rbx
movl 0x68(%rdi), %eax
cmpl $0x5, %eax
je 0x11c77
cmpl $0x1, %eax
jne 0x11c8a
andl $0x0, 0x68(%rbx)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11f8c
jmp 0x11c8a
andl $0x0, 0x68(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x11c8a
movq 0x38(%rbx), %rdi
callq *%rax
movq %rbx, %rdi
popq %rbx... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
tlsio_openssl_send | int tlsio_openssl_send(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context)
{
int result;
if (tls_io == NULL)
{
LogError("NULL tls_io.");
result = MU_FAILURE;
}
else
{
TLS_IO_INSTANCE* tls_io_instance = (T... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x11d26
movq %rdi, %r15
cmpl $0x4, 0x68(%rdi)
jne 0x11d5e
movq 0x48(%r15), %rdi
testq %rdi, %rdi
je 0x11d92
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
callq 0x3790
cmpl %r12d, %eax
jne 0x11dd7
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
write_outgoing_bytes | static int write_outgoing_bytes(TLS_IO_INSTANCE* tls_io_instance, ON_SEND_COMPLETE on_send_complete, void* callback_context)
{
int result;
size_t pending = BIO_ctrl_pending(tls_io_instance->out_bio);
if (pending == 0)
{
result = 0;
}
else
{
unsigned char* bytes_to_send = ma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x60(%rdi), %rdi
callq 0x37c0
testq %rax, %rax
je 0x11e96
movq %rax, %r13
movq %rax, %rdi
callq 0x35a0
testq %rax, %rax
je 0x11e9a
movq %rax, %rbx
movq 0x60(%r12), %rdi
movq %rax, %rsi
movl ... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
tlsio_openssl_retrieveoptions | static OPTIONHANDLER_HANDLE tlsio_openssl_retrieveoptions(CONCRETE_IO_HANDLE handle)
{
OPTIONHANDLER_HANDLE result;
if (handle == NULL)
{
LogError("invalid parameter detected: CONCRETE_IO_HANDLE handle=%p", handle);
result = NULL;
}
else
{
result = OptionHandler_Create(tl... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x12942
movq %rdi, %r15
leaq 0x459(%rip), %rdi # 0x12d05
leaq 0x905(%rip), %rsi # 0x131b8
leaq -0x8e6(%rip), %rdx # 0x11fd4
callq 0x17500
testq %rax, %rax
je 0x1297c
movq %rax, %rbx
movq (%r15), %rdi
callq 0x14908
testq %rax, %rax
je... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/tlsio_openssl.c |
x509_openssl_add_pem_file_key | int x509_openssl_add_pem_file_key(SSL_CTX* ssl_ctx, const char* x509privatekey)
{
int result;
BIO* bio_key = BIO_new_mem_buf((char*)x509privatekey, -1); /*taking off the const from the pointer is needed on older versions of OPENSSL*/
if (bio_key == NULL)
{
log_ERR_get_error("cannot create priva... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rax
movq %rdi, %r15
pushq $-0x1
popq %rsi
movq %rax, %rdi
callq 0x30f0
testq %rax, %rax
je 0x133f3
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x32e0
testq %rax, %rax
je 0x13409
movq %rax, %r14
movq %rax, %rdi
c... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/x509_openssl.c |
x509_openssl_add_credentials | int x509_openssl_add_credentials(
SSL_CTX* ssl_ctx,
const char* x509certificate,
const char* x509privatekey,
OPTION_OPENSSL_KEY_TYPE x509privatekeytype)
#endif // OPENSSL_NO_ENGINE
{
int result;
if (ssl_ctx == NULL || x509certificate == NULL || x509privatekey == NULL)
{
/*Codes_SRS_X... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0x13763
callq 0xd163
movl $0x12a, %ebp # imm = 0x12A
testq %rax, %rax
je 0x... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/x509_openssl.c |
BUFFER_new | BUFFER_HANDLE BUFFER_new(void)
{
BUFFER* temp = (BUFFER*)calloc(1, sizeof(BUFFER));
/* Codes_SRS_BUFFER_07_002: [BUFFER_new shall return NULL on any error that occurs.] */
if (temp != NULL)
{
temp->buffer = NULL;
temp->size = 0;
}
return (BUFFER_HANDLE)temp;
} | pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
jmp 0x3300
| /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_safemalloc | static int BUFFER_safemalloc(BUFFER* handleptr, size_t size)
{
int result;
size_t sizetomalloc = size;
if (size == 0)
{
sizetomalloc = 1;
}
handleptr->buffer = (unsigned char*)malloc(sizetomalloc);
if (handleptr->buffer == NULL)
{
/*Codes_SRS_BUFFER_02_003: [If allocating... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x1, %rsi
movq %rsi, %rdi
adcq $0x0, %rdi
callq 0x35a0
movq %rax, (%r14)
testq %rax, %rax
je 0x13c1d
movq %rbx, 0x8(%r14)
xorl %ebx, %ebx
jmp 0x13c50
callq 0xd163
pushq $0x2d
popq %rbx
testq %rax, %rax
je 0x13c50
movq %rax, %r10
leaq 0xb2ed(%rip), %... | /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_delete | void BUFFER_delete(BUFFER_HANDLE handle)
{
/* Codes_SRS_BUFFER_07_004: [BUFFER_delete shall not delete any BUFFER_HANDLE that is NULL.] */
if (handle != NULL)
{
BUFFER* b = (BUFFER*)handle;
if (b->buffer != NULL)
{
/* Codes_SRS_BUFFER_07_003: [BUFFER_delete shall delete t... | testq %rdi, %rdi
je 0x13d26
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3500
movq %rbx, %rdi
popq %rbx
jmp 0x3500
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_build | int BUFFER_build(BUFFER_HANDLE handle, const unsigned char* source, size_t size)
{
int result;
if (handle == NULL)
{
/* Codes_SRS_BUFFER_07_009: [BUFFER_build shall return nonzero if handle is NULL ] */
result = MU_FAILURE;
}
/* Codes_SRS_BUFFER_01_002: [The size argument can be zero... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x13d6b
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x13d72
movq %rsi, %r15
testq %rsi, %rsi
je 0x13d84
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x36d0
testq %rax, %rax
je 0x13d8b
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14... | /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_pre_build | int BUFFER_pre_build(BUFFER_HANDLE handle, size_t size)
{
int result;
if (handle == NULL)
{
/* Codes_SRS_BUFFER_07_006: [If handle is NULL or size is 0 then BUFFER_pre_build shall return a nonzero value.] */
result = MU_FAILURE;
}
else if (size == 0)
{
/* Codes_SRS_BUFFER... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13f92
movq %rsi, %rbx
testq %rsi, %rsi
je 0x13f99
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x13fa0
callq 0xd163
movl $0x116, %ebx # imm = 0x116
testq %rax, %rax
je 0x13fb6
movq %rax, %r10
leaq 0xafaf(%rip), %rsi # 0x1ef21
leaq 0xb19e(%rip), %rdx # ... | /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_content | int BUFFER_content(BUFFER_HANDLE handle, const unsigned char** content)
{
int result;
if ((handle == NULL) || (content == NULL))
{
/* Codes_SRS_BUFFER_07_020: [If the handle and/or content*is NULL BUFFER_content shall return nonzero.] */
result = MU_FAILURE;
}
else
{
BUFF... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0x131, %eax # imm = 0x131
jne 0x14011
movq (%rdi), %rax
movq %rax, (%rsi)
xorl %eax, %eax
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_enlarge | int BUFFER_enlarge(BUFFER_HANDLE handle, size_t enlargeSize)
{
int result;
if (handle == NULL)
{
/* Codes_SRS_BUFFER_07_017: [BUFFER_enlarge shall return a nonzero result if any parameters are NULL or zero.] */
LogError("Failure: handle is invalid.");
result = MU_FAILURE;
}
e... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x140c7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x14137
movq %rdi, %r14
movq 0x8(%rdi), %rax
addq %rbx, %rax
pushq $-0x1
popq %r15
cmovaeq %rax, %r15
cmpq $-0x1, %r15
je 0x140ff
movq (%r14), %rdi
movq %r15, %rsi
callq 0x36d0
testq %rax, %rax
je 0x140ff
m... | /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_size | int BUFFER_size(BUFFER_HANDLE handle, size_t* size)
{
int result;
if ((handle == NULL) || (size == NULL))
{
/* Codes_SRS_BUFFER_07_022: [BUFFER_size shall return a nonzero value for any error that is encountered.] */
result = MU_FAILURE;
}
else
{
BUFFER* b = (BUFFER*)hand... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0x1c9, %eax # imm = 0x1C9
jne 0x1430f
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
xorl %eax, %eax
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_append | int BUFFER_append(BUFFER_HANDLE handle1, BUFFER_HANDLE handle2)
{
int result;
if ( (handle1 == NULL) || (handle2 == NULL) || (handle1 == handle2) )
{
/* Codes_SRS_BUFFER_07_023: [BUFFER_append shall return a nonzero upon any error that is encountered.] */
result = MU_FAILURE;
}
else
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1db, %ebx # imm = 0x1DB
cmpq %rsi, %rdi
je 0x143e0
movq %rdi, %r14
testq %rdi, %rdi
je 0x143e0
movq %rsi, %r15
testq %rsi, %rsi
je 0x143e0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1439b
cmpq $0x0, (%r15)
je 0x143a2
movq 0x8(%r15), %rax
xorl %ebx, ... | /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_prepend | int BUFFER_prepend(BUFFER_HANDLE handle1, BUFFER_HANDLE handle2)
{
int result;
if ((handle1 == NULL) || (handle2 == NULL) || (handle1 == handle2))
{
/* Codes_SRS_BUFFER_01_005: [ BUFFER_prepend shall return a non-zero upon value any error that is encountered. ]*/
result = MU_FAILURE;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x213, %ebx # imm = 0x213
cmpq %rsi, %rdi
je 0x14514
movq %rdi, %r14
testq %rdi, %rdi
je 0x14514
movq %rsi, %r15
testq %rsi, %rsi
je 0x14514
movq (%r14), %r12
testq %r12, %r12
je 0x1449b
movq (%r15), %rbp
testq %rbp, %rbp
je 0... | /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
BUFFER_length | size_t BUFFER_length(BUFFER_HANDLE handle)
{
size_t result;
if (handle == NULL)
{
/* Codes_SRS_BUFFER_07_028: [BUFFER_length shall return zero for any error that is encountered.] */
result = 0;
}
else
{
BUFFER* b = (BUFFER*)handle;
result = b->size;
}
retu... | testq %rdi, %rdi
je 0x14599
movq 0x8(%rdi), %rax
retq
xorl %eax, %eax
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/buffer.c |
xio_create | XIO_HANDLE xio_create(const IO_INTERFACE_DESCRIPTION* io_interface_description, const void* xio_create_parameters)
{
XIO_INSTANCE* xio_instance;
/* Codes_SRS_XIO_01_003: [If the argument io_interface_description is NULL, xio_create shall return NULL.] */
if ((io_interface_description == NULL) ||
/* ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x147aa
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x147aa
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x147aa
cmpq $0x0, 0x10(%r15)
je 0x147aa
cmpq $0x0, 0x18(%r15)
je 0x147aa
cmpq $0x0, 0x20(%r15)
je 0x147aa
cmpq $0x0, 0x28(%r15)
je 0x147aa
cmpq $0x0, ... | /Azure[P]azure-utpm-c/deps/c-utility/src/xio.c |
xio_send | int xio_send(XIO_HANDLE xio, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context)
{
int result;
/* Codes_SRS_XIO_01_011: [No error check shall be performed on buffer and size.] */
/* Codes_SRS_XIO_01_010: [If handle is NULL, xio_send shall return a non-zero value.] */... | testq %rdi, %rdi
je 0x1483a
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq 0x28(%rax), %rax
jmpq *%rax
movl $0x8c, %eax
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/xio.c |
Map_Create | MAP_HANDLE Map_Create(MAP_FILTER_CALLBACK mapFilterFunc)
{
/*Codes_SRS_MAP_02_001: [Map_Create shall create a new, empty map.]*/
MAP_HANDLE_DATA* result = (MAP_HANDLE_DATA*)calloc(1, sizeof(MAP_HANDLE_DATA));
/*Codes_SRS_MAP_02_002: [If during creation there are any error, then Map_Create shall return NULL.... | pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x3300
testq %rax, %rax
je 0x14c5c
movq %rbx, 0x18(%rax)
popq %rbx
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/map.c |
Map_Add | MAP_RESULT Map_Add(MAP_HANDLE handle, const char* key, const char* value)
{
MAP_RESULT result;
/*Codes_SRS_MAP_02_006: [If parameter handle is NULL then Map_Add shall return MAP_INVALID_ARG.] */
/*Codes_SRS_MAP_02_007: [If parameter key is NULL then Map_Add shall return MAP_INVALID_ARG.]*/
/*Codes_SRS_M... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0x14f19
callq 0xd163
pushq $0x3
popq %rbx
testq %rax, %rax
je 0x14f2f
movq %rax, %r10
leaq 0x18965(%rip), %r11 # 0x2d840
subq $0x8, %rsp
leaq 0x8c92(%rip), %r14 # 0... | /Azure[P]azure-utpm-c/deps/c-utility/src/map.c |
findKey | static char** findKey(MAP_HANDLE_DATA* handleData, const char* key)
{
char** result;
if (handleData->keys == NULL)
{
result = NULL;
}
else
{
size_t i;
result = NULL;
for (i = 0; i < handleData->count; i++)
{
if (strcmp(handleData->keys[i], key)... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x14fe7
movq %rsi, %r14
movq 0x10(%rdi), %r15
subq $0x1, %r15
jb 0x14fe7
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x35f0
testl %eax, %eax
je 0x14fe9
addq $0x8, %rbx
jmp 0x14fcc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/map.c |
insertNewKeyValue | static int Map_IncreaseStorageKeysValues(MAP_HANDLE_DATA* handleData)
{
int result;
char** newKeys;
size_t realloc_size = safe_add_size_t(handleData->count, 1);
realloc_size = safe_multiply_size_t(realloc_size, sizeof(char*));
if (realloc_size == SIZE_MAX ||
(newKeys = (char**)realloc(handle... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r12
incq %r12
pushq $-0x1
popq %r13
cmoveq %r13, %r12
movq %r12, %rax
shrq $0x3d, %rax
shlq $0x3, %r12
xorl %ebp, %ebp
movq %rax, %rcx
negq %rcx
sbbq %rbp, %rbp
testq %rax, %rax
jne 0x150f7
movq %rdx, %r14
movq %rsi, %r15
mov... | /Azure[P]azure-utpm-c/deps/c-utility/src/map.c |
Map_ContainsKey | MAP_RESULT Map_ContainsKey(MAP_HANDLE handle, const char* key, bool* keyExists)
{
MAP_RESULT result;
/*Codes_SRS_MAP_02_024: [If parameter handle, key or keyExists are NULL then Map_ContainsKey shall return MAP_INVALIDARG.]*/
if (
(handle ==NULL) ||
(key == NULL) ||
(keyExists == NUL... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0x156d6
callq 0xd163
pushq $0x3
popq %rbx
testq %rax, %rax
je 0x156e7
movq %rax, %r10
leaq 0x181a8(%rip), %r11 # 0x2d840
subq $0x8, %rsp
leaq 0x84d5(%rip), %r14 # 0... | /Azure[P]azure-utpm-c/deps/c-utility/src/map.c |
Map_ToJSON | STRING_HANDLE Map_ToJSON(MAP_HANDLE handle)
{
STRING_HANDLE result;
/*Codes_SRS_MAP_02_052: [If parameter handle is NULL then Map_ToJSON shall return NULL.] */
if (handle == NULL)
{
result = NULL;
LogError("invalid arg (NULL)");
}
else
{
/*Codes_SRS_MAP_02_048: [Map_T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15ab6
movq %rdi, %r14
leaq 0x9de5(%rip), %rdi # 0x1f6d3
callq 0x15c95
testq %rax, %rax
je 0x15aeb
movq %rax, %rbx
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpq 0x10(%r14), %r12
jae 0x15a79
testb $0x1, %bpl
jne 0x15a79
movq ... | /Azure[P]azure-utpm-c/deps/c-utility/src/map.c |
STRING_new | STRING_HANDLE STRING_new(void)
{
STRING* result;
if ((result = (STRING*)malloc(sizeof(STRING))) != NULL)
{
if ((result->s = (char*)malloc(1)) != NULL)
{
result->s[0] = '\0';
}
else
{
/* Codes_SRS_STRING_07_002: [STRING_new shall return an NULL ... | pushq %rbx
pushq $0x8
popq %rdi
callq 0x35a0
testq %rax, %rax
je 0x15be2
movq %rax, %rbx
pushq $0x1
popq %rdi
callq 0x35a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x15baa
movb $0x0, (%rax)
jmp 0x15be4
callq 0xd163
testq %rax, %rax
je 0x15bda
movq %rax, %r10
leaq 0x9c60(%rip), %rsi # 0x1f81e
leaq 0x9cbd(%rip), %rdx ... | /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_new_with_memory | STRING_HANDLE STRING_new_with_memory(const char* memory)
{
STRING* result;
if (memory == NULL)
{
/* Codes_SRS_STRING_07_007: [STRING_new_with_memory shall return a NULL STRING_HANDLE if the supplied char* is NULL.] */
result = NULL;
}
else
{
if ((result = (STRING*)malloc(... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16025
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x35a0
testq %rax, %rax
je 0x15fef
movq %rax, %rbx
movq %r14, (%rax)
jmp 0x16027
callq 0xd163
testq %rax, %rax
je 0x16025
movq %rax, %r10
leaq 0x981b(%rip), %rsi # 0x1f81e
leaq 0x99f0(%rip), %rdx # 0x1f9fa
... | /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_new_JSON | STRING_HANDLE STRING_new_JSON(const char* source)
{
STRING* result;
if (source == NULL)
{
/*Codes_SRS_STRING_02_011: [If source is NULL then STRING_new_JSON shall return NULL.] */
result = NULL;
LogError("invalid arg (NULL)");
}
else
{
size_t i;
size_t nCo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1615b
movq %rdi, %r14
callq 0x3200
movq %rax, %r12
xorl %r15d, %r15d
movabsq $0x400000000002001, %rcx # imm = 0x400000000002001
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %r12
je 0x16193
movzbl (%r14,%rdx), %esi
testb %sil, %sil
js 0x1629a
cmp... | /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_concat | int STRING_concat(STRING_HANDLE handle, const char* s2)
{
int result;
if ((handle == NULL) || (s2 == NULL))
{
/* Codes_SRS_STRING_07_013: [STRING_concat shall return a nonzero number if an error is encountered.] */
result = MU_FAILURE;
}
else
{
STRING* s1 = (STRING*)handl... | 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
movl $0x196, %ebp # imm = 0x196
jne 0x1646b
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rbp
movq %rbp, %rdi
callq 0x3200
movq %rax, %r15
movq %rbx, %rdi
callq 0x3200... | /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_copy | int STRING_copy(STRING_HANDLE handle, const char* s2)
{
int result;
if ((handle == NULL) || (s2 == NULL))
{
/* Codes_SRS_STRING_07_017: [STRING_copy shall return a nonzero value if any of the supplied parameters are NULL.] */
result = MU_FAILURE;
}
else
{
STRING* s1 = (ST... | 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
movl $0x1e2, %ebx # imm = 0x1E2
jne 0x16630
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbp
xorl %ebx, %ebx
cmpq %rsi, %rbp
je 0x16630
movq %r14, %rdi
callq 0x3200
m... | /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_delete | void STRING_delete(STRING_HANDLE handle)
{
/* Codes_SRS_STRING_07_011: [STRING_delete will not attempt to free anything with a NULL STRING_HANDLE.] */
if (handle != NULL)
{
STRING* value = (STRING*)handle;
free(value->s);
value->s = NULL;
free(value);
}
} | testq %rdi, %rdi
je 0x16a84
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3500
movq %rbx, %rdi
popq %rbx
jmp 0x3500
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_c_str | const char* STRING_c_str(STRING_HANDLE handle)
{
const char* result;
if (handle != NULL)
{
result = ((STRING*)handle)->s;
}
else
{
/* Codes_SRS_STRING_07_021: [STRING_c_str shall return NULL if the STRING_HANDLE is NULL.] */
result = NULL;
}
return result;
} | testq %rdi, %rdi
je 0x16a8e
movq (%rdi), %rax
retq
xorl %eax, %eax
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_length | size_t STRING_length(STRING_HANDLE handle)
{
size_t result = 0;
/* Codes_SRS_STRING_07_025: [STRING_length shall return zero if the given handle is NULL.] */
if (handle != NULL)
{
STRING* value = (STRING*)handle;
result = strlen(value->s);
}
return result;
} | testq %rdi, %rdi
je 0x16a9e
movq (%rdi), %rdi
jmp 0x3200
xorl %eax, %eax
retq
| /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_construct_n | STRING_HANDLE STRING_construct_n(const char* psz, size_t n)
{
STRING_HANDLE result;
/*Codes_SRS_STRING_02_008: [If psz is NULL then STRING_construct_n shall return NULL.] */
if (psz == NULL)
{
result = NULL;
LogError("invalid arg (NULL)");
}
else
{
size_t len = strlen... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x16af8
movq %rsi, %r14
movq %rdi, %r15
callq 0x3200
cmpq %r14, %rax
jae 0x16b35
callq 0xd163
testq %rax, %rax
je 0x16bc0
movq %rax, %r10
leaq 0x8d43(%rip), %rsi # 0x1f81e
leaq 0x915b(%rip), %rdx # 0x1fc3d
leaq 0x9167(... | /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
STRING_from_byte_array | STRING_HANDLE STRING_from_byte_array(const unsigned char* source, size_t size)
{
STRING* result;
/*Codes_SRS_STRING_02_022: [ If source is NULL and size > 0 then STRING_from_BUFFER shall fail and return NULL. ]*/
if ((source == NULL) && (size > 0))
{
LogError("invalid parameter (NULL)");
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x16c62
callq 0xd163
testq %rax, %rax
je 0x16d2f
movq %rax, %r10
leaq 0x8bdc(%rip), %rsi # 0x1f81e
leaq 0x9060(%rip), %rdx # 0x1fca9
leaq 0x9070(%rip), %r9 # 0x1f... | /Azure[P]azure-utpm-c/deps/c-utility/src/strings.c |
DestroyInternal | static void DestroyInternal(OPTIONHANDLER_HANDLE handle)
{
if (handle != NULL)
{
/*Codes_SRS_OPTIONHANDLER_02_016: [ Otherwise, OptionHandler_Destroy shall free all used resources. ]*/
size_t nOptions = VECTOR_size(handle->storage), i;
for (i = 0; i < nOptions; i++)
{
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x174b6
movq %rax, %r14
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
cmpq %r15, %r14
je 0x178cd
movq %r15, %rsi
callq 0x17262
testq %rax, %rax
je 0x178c8
movq %rax, %r12
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq *0x8(%rbx)
... | /Azure[P]azure-utpm-c/deps/c-utility/src/optionhandler.c |
Lock_Init | LOCK_HANDLE Lock_Init(void)
{
/* Codes_SRS_LOCK_10_002: [Lock_Init on success shall return a valid lock handle which should be a non NULL value] */
pthread_mutex_t* result = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
if (result == NULL)
{
LogError("malloc failed.");
}
else
{
... | pushq %rbx
pushq $0x28
popq %rdi
callq 0x35a0
testq %rax, %rax
je 0x17b1d
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3660
testl %eax, %eax
je 0x17b53
callq 0xd163
testq %rax, %rax
je 0x17b13
movq %rax, %r10
leaq 0x87f6(%rip), %rsi # 0x202ed
leaq 0x885e(%rip), %rdx # 0x2035c
leaq 0x8861(%rip), %r9... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/lock_pthreads.c |
Lock_Deinit | LOCK_RESULT Lock_Deinit(LOCK_HANDLE handle)
{
LOCK_RESULT result;
if (NULL == handle)
{
/* Codes_SRS_LOCK_10_007: [Lock_Deinit on NULL handle passed returns LOCK_ERROR] */
LogError("Invalid argument; handle is NULL.");
result = LOCK_ERROR;
}
else
{
/* Codes_SRS_LO... | pushq %rbx
testq %rdi, %rdi
je 0x17c93
movq %rdi, %rbx
callq 0x34e0
testl %eax, %eax
je 0x17cc8
callq 0xd163
pushq $0x2
popq %rbx
testq %rax, %rax
je 0x17cd3
movq %rax, %r10
leaq 0x866c(%rip), %rsi # 0x202ed
leaq 0x8769(%rip), %rdx # 0x203f1
leaq 0x876e(%rip), %r9 # 0x203fd
pushq $0x6b
jmp 0x17cba
callq... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/lock_pthreads.c |
socketio_destroy | void socketio_destroy(CONCRETE_IO_HANDLE socket_io)
{
if (socket_io != NULL)
{
SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io;
/* we cannot do much if the close fails, so just ignore the result */
if (socket_io_instance->socket != INVALID_SOCKET)
{
... | testq %rdi, %rdi
je 0x17f88
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
cmpl $-0x1, %edi
je 0x17f6d
callq 0x37b0
jmp 0x17f6d
movq %rax, %r14
movq %rax, %rdi
callq 0x19ecb
testq %rax, %rax
je 0x17f61
movq %rax, %r15
movq (%rax), %rdi
callq 0x3500
movq %r15, %rdi
callq 0x3500
movq 0x58(%rbx), %rdi
... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/socketio_berkeley.c |
socketio_open | int socketio_open(CONCRETE_IO_HANDLE socket_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context)
{
int result;
SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0x17fe2
cmpl $0x0, 0x50(%r15)
je 0x18022
callq 0xd163
movl $0x360, %ebp # imm = 0x360
testq %rax, %rax
je 0x18114
movq %rax, %r10
leaq 0x8454(%rip), %rsi # 0... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/socketio_berkeley.c |
socketio_send | int socketio_send(CONCRETE_IO_HANDLE socket_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context)
{
int result;
if ((socket_io == NULL) ||
(buffer == NULL) ||
(size == 0))
{
/* Invalid arguments */
LogError("Invalid argument: send gi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0x18383
callq 0xd163
movl $0x3ba, %ebx # imm = 0x3BA
testq %rax, %rax
je 0x1842e
movq %rax, %r10
leaq ... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/socketio_berkeley.c |
add_pending_io | static int add_pending_io(SOCKET_IO_INSTANCE* socket_io_instance, const unsigned char* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context)
{
int result;
PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)malloc(sizeof(PENDING_SOCKET_IO));
if (pending_socket_io == NULL)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbp
pushq $0x28
popq %rdi
callq 0x35a0
testq %rax, %rax
je 0x1860c
movq %rax, %rbx
movq %r14, %rdi
callq 0x35a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x18613
movq %r14,... | /Azure[P]azure-utpm-c/deps/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 0x194f7
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x73d4(%rip), %rsi # 0x207d1
movq %r15, %rdi
cal... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/socketio_berkeley.c |
destroy_network_interface_descriptions | static void destroy_network_interface_descriptions(NETWORK_INTERFACE_DESCRIPTION* nid)
{
if (nid != NULL)
{
if (nid->next != NULL)
{
destroy_network_interface_descriptions(nid->next);
}
if (nid->name != NULL)
{
free(nid->name);
}
... | testq %rdi, %rdi
je 0x196f5
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x196d2
callq 0x196bb
movq (%rbx), %rdi
callq 0x3500
movq 0x8(%rbx), %rdi
callq 0x3500
movq 0x10(%rbx), %rdi
callq 0x3500
movq %rbx, %rdi
popq %rbx
jmp 0x3500
retq
| /Azure[P]azure-utpm-c/deps/c-utility/adapters/socketio_berkeley.c |
socketio_CloneOption | static void* socketio_CloneOption(const char* name, const void* value)
{
void* result;
if (name != NULL)
{
result = NULL;
if (strcmp(name, OPTION_NET_INT_MAC_ADDRESS) == 0)
{
if (value == NULL)
{
LogError("Failed cloning option %s (value is N... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19855
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6ff3(%rip), %rsi # 0x20809
callq 0x35f0
testl %eax, %eax
je 0x1985f
callq 0xd163
testq %rax, %rax
je 0x19855
movq %rax, %r10
movq %rbx, (%rsp)
leaq 0x6be4(%rip), %rsi # 0x2041b
leaq 0x76f3(%rip), %rdx # 0x... | /Azure[P]azure-utpm-c/deps/c-utility/adapters/socketio_berkeley.c |
dns_resolver_create | DNSRESOLVER_HANDLE dns_resolver_create(const char* hostname, int port, const DNSRESOLVER_OPTIONS* options)
{
/* Codes_SRS_dns_resolver_30_012: [ The optional options parameter shall be ignored. ]*/
DNSRESOLVER_INSTANCE* result;
(void)options;
if (hostname == NULL)
{
/* Codes_SRS_dns_resolver... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1999d
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x3300
testq %rax, %rax
je 0x199c5
movq %rax, %rbx
movl %ebp, 0x8(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0xcf00
testl %eax, %eax
je 0x199fb
movq %rbx, %rdi
callq 0x3500
jmp ... | /Azure[P]azure-utpm-c/deps/c-utility/src/dns_resolver_sync.c |
dns_resolver_is_lookup_complete | bool dns_resolver_is_lookup_complete(DNSRESOLVER_HANDLE dns_in)
{
DNSRESOLVER_INSTANCE* dns = (DNSRESOLVER_INSTANCE*)dns_in;
bool result;
if (dns == NULL)
{
/* Codes_SRS_dns_resolver_30_020: [ If the dns parameter is NULL, dns_resolver_is_create_complete shall log an error and return false. ]*/... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x19aed
cmpb $0x0, 0x10(%rbx)
jne 0x19b53
andq $0x0, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movabsq $0x100000002, %rax # imm = 0x100000002
movq %rax, 0x24(%rsp)
movl 0x8(%rbx)... | /Azure[P]azure-utpm-c/deps/c-utility/src/dns_resolver_sync.c |
dns_resolver_get_addrInfo | struct addrinfo* dns_resolver_get_addrInfo(DNSRESOLVER_HANDLE dns_in)
{
DNSRESOLVER_INSTANCE* dns = (DNSRESOLVER_INSTANCE*)dns_in;
struct addrinfo* result;
if (dns == NULL)
{
/* Codes_SRS_dns_resolver_30_030: [ If the dns parameter is NULL, dns_resolver_get_ipv4 shall log an error and return 0. ... | pushq %rbx
testq %rdi, %rdi
je 0x19c66
cmpb $0x1, 0x10(%rdi)
jne 0x19c97
cmpb $0x0, 0x11(%rdi)
jne 0x19ccd
movq 0x18(%rdi), %rbx
jmp 0x19ccf
callq 0xd163
testq %rax, %rax
je 0x19ccd
movq %rax, %r10
leaq 0x7346(%rip), %rsi # 0x20fc0
leaq 0x74ab(%rip), %rdx # 0x2112c
leaq 0x73ff(%rip), %r9 # 0x21087
xorl ... | /Azure[P]azure-utpm-c/deps/c-utility/src/dns_resolver_sync.c |
singlylinkedlist_remove | int singlylinkedlist_remove(SINGLYLINKEDLIST_HANDLE list, LIST_ITEM_HANDLE item)
{
int result;
/* Codes_SRS_LIST_01_024: [If any of the arguments list or item_handle is NULL, singlylinkedlist_remove shall fail and return a non-zero value.] */
if ((list == NULL) ||
(item == NULL))
{
LogE... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x19dee
callq 0xd163
pushq $0x6e
popq %rbp
testq %rax, %rax
je 0x19e33
movq %rax, %r10
leaq 0x737b(%rip), %rsi # 0x21146
leaq 0x741a(%rip), %rdx # 0x211ec
leaq 0x73ef(%rip), %r9... | /Azure[P]azure-utpm-c/deps/c-utility/src/singlylinkedlist.c |
singlylinkedlist_get_head_item | LIST_ITEM_HANDLE singlylinkedlist_get_head_item(SINGLYLINKEDLIST_HANDLE list)
{
LIST_ITEM_HANDLE result;
if (list == NULL)
{
/* Codes_SRS_LIST_01_009: [If the list argument is NULL, singlylinkedlist_get_head_item shall return NULL.] */
LogError("Invalid argument (list=NULL)");
resul... | pushq %rbx
testq %rdi, %rdi
je 0x19e45
movq (%rdi), %rbx
jmp 0x19e7d
callq 0xd163
testq %rax, %rax
je 0x19e7b
movq %rax, %r10
leaq 0x72ed(%rip), %rsi # 0x21146
leaq 0x73a4(%rip), %rdx # 0x21204
leaq 0x73bc(%rip), %r9 # 0x21223
xorl %ebx, %ebx
pushq $0x1
popq %r8
xorl %edi, %edi
movl $0xad, %ecx
xorl %ea... | /Azure[P]azure-utpm-c/deps/c-utility/src/singlylinkedlist.c |
singlylinkedlist_get_next_item | LIST_ITEM_HANDLE singlylinkedlist_get_next_item(LIST_ITEM_HANDLE item_handle)
{
LIST_ITEM_HANDLE result;
if (item_handle == NULL)
{
LogError("Invalid argument (list is NULL)");
/* Codes_SRS_LIST_01_019: [If item_handle is NULL then singlylinkedlist_get_next_item shall return NULL.] */
... | pushq %rbx
testq %rdi, %rdi
je 0x19e8e
movq 0x8(%rdi), %rbx
jmp 0x19ec6
callq 0xd163
testq %rax, %rax
je 0x19ec4
movq %rax, %r10
leaq 0x72a4(%rip), %rsi # 0x21146
leaq 0x7397(%rip), %rdx # 0x21240
leaq 0x73af(%rip), %r9 # 0x2125f
xorl %ebx, %ebx
pushq $0x1
popq %r8
xorl %edi, %edi
movl $0xc2, %ecx
xorl ... | /Azure[P]azure-utpm-c/deps/c-utility/src/singlylinkedlist.c |
ion_switch_handler | ion_err_t
ion_switch_handler(
ion_dictionary_type_t type,
ion_dictionary_handler_t *handler
) {
switch (type) {
case dictionary_type_bpp_tree_t: {
bpptree_init(handler);
break;
}
case dictionary_type_flat_file_t: {
ffdict_init(handler);
break;
}
case dictionary_type_open_address_file_hash_t:... | pushq %rax
cmpl $0x6, %edi
ja 0x47d1
movl %edi, %eax
leaq 0x9002(%rip), %rcx # 0xd790
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
callq 0x8e22
jmp 0x47d1
movq %rsi, %rdi
callq 0x53ae
jmp 0x47d1
movq %rsi, %rdi
callq 0x8046
jmp 0x47d1
movq %rsi, %rdi
callq 0x76f7
jmp 0x47d1
movq %rsi, %rdi... | /iondbproject[P]iondb/src/dictionary/ion_master_table.c |
ion_add_to_master_table | ion_err_t
ion_add_to_master_table(
ion_dictionary_t *dictionary,
ion_dictionary_size_t dictionary_size
) {
ion_dictionary_config_info_t config = {
.id = dictionary->instance->id, .use_type = 0, .type = dictionary->instance->key_type, .key_size = dictionary->instance->record.key_size, .value_size = dictionary->ins... | subq $0x28, %rsp
movq 0x8(%rdi), %rcx
movl 0x18(%rcx), %edx
leaq 0x8(%rsp), %rax
movl %edx, (%rax)
movb $0x0, 0x4(%rax)
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x8(%rcx), %edx
movl %edx, 0x10(%rax)
movl %esi, 0x14(%rax)
movl 0x1c(%rcx), %ecx
movl %ecx, 0x18(%rax)
movb (%rdi), %cl
movb %cl, 0x1c(%rax)
pushq $-0x2
po... | /iondbproject[P]iondb/src/dictionary/ion_master_table.c |
ion_master_table_create_dictionary | ion_err_t
ion_master_table_create_dictionary(
ion_dictionary_handler_t *handler,
ion_dictionary_t *dictionary,
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
ion_dictionary_size_t dictionary_size
) {
ion_err_t err;
ion_dictionary_id_t id;
err = ion_master_table_get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r13
leaq 0x14(%rsp), %rdi
callq 0x45a9
testb %al, %al
jne 0x488d
movl 0x14(%rsp), %edx
movl %ebx, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movl %... | /iondbproject[P]iondb/src/dictionary/ion_master_table.c |
ion_find_by_use_master_table | ion_err_t
ion_find_by_use_master_table(
ion_dictionary_config_info_t *config,
ion_dict_use_t use_type,
char whence
) {
ion_dictionary_id_t id;
ion_dictionary_config_info_t tconfig;
ion_err_t error;
tconfig.id = 0;
id = 1;
if (ION_MASTER_TABLE_FIND_LAST == whence) {
id = ion_master_tabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, %ebp
leaq 0x8(%rsp), %r15
andl $0x0, (%r15)
movq %rdi, %r14
leaq 0xf847(%rip), %r13 # 0x14120
movl (%r13), %ecx
leal -0x1(%rcx), %eax
cmpb $-0x1, %bl
pushq $0x1
popq %r12
cmovel %eax, %r12d
movb $0x1, %al
... | /iondbproject[P]iondb/src/dictionary/ion_master_table.c |
ion_get_dictionary_type | ion_dictionary_type_t
ion_get_dictionary_type(
ion_dictionary_id_t id
) {
ion_err_t err;
ion_dictionary_config_info_t config;
err = ion_lookup_in_master_table(id, &config);
if (err_ok != err) {
return dictionary_type_error_t;
}
return config.dictionary_type;
} | subq $0x28, %rsp
leaq 0x8(%rsp), %rsi
callq 0x476f
testb %al, %al
jne 0x497d
movl 0x20(%rsp), %eax
jmp 0x4980
pushq $0x6
popq %rax
addq $0x28, %rsp
retq
| /iondbproject[P]iondb/src/dictionary/ion_master_table.c |
ion_delete_dictionary | ion_err_t
ion_delete_dictionary(
ion_dictionary_t *dictionary,
ion_dictionary_id_t id
) {
ion_err_t err;
ion_dictionary_type_t type;
if (ion_dictionary_status_closed != dictionary->status) {
id = dictionary->instance->id;
err = dictionary_delete_dictionary(dictionary);
if (err_ok != err) {
return err... | pushq %r14
pushq %rbx
subq $0x58, %rsp
cmpb $0x1, (%rdi)
jne 0x4a14
movl %esi, %ebx
movl %esi, %edi
callq 0x4965
movl %eax, %edi
movb $0x4, %al
cmpl $0x6, %edi
je 0x4a28
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x477f
movq %r14, %rdi
movl %ebx, %esi
callq 0x5609
testb %al, %al
jne 0x4a28
movl %ebx, %edi
callq 0x4941
... | /iondbproject[P]iondb/src/dictionary/ion_master_table.c |
planck_unit_assert_int_are_not_equal | planck_unit_result_t
planck_unit_assert_int_are_not_equal(
planck_unit_test_t *state,
int32_t expected,
int32_t actual,
int line,
const char *file
) {
const char *message;
int message_size;
char *buffer;
message = "expected not int %ld, got %ld";
message_size = planck_unit_check_int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
leaq 0x14(%rsp), %rsi
movl %r12d, (%rsi)
leaq 0x10(%rsp), %rdx
movl %r15d, (%rdx)
leaq 0x8b7e(%rip), %rdi # 0xd851
callq 0x4b28
movb $0x1, 0x40(%r... | /iondbproject[P]iondb/src/tests/planck-unit/src/planck_unit.c |
planck_unit_assert_str_are_equal | planck_unit_result_t
planck_unit_assert_str_are_equal(
planck_unit_test_t *state,
char *expected,
char *actual,
int line,
const char *file
) {
const char *message;
int message_size;
char *buffer;
message = "expected \\\"%s\\\", got \\\"%s\\\"";
state->allocated_message = 1;
message_size ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movb $0x1, 0x40(%rdi)
leaq 0x8ae9(%rip), %rdi # 0xd86f
callq 0x4b0f
movslq %eax, %rbx
movq %rbx, %rdi
callq 0x1160
movq %rax, %r12
testl %ebx, %ebx
je 0x4deb... | /iondbproject[P]iondb/src/tests/planck-unit/src/planck_unit.c |
planck_unit_assert_str_are_not_equal | planck_unit_result_t
planck_unit_assert_str_are_not_equal(
planck_unit_test_t *state,
char *expected,
char *actual,
int line,
const char *file
) {
const char *message;
int message_size;
char *buffer;
message = "expected not \\\"%s\\\", got \\\"%s\\\"";
message_size = planck_unit_check_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8a52(%rip), %rdi # 0xd88b
callq 0x4b0f
movb $0x1, 0x40(%r14)
movslq %eax, %rbx
movq %rbx, %rdi
callq 0x1160
movq %rax, %r12
testl %ebx, %ebx
je 0x4ea3... | /iondbproject[P]iondb/src/tests/planck-unit/src/planck_unit.c |
ion_time | unsigned long
ion_time(
) {
#if defined(ARDUINO)
return (unsigned long) (millis());
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32)
return (unsigned long) (((double) clock() / CLOCKS_PER_SEC) * 1000);
#elif defined (__unix__) || defined(__APPLE__) && defined (__MACH__)
return (unsigned long) (((double)... | pushq %rax
callq 0x1090
cvtsi2sd %rax, %xmm0
divsd 0x8851(%rip), %xmm0 # 0xd8c0
mulsd 0x8851(%rip), %xmm0 # 0xd8c8
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x8849(%rip), %xmm0 # 0xd8d0
cvttsd2si %xmm0, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
popq %rcx
retq
| /iondbproject[P]iondb/src/tests/planck-unit/src/ion_time/ion_time.c |
sldict_next | ion_cursor_status_t
sldict_next(
ion_dict_cursor_t *cursor,
ion_record_t *record
) {
ion_sldict_cursor_t *sl_cursor = (ion_sldict_cursor_t *) cursor;
if (cursor->status == cs_cursor_uninitialized) {
return cursor->status;
}
else if (cursor->status == cs_end_of_results) {
return cursor->status;
}
else if (... | pushq %r14
pushq %rbx
pushq %rax
movzbl (%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x512e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x881b(%rip), %rdx # 0xd8d8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb $0x4, (%rbx)
jmp 0x50e3
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x5132
movq (%rax), %rsi... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list_handler.c |
sldict_find | ion_err_t
sldict_find(
ion_dictionary_t *dictionary,
ion_predicate_t *predicate,
ion_dict_cursor_t **cursor
) {
*cursor = malloc(sizeof(ion_sldict_cursor_t));
ion_skiplist_t *skip_list = (ion_skiplist_t *) dictionary->instance;
if (NULL == *cursor) {
return err_out_of_memory;
}
(*cursor)->dictionary = dic... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x1160
movq %rax, (%rbx)
movb $0x6, %bpl
testq %rax, %rax
je 0x5366
movq %rax, %r12
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x8(%r12)
movb $0x3, (%r... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list_handler.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.