name string | code string | asm string | file string |
|---|---|---|---|
dlep_base_proto_radio_init | void
dlep_base_proto_radio_init(void) {
_base = dlep_base_proto_init();
dlep_extension_add_processing(_base, true, _radio_signals, ARRAYSIZE(_radio_signals));
oonf_class_extension_add(&_layer2_net_listener);
oonf_class_extension_add(&_layer2_neigh_listener);
oonf_class_extension_add(&_layer2_dst_listener);
... | pushq %rax
callq 0x21d40
movq %rax, 0x4781b(%rip) # 0x6d768
leaq 0x321dc(%rip), %rdx # 0x58130
movl $0xf, %ecx
movq %rax, %rdi
movl $0x1, %esi
callq 0x22415
leaq 0x3232b(%rip), %rdi # 0x58298
callq 0x11b12
leaq 0x32367(%rip), %rdi # 0x582e0
callq 0x11b12
leaq 0x323a3(%rip), %rdi # 0x58328
callq 0x11... | /OLSR[P]OONF/src/generic/dlep/ext_base_proto/proto_radio.c |
radio_write_peer_offer | static int
_radio_write_peer_offer(struct dlep_extension *ext __attribute__((unused)), struct dlep_session *session,
const struct oonf_layer2_neigh_key *addr __attribute__((unused))) {
struct dlep_radio_if *radio_if;
struct netaddr local_addr;
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str nbuf;
#endif
radio_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq 0x150(%rsi), %rdi
addq $0xc, %rdi
callq 0x26cca
movq %rax, %r14
testq %rax, %rax
sete %al
cmpq %rbx, %r14
setne %cl
orb %al, %cl
jne 0x26183
movl 0x130(%rbx), %r15d
leaq 0x4785c(%rip), %r12 # 0x6d8d0
testb $0x1, (%r12,%r15)
je 0x260bf... | /OLSR[P]OONF/src/generic/dlep/ext_base_proto/proto_radio.c |
radio_process_session_update_ack | static int
_radio_process_session_update_ack(struct dlep_extension *ext __attribute__((unused)), struct dlep_session *session) {
dlep_base_proto_print_status(session);
if (session->_peer_state == DLEP_PEER_SEND_UPDATE) {
if (dlep_session_generate_signal(session, DLEP_SESSION_UPDATE, NULL)) {
// TODO: do w... | pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x21e07
movl $0x4, %eax
cmpl $0x3, 0x318(%rbx)
jne 0x26554
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x24bc9
movl %eax, %ecx
movl $0xfffffff7, %eax # imm = 0xFFFFFFF7
testl %ecx, %ecx
jne 0x2655c
movl $0x2, %eax
movl %eax, 0x318(%rbx)
xorl %eax, %eax
po... | /OLSR[P]OONF/src/generic/dlep/ext_base_proto/proto_radio.c |
l2_neigh_added | static void
_l2_neigh_added(struct oonf_layer2_neigh *l2neigh, struct oonf_layer2_destination *l2dest,
const struct oonf_layer2_neigh_key *mac) {
struct dlep_radio_if *radio_if;
struct dlep_radio_session *radio_session;
radio_if = dlep_radio_get_by_layer2_if(l2neigh->network->name);
if (!radio_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x26cca
testq %rax, %rax
je 0x26803
movq %rax, %r15
movq 0xb88(%rax), %r12
movq 0x8(%r12), %rax
cmpq 0xb90(%r15), %rax
je 0x26803
cmpb $0x1, -0x360(%r12)
jne 0x267fd
leaq -0x378(%r12), %rdi
movq %r14, %rsi... | /OLSR[P]OONF/src/generic/dlep/ext_base_proto/proto_radio.c |
l2_neigh_removed | static void
_l2_neigh_removed(
struct oonf_layer2_neigh *l2neigh, struct oonf_layer2_destination *l2dest, const struct oonf_layer2_neigh_key *mac) {
struct dlep_radio_if *radio_if;
struct dlep_radio_session *radio_session;
struct dlep_local_neighbor *local;
radio_if = dlep_radio_get_by_layer2_if(l2neigh->net... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rdi), %rdi
callq 0x26cca
testq %rax, %rax
je 0x269c8
movq %rax, %r14
movq 0xb88(%rax), %r12
movq 0x8(%r12), %rax
cmpq 0xb90(%r14), %rax
je 0x269c8
cmpb $0x1, -0x360(%r12)
jne 0x269c2
leaq -0x298(%r12), %rdi
movq %rbx, %rsi
callq 0x2780e
t... | /OLSR[P]OONF/src/generic/dlep/ext_base_proto/proto_radio.c |
dlep_radio_interface_cleanup | void
dlep_radio_interface_cleanup(void) {
struct dlep_radio_if *interf, *it;
avl_for_each_element_safe(dlep_if_get_tree(true), interf, interf._node, it) {
dlep_radio_remove_interface(interf);
}
oonf_class_remove(&_interface_class);
dlep_radio_session_cleanup();
dlep_extension_cleanup();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %edi
callq 0x22d34
movq (%rax), %rbx
movq (%rbx), %r14
movq 0x8(%rbx), %r15
movl $0x1, %edi
callq 0x22d34
cmpq 0x8(%rax), %r15
je 0x26c27
movq %r14, %r15
addq $-0xb50, %rbx # imm = 0xF4B0
movq %rbx, %rdi
callq 0x26c48
movq (%r14), %r14
movq 0x8... | /OLSR[P]OONF/src/generic/dlep/radio/dlep_radio_interface.c |
dlep_radio_add_interface | struct dlep_radio_if *
dlep_radio_add_interface(const char *ifname) {
struct dlep_radio_if *interface;
interface = dlep_radio_get_by_layer2_if(ifname);
if (interface) {
return interface;
}
interface = oonf_class_malloc(&_interface_class);
if (!interface) {
return NULL;
}
if (dlep_if_add(&inte... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
callq 0x22d34
movq %rax, %rdi
movq %r14, %rsi
callq 0x2780e
leaq -0xb50(%rax), %rbx
testq %rax, %rax
cmoveq %rax, %rbx
jne 0x26e17
leaq 0x321b0(%rip), %rdi # 0x58f38
callq 0x11933
testq %rax, %rax
je 0x26dd5
movq %rax, %rbx
leaq 0x469d4(%rip), %rax ... | /OLSR[P]OONF/src/generic/dlep/radio/dlep_radio_interface.c |
abuf_memcpy | int
abuf_memcpy(struct autobuf *autobuf, const void *p, const size_t len) {
if (autobuf == NULL || len == 0)
return 0;
if (_autobuf_enlarge(autobuf, autobuf->_len + len) < 0) {
return -1;
}
memcpy(autobuf->_buf + autobuf->_len, p, len);
autobuf->_len += len;
/* null-terminate autobuf */
autobuf-... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x27542
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rsi
addq %rdx, %rsi
callq 0x273c7
testl %eax, %eax
js 0x2753d
movq 0x10(%r15), %rdi
addq 0x8(%r15), %rdi
mo... | /OLSR[P]OONF/src/libcommon/autobuf.c |
abuf_pull | void
abuf_pull(struct autobuf *autobuf, size_t len) {
char *p;
size_t newsize;
if (autobuf == NULL || len == 0)
return;
if (len != autobuf->_len) {
memmove(autobuf->_buf, &autobuf->_buf[len], autobuf->_len - len);
}
autobuf->_len -= len;
if (autobuf->_len + getpagesize() > autobuf->_total) {
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x27641
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
subq %rsi, %rdx
je 0x275fa
movq 0x10(%rbx), %rdi
leaq (%rdi,%r14), %rsi
callq 0x114a0
movq 0x8(%rbx), %r15
subq %r14, %r15
movq %r15, 0x8(%rbx)
callq 0x11520... | /OLSR[P]OONF/src/libcommon/autobuf.c |
avl_comp_int32 | int
avl_comp_int32(const void *k1, const void *k2) {
const int32_t *i1 = k1;
const int32_t *i2 = k2;
if (*i1 > *i2) {
return 1;
}
if (*i2 > *i1) {
return -1;
}
return 0;
} | movl (%rdi), %eax
movl (%rsi), %ecx
xorl %edx, %edx
cmpl %eax, %ecx
setg %dl
negl %edx
cmpl %ecx, %eax
movl $0x1, %eax
cmovlel %edx, %eax
retq
| /OLSR[P]OONF/src/libcommon/avl_comp.c |
avl_find_greaterequal | struct avl_node *
avl_find_greaterequal(const struct avl_tree *tree, const void *key) {
struct avl_node *node, *next;
int diff;
if (tree->root == NULL)
return NULL;
node = _avl_find_rec(tree->root, key, tree->comp, &diff);
/* go right as long as key>node.key */
while (diff > 0) {
if (list_is_last... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2799d
movq %rsi, %rbx
movq 0x20(%r14), %rdx
leaq 0x4(%rsp), %r15
movq %r15, %rcx
callq 0x27845
movq %rax, %r12
cmpl $0x0, (%r15)
jle 0x2796f
xorl %r15d, %r15d
cmpq %r12, 0x8(%r14)
je 0x279a0
movq (%r12), %... | /OLSR[P]OONF/src/libcommon/avl.c |
avl_post_remove | static void
_avl_post_remove(struct avl_tree *tree, struct avl_node *node) {
struct avl_node *parent;
if ((parent = node->parent) == NULL)
return;
if (node == parent->left) {
parent->balance++;
if (parent->balance == 0) {
_avl_post_remove(tree, parent);
return;
}
if (parent->ba... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
testq %r14, %r14
je 0x27fdd
movq 0x18(%r14), %rax
movb 0x30(%r14), %cl
cmpq %rsi, %rax
je 0x27f9f
movl %ecx, %edx
movq %r14, %rsi
decb %dl
movb %dl, 0x30(%r14)
je 0x27f48
testb %cl, %cl
je 0x27fdd
movzbl 0x30(%rax), %ecx
cmpl $0xff, %ecx
je 0x27f8e
... | /OLSR[P]OONF/src/libcommon/avl.c |
json_printvalue | static void
_json_printvalue(struct autobuf *out, const char *txt, bool delimiter) {
const char *ptr;
bool unprintable;
if (delimiter) {
abuf_puts(out, "\"");
}
else if (*txt == 0) {
abuf_puts(out, "0");
}
ptr = txt;
while (*ptr) {
unprintable = !str_char_is_printable(*ptr);
if (unprin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testl %edx, %edx
je 0x28767
leaq 0x14fcd(%rip), %rsi # 0x3d732
jmp 0x28774
cmpb $0x0, (%r14)
jne 0x2877c
leaq 0x19701(%rip), %rsi # 0x41e75
movq %rbx, %rdi
callq 0x27362
movb (%r14),... | /OLSR[P]OONF/src/libcommon/json.c |
netaddr_create_host_bin | int
netaddr_create_host_bin(struct netaddr *host, const struct netaddr *netmask, const void *number, size_t num_length) {
size_t host_index, number_index;
uint8_t host_part_length;
const uint8_t *number_byte;
uint8_t mask;
number_byte = number;
/* copy netmask with prefixlength max */
memcpy(host, netma... | movq %rcx, %rax
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movzwl 0x10(%rsi), %ecx
movw %cx, 0x10(%rdi)
movzbl %cl, %ecx
cmpl $0x2e, %ecx
jg 0x28b05
cmpl $0x2, %ecx
je 0x28b1b
cmpl $0xa, %ecx
jne 0x28b14
movb $-0x80, %r8b
jmp 0x28b23
cmpl $0x2f, %ecx
je 0x28b20
cmpl $0x30, %ecx
jne 0x28b14
movb $0x40, %r8b
jmp 0x28b23
m... | /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_to_prefixstring | const char *
netaddr_to_prefixstring(struct netaddr_str *dst, const struct netaddr *src, bool forceprefix) {
static const char *NONE = "-";
const char *result = NULL;
int maxprefix;
if (!src) {
return strscpy(dst->buf, NONE, sizeof(*dst));
}
maxprefix = netaddr_get_maxprefix(src);
switch (src->_type... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x28f9b
movl %edx, %r8d
movq %rsi, %r14
movzbl 0x10(%rsi), %eax
cmpl $0x2e, %eax
jg 0x28e79
cmpl $0x2, %eax
je 0x28e8c
cmpl $0xa, %eax
jne 0x28e88
movb $-0x80, %dil
jmp 0x28e94
cmpl $0x2f, %eax
je 0x28e91
cm... | /OLSR[P]OONF/src/libcommon/netaddr.c |
uuid_from_string | static int
_uuid_from_string(void *bin, size_t bin_size, const char *src) {
static const size_t max_group_len[5] = { 8, 4, 4, 4, 12 };
char buffer[32 + 4 + 1];
char *current_group, *next_group, *_bin;
size_t i;
if (bin_size < 16) {
return -1;
}
if (strlen(src) > 32 + 4) {
return -1;
}
strscp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x111a0
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq $0x24, %rax
ja 0x29669
movq %rsp, %r15
movl $0x25, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x29d98
xorl %r13d, %r13d
le... | /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_cmp_to_socket | int
netaddr_cmp_to_socket(const struct netaddr *a1, const union netaddr_socket *a2) {
int result = 0;
result = (int)a1->_type - (int)a2->std.sa_family;
if (result) {
return result;
}
if (a1->_type == AF_INET) {
result = memcmp(a1->_addr, &a2->v4.sin_addr, 4);
}
else if (a1->_type == AF_INET6) {
... | movzbl 0x10(%rdi), %ecx
movzwl (%rsi), %edx
movl %ecx, %eax
subl %edx, %eax
je 0x297cf
retq
xorl %eax, %eax
cmpl $0xa, %ecx
je 0x297f0
cmpl $0x2, %ecx
jne 0x2981f
movl (%rdi), %edx
movl 0x4(%rsi), %esi
bswapl %edx
bswapl %esi
xorl %eax, %eax
cmpl %esi, %edx
seta %al
sbbl $0x0, %eax
jmp 0x2981f
movq (%rdi), %rdx
bswapq ... | /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_acl_copy | int
netaddr_acl_copy(struct netaddr_acl *to, const struct netaddr_acl *from) {
netaddr_acl_remove(to);
memcpy(to, from, sizeof(*to));
if (to->accept_count) {
to->accept = calloc(to->accept_count, sizeof(struct netaddr));
if (to->accept == NULL) {
return -1;
}
memcpy(to->accept, from->accept... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x11060
movq 0x10(%r14), %rdi
callq 0x11060
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq $0x0, 0x20(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%r14)
movups %xmm... | /OLSR[P]OONF/src/libcommon/netaddr_acl.c |
cfg_cmd_handle_remove | int
cfg_cmd_handle_remove(
struct cfg_instance *instance __attribute__((unused)), struct cfg_db *db, const char *arg, struct autobuf *log) {
struct _parsed_argument pa;
char *ptr;
int result;
/* get temporary copy of argument string */
ptr = strdup(arg);
if (!ptr)
return -1;
/* prepare for cleanup... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdx, %rdi
callq 0x11550
testq %rax, %rax
je 0x2aab0
movq %rax, %rbx
movq %rsp, %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2a937
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %eax, %eax... | /OLSR[P]OONF/src/libconfig/cfg_cmd.c |
cfg_cmd_handle_get | int
cfg_cmd_handle_get(
struct cfg_instance *instance __attribute__((unused)), struct cfg_db *db, const char *arg, struct autobuf *log) {
struct cfg_section_type *type, *type_it;
struct cfg_named_section *named, *named_it;
struct cfg_entry *entry, *entry_it;
struct _parsed_argument pa;
char *arg_copy, *tmp;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r12
testq %rdx, %rdx
je 0x2aba8
movq %rdx, %r15
cmpb $0x0, (%rdx)
je 0x2aba8
movq %r15, %rdi
callq 0x11550
testq %rax, %rax
je 0x2abf7
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq... | /OLSR[P]OONF/src/libconfig/cfg_cmd.c |
free_sectiontype | static void
_free_sectiontype(struct cfg_section_type *section) {
struct cfg_named_section *named, *named_it;
/* remove all named sections */
CFG_FOR_ALL_SECTION_NAMES(section, named, named_it) {
_free_namedsection(named);
}
avl_remove(§ion->db->sectiontypes, §ion->node);
free((void *)section-... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq 0x50(%rbx), %rax
je 0x2b53c
movq (%rdi), %r14
callq 0x2b9e2
movq 0x8(%r14), %rax
movq %r14, %rdi
jmp 0x2b525
movq 0x40(%rbx), %rdi
movq %rbx, %rsi
callq 0x27bcf
movq 0x38(%rbx), %rdi
callq 0x11060
movq %rbx, %rdi
addq $0x8,... | /OLSR[P]OONF/src/libconfig/cfg_db.c |
cfg_db_append | int
_cfg_db_append(
struct cfg_db *dst, struct cfg_db *src, const char *section_type, const char *section_name, const char *entry_name) {
struct cfg_section_type *section, *section_it;
struct cfg_named_section *named, *named_it;
struct cfg_entry *entry, *entry_it;
char *ptr;
bool dummy;
CFG_FOR_ALL_SECTI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq (%rsi), %r12
movq 0x8(%r12), %rcx
xorl %eax, %eax
movq %rsi, 0x30(%rsp)
cmpq 0x8(%rsi), %rcx
je 0x2b6ce
movq %rdx, %rbx
movq %rdi, %rbp
movq %rdx, 0x28(%rsp)
movq (%r12), %rax
movq %rax, 0x... | /OLSR[P]OONF/src/libconfig/cfg_db.c |
cfg_help_choice | void
cfg_help_choice(struct autobuf *out, bool preamble, const char *(*callback)(size_t idx, const void *ptr),
size_t choice_count, const void *ptr) {
size_t i;
if (preamble) {
cfg_append_printable_line(out, CFG_HELP_INDENT_PREFIX "Parameter must be on of the following list:");
}
abuf_puts(out, " ");... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
testl %esi, %esi
je 0x2bc88
leaq 0x120ff(%rip), %rsi # 0x3dd7d
movq %r15, %rdi
xorl %eax, %eax
callq 0x2dfe9
leaq 0x15c4d(%rip), %rsi # 0x418dc
movq %r15, %rdi
callq 0x2736... | /OLSR[P]OONF/src/libconfig/cfg_help.c |
cfg_io_save | int
cfg_io_save(struct cfg_instance *instance, const char *url, struct cfg_db *src, struct autobuf *log) {
struct cfg_io *io;
const char *io_param = NULL;
io = _find_io(instance, url, &io_param, log);
if (io == NULL) {
cfg_append_printable_line(log, "Error, unknown config io '%s'.", url);
return -1;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
callq 0x2c1c1
testq %rax, %rax
je 0x2c296
movq 0x50(%rax), %rcx
testq %rcx, %rcx
je 0x2c2a5
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
p... | /OLSR[P]OONF/src/libconfig/cfg_io.c |
handle_db_changes | static int
_handle_db_changes(struct cfg_db *pre_change, struct cfg_db *post_change, bool startup) {
struct cfg_section_type default_section_type[2];
struct cfg_named_section default_named_section[2];
struct cfg_schema_section *s_section;
struct cfg_section_type *pre_type, *post_type;
struct cfg_named_section... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x8(%rsp)
movq 0x28(%rdi), %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x2ce62
movq %rsi, %r12
cmpq 0x28(%rsi), %rax
jne 0x2ce62
movl %edx, %ebp
leaq 0x40(%rsp), %rdi
xorl... | /OLSR[P]OONF/src/libconfig/cfg_schema.c |
cfg_tobin_int | int
cfg_tobin_int(void *reference, size_t bin_size, const struct const_strarray *value, uint16_t fraction, size_t int_size) {
int64_t i;
int result;
uint64_t j, scaling;
if (bin_size != int_size) {
return -1;
}
for (j = 0, scaling = 1; j < fraction; j++, scaling*=10);
result = isonumber_to_s64(&i, ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpq %r8, %rsi
jne 0x2d5ae
movq %r8, %r15
movq %rdi, %r14
testw %cx, %cx
je 0x2d593
movzwl %cx, %ecx
movl $0x1, %eax
addq %rax, %rax
leaq (%rax,%rax,4), %rax
decq %rcx
jne 0x2d585
jmp 0x2d598
movl $0x1, %eax
movq (%rdx), %... | /OLSR[P]OONF/src/libconfig/cfg_tobin.c |
cfg_tobin_bitmap256 | int
cfg_tobin_bitmap256(void *reference, size_t bin_size, const struct const_strarray *value) {
struct bitmap256 *bitmap;
const char *ptr;
int idx;
if (bin_size != sizeof(*bitmap)) {
return -1;
}
bitmap = (struct bitmap256 *)reference;
memset(bitmap, 0, sizeof(*bitmap));
strarray_for_each_element... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq $0x20, %rsi
jne 0x2d747
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movdqu %xmm0, (%rdi)
movq (%rdx), %r15
xorl %eax, %eax
testq %r15, %r15
je 0x2d739
movq 0x8... | /OLSR[P]OONF/src/libconfig/cfg_tobin.c |
cfg_validate_choice | int
cfg_validate_choice(struct autobuf *out, const char *section_name, const char *entry_name, const char *value,
const char *(*callback)(size_t idx, const void *ptr), size_t choices_count, const void *ptr) {
int i;
i = cfg_get_choice_index(value, callback, choices_count, ptr);
if (i >= 0) {
return 0;
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq 0x30(%rsp), %rcx
movq %r15, %rdi
movq %r8, %rsi
movq %r9, %rdx
callq 0x2e12e
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x2d9fb
leaq 0x10fbc(%rip), %rsi # 0x3e99f
movq %r12, %rdi
mov... | /OLSR[P]OONF/src/libconfig/cfg_validate.c |
cfg_validate_netaddr | int
cfg_validate_netaddr(struct autobuf *out, const char *section_name, const char *entry_name, const char *value,
bool prefix, const int8_t *af_types, size_t af_types_count) {
struct netaddr addr;
uint8_t max_prefix;
size_t i;
if (netaddr_from_string(&addr, value)) {
cfg_append_printable_line(out,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x6(%rsp), %rdi
movq %rcx, %rsi
callq 0x290a3
testl %eax, %eax
je 0x2dc07
leaq 0x10f56(%rip), %rsi # 0x3eb5b
jmp 0x2dc62
movzbl 0x16(... | /OLSR[P]OONF/src/libconfig/cfg_validate.c |
cfg_append_printable_line | int
cfg_append_printable_line(struct autobuf *autobuf, const char *fmt, ...) {
unsigned char *_value;
size_t len;
int rv;
va_list ap;
if (autobuf == NULL)
return 0;
_value = (unsigned char *)abuf_getptr(autobuf) + abuf_getlen(autobuf);
len = abuf_getlen(autobuf);
va_start(ap, fmt);
rv = abuf_va... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x2e049
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rs... | /OLSR[P]OONF/src/libconfig/cfg.c |
oonf_cfg_clear_rawdb | int
oonf_cfg_clear_rawdb(void) {
struct cfg_db *db;
/* remember old db */
db = _oonf_raw_db;
/* initialize database */
if ((_oonf_raw_db = cfg_db_add()) == NULL) {
OONF_WARN(LOG_CONFIG, "Cannot create raw configuration database.");
_oonf_raw_db = db;
return -1;
}
/* free old db */
cfg_db_... | pushq %rbx
subq $0x10, %rsp
movq 0x3ec96(%rip), %rbx # 0x6d810
callq 0x2b4b4
movq %rax, 0x3ec8a(%rip) # 0x6d810
testq %rax, %rax
je 0x2eba9
movq %rbx, %rdi
callq 0x2b4e2
movq 0x3ec76(%rip), %rax # 0x6d810
leaq 0x3ec0f(%rip), %rcx # 0x6d7b0
movq %rcx, 0x28(%rax)
xorl %eax, %eax
jmp 0x2ebf0
leaq 0x3ed20(%... | /OLSR[P]OONF/src/libcore/oonf_cfg.c |
oonf_log_updatemask | static INLINE void
oonf_log_mask_clear(uint8_t *mask) {
memset(mask, LOG_SEVERITY_WARN | LOG_SEVERITY_ASSERT, LOG_MAXIMUM_SOURCES);
} | movaps 0x102f8(%rip), %xmm0 # 0x3f150
movaps %xmm0, 0x3eae1(%rip) # 0x6d940
movaps %xmm0, 0x3eaca(%rip) # 0x6d930
movaps %xmm0, 0x3eab3(%rip) # 0x6d920
movaps %xmm0, 0x3ea9c(%rip) # 0x6d910
movaps %xmm0, 0x3ea85(%rip) # 0x6d900
movaps %xmm0, 0x3ea6e(%rip) # 0x6d8f0
movaps %xmm0, 0x3ea57(%rip) # ... | /OLSR[P]OONF/include/oonf/libcore/oonf_logging.h |
apply_log_setting | static void
_apply_log_setting(struct cfg_named_section *named, const char *entry_name, enum oonf_log_severity severity) {
struct cfg_entry *entry;
char *ptr;
size_t i;
entry = cfg_db_get_entry(named, entry_name);
if (entry) {
strarray_for_each_element(&entry->val, ptr) {
for (i = 0; i < oonf_log_g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
addq $0x48, %rdi
callq 0x2780e
testq %rax, %rax
je 0x2f94d
movq %rax, %r14
movq 0x40(%rax), %r15
testq %r15, %r15
je 0x2f94d
movq 0x48(%r14), %rax
addq 0x40(%r14), %rax
cmpq %r15, %rax
jbe 0x2f94d
leaq 0x29e04(%rip), %r12 #... | /OLSR[P]OONF/src/libcore/oonf_logging_cfg.c |
oonf_main | int
oonf_main(int argc, char **argv, const struct oonf_appdata *appdata) {
int return_code;
int result;
/* early initialization */
return_code = 1;
_schema_name = NULL;
_display_schema = false;
_debug_early = false;
_ignore_unknown = false;
/* setup signal handler */
_end_oonf_signal = false;
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movl %edi, %ebp
movq $0x0, 0x3e0f5(%rip) # 0x6dbd8
xorl %ebx, %ebx
movb %bl, 0x3e0f5(%rip) # 0x6dbe0
movb %bl, 0x3e0f0(%rip) # 0x6dbe1
movb %bl, 0x3e0eb(%rip) # 0x6dbe2
leaq 0x3e0fa(%r... | /OLSR[P]OONF/src/libcore/oonf_main.c |
display_schema | static int
display_schema(void) {
struct autobuf log;
int return_code;
return_code = 0;
abuf_init(&log);
if (cfg_cmd_handle_schema(oonf_cfg_get_rawdb(), _schema_name, &log)) {
return_code = -1;
}
if (abuf_getlen(&log) > 0) {
fputs(abuf_getptr(&log), stdout);
}
abuf_free(&log);
return r... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsp, %r14
movq %r14, %rdi
callq 0x271cc
callq 0x2ec06
movq 0x3d843(%rip), %rsi # 0x6dbd8
movq %rax, %rdi
movq %r14, %rdx
callq 0x2af7c
movl %eax, %ebx
cmpq $0x0, 0x8(%r14)
je 0x303bd
movq 0x10(%rsp), %rdi
movq 0x1fc03(%rip), %rax # 0x4ffb8
movq (%rax), %rs... | /OLSR[P]OONF/src/libcore/oonf_main.c |
write_pidfile | static int
_write_pidfile(const char *filename) {
int pid_fd;
char buffer[16];
pid_fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (pid_fd < 0) {
OONF_WARN(LOG_MAIN, "Could not open pidfile '%s': %s (%d)", filename, strerror(errno), errno);
return -1;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x241, %esi # imm = 0x241
movl $0x1a4, %edx # imm = 0x1A4
xorl %eax, %eax
callq 0x114b0
testl %eax, %eax
js 0x30444
movl %eax, %ebp
callq 0x11170
leaq 0x8093(%rip), %rdx # 0x38499
xorl %r14d, %r14d
movq %rsp, %... | /OLSR[P]OONF/src/libcore/oonf_main.c |
mainloop | static int
mainloop(int argc, char **argv, const struct oonf_appdata *appdata) {
int exit_code = 0;
OONF_INFO(LOG_MAIN, "Starting %s", appdata->app_name);
/* enter main loop */
while (oonf_cfg_is_running()) {
/* call event scheduler */
if (_handle_scheduling()) {
exit_code = 1;
break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x3d38f(%rip), %r13 # 0x6d8d0
testb $0x2, 0x1(%r13)
je 0x3057a
leaq 0xf0dd(%rip), %r10 # 0x3f62c
leaq 0xefa8(%rip), %rdx # 0x3f4fe
movl $0x2, %edi
movl $0x1, %esi
movl $0x192, ... | /OLSR[P]OONF/src/libcore/oonf_main.c |
init_plugin | static int
_init_plugin(struct oonf_subsystem *plugin) {
struct oonf_subsystem *dep;
size_t i;
int result;
if (plugin->_initialized) {
return 0;
}
/* mark plugin */
plugin->_dependency_missing = true;
for (i = 0; i < plugin->dependencies_count; i++) {
dep = oonf_subsystem_get(plugin->dependen... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $0x0, 0x58(%rdi)
je 0x30e36
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdi, %r14
movb $0x1, 0x5a(%rdi)
cmpq $0x0, 0x10(%rdi)
je 0x30e99
xorl %r12d, %r12d
leaq 0x3ce62(%rip), %r15 # 0x6dcb0
movq 0x8(%r... | /OLSR[P]OONF/src/libcore/oonf_subsystem.c |
cleanup_plugin | static void
_cleanup_plugin(struct oonf_subsystem *plugin) {
struct oonf_subsystem *rdep;
size_t i;
if (!plugin->_initialized) {
return;
}
/* handle reverse dependencies */
avl_for_each_element(&oonf_plugin_tree, rdep, _node) {
/* look for reverse dependency */
for (i = 0; i < rdep->dependenci... | cmpb $0x1, 0x58(%rdi)
jne 0x312da
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3ca73(%rip), %r15 # 0x6dcb0
movq 0x8(%r15), %rax
cmpq 0x3ca70(%rip), %rax # 0x6dcb8
je 0x31282
cmpq $0x0, -0x60(%r15)
je 0x3127d
leaq -0x70(%r15), %r14
xorl %r12d, %r12d
movq -0x68(%r15), %rax
movq (%... | /OLSR[P]OONF/src/libcore/oonf_subsystem.c |
os_core_linux_create_lockfile | int
os_core_linux_create_lockfile(const char *path) {
int lock_fd;
/* create file for lock */
lock_fd = open(path, O_RDWR | O_CREAT, S_IRWXU);
if (lock_fd == -1) {
return -1;
}
if (flock(lock_fd, LOCK_EX | LOCK_NB)) {
close(lock_fd);
return -1;
}
/* lock will be released when process ends... | pushq %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl $0x42, %esi
movl $0x1c0, %edx # imm = 0x1C0
xorl %eax, %eax
callq 0x114b0
cmpl $-0x1, %eax
je 0x313c7
movl %eax, %ebp
movl %eax, %edi
movl $0x6, %esi
callq 0x114f0
testl %eax, %eax
je 0x313cc
movl %ebp, %edi
callq 0x11290
movl $0xffffffff, %ebx # im... | /OLSR[P]OONF/src/libcore/os_linux/os_core_linux.c |
rfc5497_timetlv_encode | uint8_t
rfc5497_timetlv_encode(uint64_t decoded) {
uint32_t a, b;
/*
* t = (1 + a/8) * 2^b * 1000 / 1024
* = (1000 + 125 * a) * (2^b / 2^10)
* = (1000 + 125 * a) * 2 ^ (b-10)
*/
if (decoded < RFC5497_TIMETLV_MIN) {
return 0;
}
if (decoded > RFC5497_TIMETLV_MAX) {
return 255;
}
b ... | testq %rdi, %rdi
je 0x31456
movb $-0x1, %al
movl $0xdac00000, %ecx # imm = 0xDAC00000
cmpq %rcx, %rdi
ja 0x31458
movl $0xa, %esi
cmpq $0x3e7, %rdi # imm = 0x3E7
jbe 0x31442
cmpq $0x754, %rdi # imm = 0x754
jb 0x31459
movl $0xa, %esi
incl %esi
leaq 0x1(%rdi), %rcx
shrq %rcx
cmpq $0xea6, %rdi ... | /OLSR[P]OONF/src/librfc5444/rfc5444.c |
rfc5444_writer_set_msg_header | void
rfc5444_writer_set_msg_header(struct rfc5444_writer *writer, struct rfc5444_writer_message *msg, bool has_originator,
bool has_hopcount, bool has_hoplimit, bool has_seqno) {
#if WRITER_STATE_MACHINE == true
assert(writer->_state == RFC5444_WRITER_ADD_HEADER);
#endif
msg->has_origaddr = has_originator;
msg... | cmpl $0x3, 0x138(%rdi)
jne 0x32053
movb %dl, 0x67(%rsi)
movb %r8b, 0x65(%rsi)
movb %cl, 0x63(%rsi)
movb %r9b, 0x78(%rsi)
movq $0x6, 0x108(%rdi)
testb %dl, %dl
je 0x3202e
movzbl 0x8(%rdi), %eax
addq $0x6, %rax
movq %rax, 0x108(%rdi)
testb %r8b, %r8b
je 0x3203a
incq 0x108(%rdi)
testb %cl, %cl
je 0x32045
incq 0x108(%rdi)
... | /OLSR[P]OONF/src/librfc5444/rfc5444_msg_generator.c |
close_addrblock | static void
_close_addrblock(struct _rfc5444_internal_addr_compress_session *acs, struct rfc5444_writer *writer,
struct rfc5444_writer_address *last_addr, int common_head) {
int best;
int i, size;
if (common_head > writer->msg_addr_len) {
/* nothing to do */
return;
}
/* check for best compression ... | movzbl 0x8(%rsi), %r9d
cmpl %ecx, %r9d
jl 0x32a7c
pushq %rbx
movslq %ecx, %rax
leaq (%rax,%rax,2), %r10
movl 0x8(%rdi,%r10,8), %eax
leal 0x1(%rcx), %r8d
cmpl %r9d, %r8d
jge 0x32a19
leaq (%rdi,%r10,8), %r10
addq $0x20, %r10
movl %r8d, %r11d
movl (%r10), %ebx
cmpl %eax, %ebx
cmovll %r11d, %ecx
cmovll %ebx, %eax
addq $0x1... | /OLSR[P]OONF/src/librfc5444/rfc5444_msg_generator.c |
rfc5444_writer_forward_msg | enum rfc5444_result
rfc5444_writer_forward_msg(
struct rfc5444_writer *writer, struct rfc5444_reader_tlvblock_context *context, const uint8_t *msg, size_t len)
{
struct rfc5444_writer_target *target;
struct rfc5444_writer_message *rfc5444_msg;
struct rfc5444_writer_forward_handler *handler;
int cnt, hopcount,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x8(%rsp)
cmpl $0x0, 0x138(%rdi)
jne 0x32e56
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r15
addq $0x58, %rdi
addq $0x30, %rsi
callq 0x2780e
testq %rax, %rax
je 0x32bf9
movq %rax, %r13
cmpq $0x0, 0xe8(%rax)
je 0x32e37
movq 0xe... | /OLSR[P]OONF/src/librfc5444/rfc5444_msg_generator.c |
rfc5444_writer_begin_packet | void
_rfc5444_writer_begin_packet(struct rfc5444_writer *writer, struct rfc5444_writer_target *target) {
struct rfc5444_writer_postprocessor *processor;
struct rfc5444_writer_pkthandler *handler;
/* cleanup packet buffer data */
_rfc5444_tlv_writer_init(&target->_pkt, target->packet_size, target->packet_size);... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsi), %rdi
movq 0x8(%rsi), %rdx
movq %rdx, %rsi
callq 0x36100
movq 0x90(%rbx), %r15
movq 0x8(%r15), %rax
cmpq 0x98(%rbx), %rax
je 0x3319d
movq %r15, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq *0x40(%r15)
testb %al, %al
je 0x3319... | /OLSR[P]OONF/src/librfc5444/rfc5444_pkt_generator.c |
rfc5444_print_add | void
rfc5444_print_add(struct rfc5444_print_session *session, struct rfc5444_reader *reader) {
/* memorize reader */
session->_reader = reader;
session->_pkt.start_callback = _cb_print_pkt_start;
session->_pkt.tlv_callback = _cb_print_pkt_tlv;
session->_pkt.end_callback = _cb_print_pkt_end;
rfc5444_reader_... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x178(%rdi)
leaq 0x10(%rdi), %rsi
leaq 0xbc(%rip), %rax # 0x3362c
movq %rax, 0x60(%rdi)
leaq 0x167(%rip), %rax # 0x336e2
movq %rax, 0x70(%rdi)
leaq 0x232(%rip), %rax # 0x337b8
movq %rax, 0x68(%rdi)
movq %rbx, %rdi
xorl %edx, ... | /OLSR[P]OONF/src/librfc5444/rfc5444_print.c |
cb_print_pkt_end | enum rfc5444_result
_cb_print_pkt_end(struct rfc5444_reader_tlvblock_context *context, bool dropped __attribute__((unused)))
{
struct rfc5444_print_session *session;
session = container_of(context->consumer, struct rfc5444_print_session, _pkt);
abuf_puts(session->output, "\t`------------------\n");
if (sessio... | pushq %rbx
movq 0x8(%rdi), %rbx
movq -0x10(%rbx), %rdi
leaq 0xe119(%rip), %rsi # 0x418e1
callq 0x27362
movq -0x8(%rbx), %rax
testq %rax, %rax
je 0x337df
addq $-0x10, %rbx
movq %rbx, %rdi
callq *%rax
xorl %eax, %eax
popq %rbx
retq
| /OLSR[P]OONF/src/librfc5444/rfc5444_print.c |
rfc5444_print_direct | enum rfc5444_result
rfc5444_print_direct(struct autobuf *out, void *buffer, size_t length)
{
struct rfc5444_reader reader;
struct rfc5444_print_session session;
enum rfc5444_result result;
memset(&reader, 0, sizeof(reader));
memset(&session, 0, sizeof(session));
session.output = out;
rfc5444_reader_ini... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x40(%r12)
movaps ... | /OLSR[P]OONF/src/librfc5444/rfc5444_print.c |
print_raw_tlvblock | static int
_print_raw_tlvblock(struct autobuf *out, const char *prefix, uint8_t *blockptr, size_t *idx, size_t length) {
char valueprefix[128];
uint16_t blocklength, tlv_len, tlv_singlelength;
uint8_t *tlvptr;
size_t idx2;
uint8_t tlv_flags, startidx, endidx;
if (2 > length) {
return -1;
}
abuf_ap... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq $0x2, %r8
jb 0x34590
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
leaq 0xd04f(%rip), %rsi # 0x41567
movq %r13, %rdx
xorl %eax, %eax
callq 0x272d1... | /OLSR[P]OONF/src/librfc5444/rfc5444_print.c |
consumer_avl_comp | static int
_consumer_avl_comp(const void *k1, const void *k2) {
const struct rfc5444_reader_tlvblock_consumer *c1 = k1;
const struct rfc5444_reader_tlvblock_consumer *c2 = k2;
if (c1->order > c2->order) {
return 1;
}
if (c1->order < c2->order) {
return -1;
}
if (c1->addrblock_consumer && !c2->add... | movl 0x38(%rsi), %ecx
movl $0x1, %eax
cmpl %ecx, 0x38(%rdi)
jle 0x3496e
retq
jge 0x34976
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
movb 0x3e(%rdi), %cl
cmpb $0x1, %cl
jne 0x34988
cmpb $0x1, 0x3e(%rsi)
jne 0x3496d
testb %cl, %cl
jne 0x34993
cmpb $0x0, 0x3e(%rsi)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF... | /OLSR[P]OONF/src/librfc5444/rfc5444_reader.c |
rfc5444_reader_handle_packet | enum rfc5444_result
rfc5444_reader_handle_packet(struct rfc5444_reader *parser, const uint8_t *buffer, size_t length)
{
struct rfc5444_reader_tlvblock_context context;
struct avl_tree entries;
struct rfc5444_reader_tlvblock_consumer *consumer, *last_started;
const uint8_t *ptr, *eob;
bool has_tlv;
uint8_t f... | movl $0xfffffff0, %eax # imm = 0xFFFFFFF0
cmpq $0xffff, %rdx # imm = 0xFFFF
ja 0x356c3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbp
movq %rsi, (%rsp)
leaq 0x70(%rsp), %r13
xorl %r15d, %r15d
mo... | /OLSR[P]OONF/src/librfc5444/rfc5444_reader.c |
schedule_tlvblock | static enum rfc5444_result
_schedule_tlvblock(struct rfc5444_reader_tlvblock_consumer *consumer, struct rfc5444_reader_tlvblock_context *context,
struct avl_tree *entries, uint8_t idx) {
struct rfc5444_reader_tlvblock_entry *tlv = NULL, *nexttlv = NULL;
struct rfc5444_reader_tlvblock_consumer_entry *cons_entry;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x8(%rsp)
cmpl $0x0, 0x18(%rdx)
je 0x35b52
movq (%rdx), %r13
jmp 0x35b55
xorl %r13d, %r13d
movq 0x8(%rsp), %rsi
leaq 0x40(%rsi), %rax
movq 0x40(%rsi), %r14
cmpq %rax, %r14
jne 0x35b76
movq 0x8(%rsp), %rsi... | /OLSR[P]OONF/src/librfc5444/rfc5444_reader.c |
schedule_end_message_cbs | static enum rfc5444_result
schedule_end_message_cbs(struct rfc5444_reader_tlvblock_context *tlv_context,
struct rfc5444_reader_tlvblock_consumer *first, struct rfc5444_reader_tlvblock_consumer *last,
enum rfc5444_result result) {
struct rfc5444_reader_tlvblock_consumer *consumer;
enum rfc5444_result r;
tlv_c... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl $0x1, 0x10(%rdi)
cmpq %rsi, (%rdx)
je 0x360f2
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x58(%r14)
je 0x360e9
cmpb $0x0, 0x3e(%r14)
jne 0x360e9
cmpb $0x0, 0x3c(%r14)
jne 0x360d0
movb 0x3d(%r14), %al
cmpb 0x30(%r12), %al
jne 0x3... | /OLSR[P]OONF/src/librfc5444/rfc5444_reader.c |
rfc5444_tlv_writer_init | void
_rfc5444_tlv_writer_init(struct rfc5444_tlv_writer_data *data, size_t max, size_t mtu __attribute__((unused))) {
data->header = 0;
data->added = 0;
data->allocated = 0;
data->set = 0;
data->max = max;
#if DEBUG_CLEANUP == true
memset(data->buffer, 0, mtu);
#endif
} | xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq %rsi, 0x28(%rdi)
retq
| /OLSR[P]OONF/src/librfc5444/rfc5444_tlv_writer.c |
rfc5444_writer_cleanup | void
rfc5444_writer_cleanup(struct rfc5444_writer *writer) {
struct rfc5444_writer_message *msg, *safe_msg;
struct rfc5444_writer_pkthandler *pkt, *safe_pkt;
struct rfc5444_writer_content_provider *provider, *safe_prv;
struct rfc5444_writer_tlvtype *tlvtype, *safe_tt;
struct rfc5444_writer_target *interf, *sa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3660e
movq %rdi, %rbx
cmpl $0x0, 0x138(%rdi)
jne 0x3662d
movq 0x80(%rbx), %rsi
movq 0x8(%rsi), %rax
cmpq 0x88(%rbx), %rax
je 0x364e2
movq (%rsi), %r14
movq %rbx, %rdi
callq 0x3664c
movq 0x8(%r14), %rax
movq %r14, %rsi
jmp 0x364c5
movq 0xe0(%rb... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
rfc5444_writer_unregister_target | void
rfc5444_writer_unregister_target(
struct rfc5444_writer *writer __attribute__((unused)), struct rfc5444_writer_target *interf) {
#if WRITER_STATE_MACHINE == true
assert(writer->_state == RFC5444_WRITER_NONE);
#endif
/* remove interface from writer */
if (list_is_node_added(&interf->_target_node)) {
li... | cmpl $0x0, 0x138(%rdi)
jne 0x366c5
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x366c4
cmpq $0x0, 0x38(%rsi)
je 0x366c4
movq 0x38(%rsi), %rcx
addq $0x30, %rsi
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
pushq %rax
leaq 0x9f94(%rip), %rdi # 0x40661
leaq 0xb8a3(%rip), %rsi ... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
rfc5444_writer_unregister_content_provider | void
rfc5444_writer_unregister_content_provider(struct rfc5444_writer *writer, struct rfc5444_writer_content_provider *cpr,
struct rfc5444_writer_tlvtype *addrtlvs, size_t addrtlvs_count) {
size_t i;
#if WRITER_STATE_MACHINE == true
assert(writer->_state == RFC5444_WRITER_NONE);
#endif
if (!avl_is_node_added(&... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x0, 0x138(%rdi)
jne 0x367d6
movq %rsi, %r14
cmpq $0x0, 0x20(%rsi)
je 0x367cc
cmpq $0x0, 0x28(%r14)
je 0x367cc
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x20(%r14), %r13
testq %rcx, %rcx
je 0x367a7
movq %rdx, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x366e5
addq... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
rfc5444_writer_register_message | struct rfc5444_writer_message *
rfc5444_writer_register_message(struct rfc5444_writer *writer, uint8_t msgid, bool if_specific) {
struct rfc5444_writer_message *msg;
#if WRITER_STATE_MACHINE == true
assert(writer->_state == RFC5444_WRITER_NONE);
#endif
msg = _get_message(writer, msgid);
if (msg == NULL) {
... | pushq %rbx
cmpl $0x0, 0x138(%rdi)
jne 0x36d4e
movl %edx, %ebx
movzbl %sil, %esi
callq 0x36abd
testq %rax, %rax
je 0x36d41
cmpb $0x0, 0x60(%rax)
je 0x36d45
xorl %eax, %eax
jmp 0x36d4c
movb $0x1, 0x60(%rax)
movb %bl, 0x61(%rax)
popq %rbx
retq
leaq 0x990c(%rip), %rdi # 0x40661
leaq 0xb21b(%rip), %rsi # 0x41f77
l... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
rfc5444_writer_register_target | void
rfc5444_writer_register_target(struct rfc5444_writer *writer, struct rfc5444_writer_target *interf) {
#if WRITER_STATE_MACHINE == true
assert(writer->_state == RFC5444_WRITER_NONE);
#endif
assert(interf->packet_buffer != NULL && interf->packet_size > 0);
interf->_pkt.buffer = interf->packet_buffer;
_rfc5... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x138(%rdi)
jne 0x36f3a
movq %rsi, %r14
movq (%rsi), %rax
testq %rax, %rax
je 0x36f1b
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x36f1b
movq %rdi, %rbx
leaq 0x48(%r14), %rdi
movq %rax, 0x48(%r14)
movq %rdx, %rsi
callq 0x36100
movb $0x1, 0x40(%r14)
leaq 0xe0(%rbx), %rax
leaq 0x... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
mbedtls_ecp_curve_info_from_grp_id | const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_grp_id( mbedtls_ecp_group_id grp_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->grp_id == grp_id )
... | leaq 0x35c3d(%rip), %rax # 0x43a00
movl $0x5, %ecx
cmpl %edi, %ecx
je 0xddd9
movl 0x10(%rax), %ecx
addq $0x10, %rax
testl %ecx, %ecx
jne 0xddc8
xorl %eax, %eax
retq
| /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_ecp_curve_info_from_name | const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_name( const char *name )
{
const mbedtls_ecp_curve_info *curve_info;
if( name == NULL )
return( NULL );
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
if... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xde21
movq %rdi, %r14
leaq 0x35bf9(%rip), %rbx # 0x43a00
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xc160
testl %eax, %eax
je 0xde23
cmpl $0x0, 0x10(%rbx)
leaq 0x10(%rbx), %rbx
jne 0xde07
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_ecp_point_write_binary | int mbedtls_ecp_point_write_binary( const mbedtls_ecp_group *grp,
const mbedtls_ecp_point *P,
int format, size_t *olen,
unsigned char *buf, size_t buflen )
{
int ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %rbp
movq %rcx, %r13
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rdi
callq 0x1a9a7
cmpq $0x0, 0x60(%r14)
je 0xe216
movq %rbp, 0x8(%rsp)
movl $0xffffb180, %ebp # imm = 0xFFFFB180
cmpq $0x0, 0... | /ARMmbed[P]mbed-crypto/library/ecp.c |
ecp_select_comb | static int ecp_select_comb( const mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
const mbedtls_ecp_point T[], unsigned char T_size,
unsigned char i )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
unsigned char ii, j;
/* Ignore the "sign" bit and s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
testl %ecx, %ecx
je 0x11463
movq %rdx, %r12
movl 0x4(%rsp), %eax
shrb %al
andb $0x3f, %al
leaq 0x18(%r14), %rdx
movq %rdx, 0x10(%rsp)
movzbl %al, %r15d
movzbl %cl, %ebx
xorl %r13d... | /ARMmbed[P]mbed-crypto/library/ecp.c |
ecp_mod_p521 | static int ecp_mod_p521( mbedtls_mpi *N )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t i;
mbedtls_mpi M;
mbedtls_mpi_uint Mp[P521_WIDTH + 1];
/* Worst case for the size of M is when mbedtls_mpi_uint is 16 bits:
* we need to hold bits 513 to 1056, which is 34 limbs, that is
* P... | movq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpq $0x9, %rcx
jb 0x12856
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, (%r14)
addq $-0x8, %rcx
cmpq $0xa, %rcx
movl $0xa, %edx
cmovbq %rcx, %rdx
movq %rdx, 0x8(%r14)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x10(%r14)
movq 0x10(%rbx), %rsi
addq $0x... | /ARMmbed[P]mbed-crypto/library/ecp_curves.c |
ecp_mod_koblitz | static inline int ecp_mod_koblitz( mbedtls_mpi *N, mbedtls_mpi_uint *Rp, size_t p_limbs,
size_t adjust, size_t shift, mbedtls_mpi_uint mask )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t i;
mbedtls_mpi M, R;
mbedtls_mpi_uint Mp[P_KOBLITZ_MAX + P_KOBLITZ_R ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x8(%rdi), %r12
xorl %eax, %eax
cmpq %rdx, %r12
jb 0x12c1e
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
movq %r9, 0x20(%rsp)
movl $0x1, %eax
movl %eax, 0x38(%rsp)
movq %rsi, 0x48(%rsp)
movq $0x1, 0x40(%rsp)
movl %eax, 0x8(%rsp)
l... | /ARMmbed[P]mbed-crypto/library/ecp_curves.c |
mbedtls_pk_check_pair | int mbedtls_pk_check_pair( const mbedtls_pk_context *pub, const mbedtls_pk_context *prv )
{
PK_VALIDATE_RET( pub != NULL );
PK_VALIDATE_RET( prv != NULL );
if( pub->pk_info == NULL ||
prv->pk_info == NULL )
{
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
}
if( prv->pk_info->check_pa... | movq (%rdi), %rdx
movl $0xffffc180, %eax # imm = 0xFFFFC180
testq %rdx, %rdx
je 0x130ec
movq (%rsi), %r8
testq %r8, %r8
je 0x130ec
movq 0x40(%r8), %rcx
testq %rcx, %rcx
je 0x130dc
cmpl $0x5, (%r8)
jne 0x130e2
movl $0xffffc100, %eax # imm = 0xFFFFC100
cmpl $0x1, (%rdx)
jne 0x130ec
movq 0x8(%rdi), %rdi
movq 0... | /ARMmbed[P]mbed-crypto/library/pk.c |
rsa_encrypt_wrap | static int rsa_encrypt_wrap( void *ctx,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
callq 0x15736
movq %rax, (%rbp)
cmpq %r13, %rax
jbe 0x13306
movl $0xffffbc00, %eax # imm = 0xFFFFBC00
jmp 0x13324
movq 0x48(%rsp), %rdx
movq 0x... | /ARMmbed[P]mbed-crypto/library/pk_wrap.c |
eckey_sign_wrap | static int eckey_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x1f24e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1f1ea
movl %eax, %r1... | /ARMmbed[P]mbed-crypto/library/pk_wrap.c |
pk_get_rsapubkey | static int pk_get_rsapubkey( unsigned char **p,
const unsigned char *end,
mbedtls_rsa_context *rsa )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %rdx
movl $0x30, %ecx
callq 0x19e01
testl %eax, %eax
je 0x14061
movl %eax, %ebp
addl $0xffffc500, %ebp # imm = 0xFFFFC500
jmp 0x14073
movq (%r14), %rax
addq 0x30(%rsp), %rax
movl $0xffffc4... | /ARMmbed[P]mbed-crypto/library/pkparse.c |
pk_get_ecpubkey | static int pk_get_ecpubkey( unsigned char **p, const unsigned char *end,
mbedtls_ecp_keypair *key )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
if( ( ret = mbedtls_ecp_point_read_binary( &key->grp, &key->Q,
(const unsigned char *) *p, end - *p ) ) == 0 )
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x110(%rdx), %r12
movq (%rdi), %rdx
movq %rsi, %rcx
subq %rdx, %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0xe2d9
testl %eax, %eax
jne 0x146a5
movq %r15, %rdi
movq %r12, %rsi
callq 0xf3d4
movq %rbx, (%r14)
addq $0... | /ARMmbed[P]mbed-crypto/library/pkparse.c |
mbedtls_rsa_export_crt | int mbedtls_rsa_export_crt( const mbedtls_rsa_context *ctx,
mbedtls_mpi *DP, mbedtls_mpi *DQ, mbedtls_mpi *QP )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
int is_priv;
RSA_VALIDATE_RET( ctx != NULL );
/* Check if key is private or public */
is_priv =
mbed... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
addq $0x10, %rdi
xorl %esi, %esi
callq 0x1b8ef
movl $0xffffbf80, %ebx # imm = 0xFFFFBF80
testl %eax, %eax
je 0x156f3
leaq 0x58(%r15), %rdi
xorl %esi, %esi
callq 0x1b8ef
testl %eax, %eax
je 0x156f... | /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_free | void mbedtls_rsa_free( mbedtls_rsa_context *ctx )
{
if( ctx == NULL )
return;
mbedtls_mpi_free( &ctx->Vi );
mbedtls_mpi_free( &ctx->Vf );
mbedtls_mpi_free( &ctx->RN );
mbedtls_mpi_free( &ctx->D );
mbedtls_mpi_free( &ctx->Q );
mbedtls_mpi_free( &ctx->P );
mbedtls_mpi_free( &ct... | testq %rdi, %rdi
je 0x15bef
pushq %rbx
movq %rdi, %rbx
addq $0x118, %rdi # imm = 0x118
callq 0x1a48e
leaq 0x130(%rbx), %rdi
callq 0x1a48e
leaq 0xd0(%rbx), %rdi
callq 0x1a48e
leaq 0x40(%rbx), %rdi
callq 0x1a48e
leaq 0x70(%rbx), %rdi
callq 0x1a48e
leaq 0x58(%rbx), %rdi
callq 0x1a48e
leaq 0x28(%rbx), %rdi
callq... | /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_rsaes_oaep_decrypt | int mbedtls_rsa_rsaes_oaep_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
const unsigned char *label, size_t label_len,
si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp # imm = 0x488
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x1, %ecx
jne 0x168a6
movl $0xffffbf80, %ebp # imm = 0xFFFFBF80
cmpl $0x1, 0x148(%r14)
jne 0x169ef
movq 0x8(%r14), %rcx
leaq -0x401(%r... | /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_pkcs1_decrypt | int mbedtls_rsa_pkcs1_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t *olen,
const unsigned char *input,
unsigned char *output,
... | movq %r9, %r10
movq %r8, %rax
movl 0x148(%rdi), %r8d
cmpl $0x1, %r8d
je 0x16d88
testl %r8d, %r8d
jne 0x16da5
movq %rax, %r8
movq %r10, %r9
jmp 0x16b27
pushq %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq 0x18(%rsp)
pushq 0x18(%rsp)
pushq %r10
pushq %rax
callq 0x16871
addq $0x20, %rsp
popq %rcx
retq
movl $0xffffbf00, %eax ... | /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_rsassa_pss_verify | int mbedtls_rsa_rsassa_pss_verify( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
unsigned int hashlen,
... | pushq %rax
movl 0x14c(%rdi), %eax
testl %eax, %eax
cmovel %r8d, %eax
pushq 0x18(%rsp)
pushq $-0x1
pushq %rax
pushq 0x28(%rsp)
callq 0x1739a
addq $0x20, %rsp
popq %rcx
retq
| /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_pkcs1_verify | int mbedtls_rsa_pkcs1_verify( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned... | movl 0x148(%rdi), %eax
cmpl $0x1, %eax
je 0x177df
testl %eax, %eax
jne 0x17802
jmp 0x1769e
pushq %rax
movl 0x14c(%rdi), %eax
testl %eax, %eax
cmovel %r8d, %eax
pushq 0x18(%rsp)
pushq $-0x1
pushq %rax
pushq 0x28(%rsp)
callq 0x1739a
addq $0x20, %rsp
popq %rcx
retq
movl $0xffffbf00, %eax # imm = 0xFFFFBF00
retq
| /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_mpi_gen_prime | int mbedtls_mpi_gen_prime( mbedtls_mpi *X, size_t nbits, int flags,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
#ifdef MBEDTLS_HAVE_INT64
// ceil(2^63.5)
#define CEIL_MAXUINT_DIV_SQRT2 0xb504f333f9de6485ULL
#else
// ceil(2^31.5)
#define CEIL_MAXUINT_DIV_SQRT2 0xb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq -0x2001(%rsi), %rax
movl $0xfffffffc, %ebp # imm = 0xFFFFFFFC
cmpq $-0x1ffe, %rax # imm = 0xE002
jb 0x1e20c
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, 0x48(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rsp)
movq %rsi, ... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_ecdsa_genkey | int mbedtls_ecdsa_genkey( mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret = 0;
ECDSA_VALIDATE_RET( ctx != NULL );
ECDSA_VALIDATE_RET( f_rng != NULL );
ret = mbedtls_ecp_group_load( &ctx->grp, gid );
if(... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x11498
testl %eax, %eax
je 0x1f1c9
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf8(%r15), %rsi
leaq 0x110(%r15), %rdx
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0xff03
| /ARMmbed[P]mbed-crypto/library/ecdsa.c |
mbedtls_md_info_from_type | const mbedtls_md_info_t *mbedtls_md_info_from_type( mbedtls_md_type_t md_type )
{
switch( md_type )
{
#if defined(MBEDTLS_MD2_C)
case MBEDTLS_MD_MD2:
return( &mbedtls_md2_info );
#endif
#if defined(MBEDTLS_MD4_C)
case MBEDTLS_MD_MD4:
return( &mbedtls_md4_info );
#endif
#i... | addl $-0x3, %edi
cmpl $0x6, %edi
ja 0x1fdc2
movl %edi, %eax
leaq 0x23fab(%rip), %rcx # 0x43d68
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /ARMmbed[P]mbed-crypto/library/md.c |
mbedtls_md_finish | int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
{
if( ctx == NULL || ctx->md_info == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
switch( ctx->md_info->type )
{
#if defined(MBEDTLS_MD2_C)
case MBEDTLS_MD_MD2:
return( mbedtls_md2_finish_ret( ctx->md_c... | testq %rdi, %rdi
je 0x20134
movq (%rdi), %rax
testq %rax, %rax
je 0x20134
movl 0x8(%rax), %eax
addl $-0x3, %eax
cmpl $0x6, %eax
ja 0x20134
leaq 0x1332a(%rip), %rcx # 0x3344c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
jmp 0x2555c
movl $0xffffaf00, %eax # imm = 0xFFFFAF00
retq
mo... | /ARMmbed[P]mbed-crypto/library/md.c |
pem_get_iv | static int pem_get_iv( const unsigned char *s, unsigned char *iv,
size_t iv_len )
{
size_t i, j, k;
memset( iv, 0, iv_len );
for( i = 0; i < iv_len * 2; i++, s++ )
{
if( *s >= '0' && *s <= '9' ) j = *s - '0'; else
if( *s >= 'A' && *s <= 'F' ) j = *s - '7'; else
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rsi, %rdi
xorl %esi, %esi
callq 0xc110
testq %rbx, %rbx
je 0x21dde
movl $0xffffffa9, %ecx # imm = 0xFFFFFFA9
addq %rbx, %rbx
cmpq $0x1, %rbx
adcq $0x0, %rbx
xorl %eax, %eax
leaq 0x27(%rcx),... | /ARMmbed[P]mbed-crypto/library/pem.c |
mbedtls_pkcs5_self_test | int mbedtls_pkcs5_self_test( int verbose )
{
mbedtls_md_context_t sha1_ctx;
const mbedtls_md_info_t *info_sha1;
int ret, i;
unsigned char key[64];
mbedtls_md_init( &sha1_ctx );
info_sha1 = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
if( info_sha1 == NULL )
{
ret = 1;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
callq 0x1fdc5
movl $0x4, %edi
callq 0x1fdac
testq %rax, %rax
je 0x2308f
leaq 0x8(%rsp), %rdi
movl $0x1, %ebx
movq %rax, %rsi
movl $0x1, %edx
callq 0x1ff01
testl %eax, %eax
jne 0x230b4
leaq 0x20(%rsp),... | /ARMmbed[P]mbed-crypto/library/pkcs5.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 %rbx
movl $0x1, %edi
movl $0x108, %esi # imm = 0x108
callq 0xc150
movq %rax, %rbx
testq %rax, %rax
je 0x2ad84
movq %rbx, %rdi
callq 0x28f94
movq %rbx, %rax
popq %rbx
retq
| /ARMmbed[P]mbed-crypto/library/cipher_wrap.c |
mbedtls_des3_crypt_ecb | int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movl (%rsi), %eax
movl 0x4(%rsi), %ecx
bswapl %eax
bswapl %ecx
movl %eax, %edx
shrl $0x4, %edx
xorl %ecx, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %ecx
shll $0x4, %edx
xorl %eax, %edx
movl %edx, %esi
shrl $0x10... | /ARMmbed[P]mbed-crypto/library/des.c |
mbedtls_blowfish_crypt_ctr | int mbedtls_blowfish_crypt_ctr( mbedtls_blowfish_context *ctx,
size_t length,
size_t *nc_off,
unsigned char nonce_counter[MBEDTLS_BLOWFISH_BLOCKSIZE],
unsigned char stream_block[MBEDTLS_BLOWFISH_BLOCKSIZE],
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq (%rdx), %rbx
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
cmpq $0x7, %rbx
ja 0x2d8d0
movq %rsi, %r13
movq %rdx, 0x8(%rsp)
testq %rsi, %rsi
je 0x2d8c6
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq 0x50(%... | /ARMmbed[P]mbed-crypto/library/blowfish.c |
mbedtls_camellia_self_test | int mbedtls_camellia_self_test( int verbose )
{
int i, j, u, v;
unsigned char key[32];
unsigned char buf[64];
unsigned char src[16];
unsigned char dst[16];
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char iv[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
size_t offset, len;
unsigned ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movl %edi, %r13d
pxor %xmm0, %xmm0
leaq 0x50(%rsp), %rax
movdqa %xmm0, (%rax)
movdqa %xmm0, 0x10(%rax)
leaq 0xa513(%rip), %r12 # 0x38d20
leaq 0x9f7c(%rip), %rbp # 0x38790
xorl %r14d, %r14d
movl %edi, 0... | /ARMmbed[P]mbed-crypto/library/camellia.c |
chacha20_block | static void chacha20_block( const uint32_t initial_state[16],
unsigned char keystream[64] )
{
uint32_t working_state[16];
size_t i;
memcpy( working_state,
initial_state,
CHACHA20_BLOCK_SIZE_BYTES );
for( i = 0U; i < 10U; i++ )
chacha20_inner_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x60(%rsp)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x20(%rdi), %xmm2
movq %rdi, 0x58(%rsp)
movups 0x30(%rdi), %xmm3
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm3, 0x40(%rsp)
movaps %xmm2, 0x30(%rs... | /ARMmbed[P]mbed-crypto/library/chacha20.c |
mbedtls_chachapoly_encrypt_and_tag | int mbedtls_chachapoly_encrypt_and_tag( mbedtls_chachapoly_context *ctx,
size_t length,
const unsigned char nonce[12],
const unsigned char *aad,
size_t aad_len,... | subq $0x18, %rsp
movq %r8, %rax
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq %r9, (%rsp)
xorl %esi, %esi
movq %rax, %r9
callq 0x2ff7e
addq $0x18, %rsp
retq
| /ARMmbed[P]mbed-crypto/library/chachapoly.c |
mbedtls_chachapoly_auth_decrypt | int mbedtls_chachapoly_auth_decrypt( mbedtls_chachapoly_context *ctx,
size_t length,
const unsigned char nonce[12],
const unsigned char *aad,
size_t aad_len,
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %r15
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rbx
movq 0x38(%rsp), %r14
subq $0x8, %rsp
leaq 0x8(%rsp), %rax
movl $0x1, %esi
movq %rbx, %rdx
pushq %rax
pushq %r14
pushq 0x48(%rsp)
callq 0x2ff7e
addq $0x20, %rsp
testl %eax, %eax
jne 0x300cc
pxor... | /ARMmbed[P]mbed-crypto/library/chachapoly.c |
mbedtls_poly1305_self_test | int mbedtls_poly1305_self_test( int verbose )
{
unsigned char mac[16];
unsigned i;
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
for( i = 0U; i < 2U; i++ )
{
if( verbose != 0 )
mbedtls_printf( " Poly1305 test %u ", i );
ret = mbedtls_poly1305_mac( test_keys[i],
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movb $0x1, %r15b
movq %rsp, %r14
leaq 0x9267(%rip), %r12 # 0x39a60
xorl %r13d, %r13d
testl %ebx, %ebx
je 0x30811
leaq 0x91e9(%rip), %rdi # 0x399f0
movl %r13d, %esi
xorl %eax, %eax
callq 0xc0c0
movq %r13, %rdi
sh... | /ARMmbed[P]mbed-crypto/library/poly1305.c |
test | int test(char *URL)
{
CURLcode res;
CURL *curl;
if(!strcmp(URL, "check")) {
/* used by the test script to ask if we can run this test or not */
if(rlimit(FALSE)) {
fprintf(stdout, "rlimit problem: %s\n", msgbuff);
return 1;
}
return 0; /* sure, run this! */
}
if(rlimit(TRUE)) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0xd49(%rip), %rsi # 0x3004
callq 0x2130
testl %eax, %eax
je 0x230b
movl $0x1, %edi
callq 0x23c0
movl $0x7e, %ebx
testl %eax, %eax
jne 0x23b8
movl $0x3, %edi
callq 0x2150
testl %eax, %eax
je 0x2342
movq 0x2cf0(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0x... | /nomaster[P]curl/tests/libtest/lib537.c |
close_file_descriptors | static void close_file_descriptors(void)
{
for(num_open.rlim_cur = 0;
num_open.rlim_cur < num_open.rlim_max;
num_open.rlim_cur++)
if(fd[num_open.rlim_cur] > 0)
close(fd[num_open.rlim_cur]);
free(fd);
fd = NULL;
} | pushq %rax
movq $0x0, 0x254f(%rip) # 0x5200
cmpq $0x0, 0x254f(%rip) # 0x5208
je 0x2cea
xorl %eax, %eax
movq 0x254c(%rip), %rcx # 0x5210
movl (%rcx,%rax,4), %edi
testl %edi, %edi
jle 0x2cd0
callq 0x21a0
movq 0x2529(%rip), %rax # 0x5200
incq %rax
movq %rax, 0x251f(%rip) # 0x5200
cmpq 0x2520(%rip), %ra... | /nomaster[P]curl/tests/libtest/lib537.c |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | testl %edi, %edi
jns 0x20b0
pushq %rax
callq 0x2030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| /nomaster[P]curl/tests/libtest/first.c |
hexdump | char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
msnprintf(p, 4, "%02x ", buffer[i]);
return dump;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0xc8, %rsi
jbe 0x2de3
xorl %ebx, %ebx
jmp 0x2e2d
movq %rsi, %r14
testq %rsi, %rsi
je 0x2e26
movq %rdi, %r15
leaq 0x243b(%rip), %rbx # 0x5230
leaq 0x53b(%rip), %r12 # 0x3337
xorl %ebp, %ebp
movq %rbx, %r13
movzbl (%r15,%rbp), %... | /nomaster[P]curl/tests/libtest/first.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x381(%rip), %rsi # 0x31cf
movl $0x6, %edi
callq 0x20a0
cmpl $0x1, %ebp
jg 0x2e81
movq 0x217c(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0x4cf(%rip), %rsi # 0x333d
xorl %eax, %eax
callq 0x20f0
movl $0x1, %eax
addq $0x8, %rsp
popq %r... | /nomaster[P]curl/tests/libtest/first.c |
curlx_ultouc | unsigned char curlx_ultouc(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR);
return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
#ifdef __INTEL_... | movq %rdi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_uztoui | unsigned int curlx_uztoui(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT);
#endif
return (unsigned int)(uznum & (size_t) CURL_MASK_UINT);
#i... | movq %rdi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_sltosi | int curlx_sltosi(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
#endif
return (int)(slnum &... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_sltous | unsigned short curlx_sltous(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(slnum & (long) CURL_M... | movq %rdi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.