name string | code string | asm string | file string |
|---|---|---|---|
cb_neighbor_remove | static void
_cb_neighbor_remove(void *ptr) {
struct nhdp_neighbor *neigh;
struct olsrv2_tc_node *tc_node;
neigh = ptr;
if (netaddr_is_unspec(&neigh->originator)) {
return;
}
tc_node = olsrv2_tc_node_get(&neigh->originator);
if (!tc_node) {
return;
}
tc_node->direct_neighbor = false;
if ... | pushq %rax
testq %rdi, %rdi
je 0x362d7
movq %rdi, %rsi
cmpb $0x0, 0x10(%rdi)
je 0x362d7
leaq 0x68431(%rip), %rdi # 0x9e6f0
callq 0x424c4
testq %rax, %rax
je 0x362d7
movb $0x0, -0xb8(%rax)
cmpq $0x0, -0x58(%rax)
je 0x362d9
popq %rax
retq
addq $-0x150, %rax # imm = 0xFEB0
movq %rax, %rdi
popq %rax
jmp 0x35d... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_tc.c |
olsrv2_writer_init | int
olsrv2_writer_init(struct oonf_rfc5444_protocol *protocol) {
_protocol = protocol;
_olsrv2_message = rfc5444_writer_register_message(&_protocol->writer, RFC7181_MSGTYPE_TC, false);
if (_olsrv2_message == NULL) {
OONF_WARN(LOG_OLSRV2, "Could not register OLSRV2 TC message");
return -1;
}
_olsrv2_... | pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x68438(%rip) # 0x9e740
addq $0xc0, %rdi
pushq $0x1
popq %rsi
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x50985
movq %rax, 0x68426(%rip) # 0x9e748
testq %rax, %rax
je 0x363d9
leaq 0xef(%rip), %rcx # 0x36421
movq %rcx, 0xd8(%rax)
leaq 0x192(%rip), %rcx # 0x364d2
mo... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_writer.c |
cb_addAddresses | static void
_cb_addAddresses(struct rfc5444_writer *writer) {
struct rfc5444_writer_address *addr;
struct nhdp_neighbor *neigh;
struct nhdp_naddr *naddr;
struct nhdp_domain *domain;
struct olsrv2_lan_entry *lan;
struct olsrv2_lan_domaindata *lan_data;
bool any_advertised;
uint8_t nbr_addrtype_value;
u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
xorl %eax, %eax
movq %rdi, 0x8(%rsp)
cmpb $0x4, 0x8(%rdi)
setne %al
leal 0x2(,%rax,8), %ebp
callq 0x2a4bd
movq %rax, %r15
movl %ebp, 0x10(%rsp)
movq (%r15), %r15
movq 0x8(%r15), %rbx
callq 0x2a4bd
cmpq 0x8(%rax), %rbx
je 0x36c42
cmpl $0x... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_writer.c |
apply_lan_data | static void
_apply_lan_data(struct _lan_data *data, bool add) {
struct nhdp_domain *domain;
if (netaddr_is_unspec(&data->prefix.src)) {
switch (netaddr_get_address_family(&data->prefix.dst)) {
case AF_INET:
memcpy(&data->prefix.src, &NETADDR_IPV4_ANY, sizeof(data->prefix.src));
break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x22(%rdi)
jne 0x37879
leaq 0x12(%rbx), %rax
movzbl 0x10(%rbx), %ecx
cmpl $0xa, %ecx
je 0x37864
cmpl $0x2, %ecx
jne 0x378f0
leaq 0x248ec(%rip), %rcx # 0x5c14e
jmp 0x3786b
leaq 0x248f5(%rip), %rcx # 0x5c160
movzwl 0... | /OLSR[P]OONF/src/olsrv2/olsrv2_lan/olsrv2_lan.c |
cb_netjsoninfo | static enum oonf_telnet_result
_cb_netjsoninfo(struct oonf_telnet_data *con) {
struct json_session session;
struct autobuf out;
const char *ptr, *next;
if (abuf_init(&out)) {
return TELNET_RESULT_INTERNAL_ERROR;
}
json_init_session(&session, &out);
next = con->parameter;
if (next && *next) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0x41ea0
testl %eax, %eax
je 0x3795d
pushq $0x2
popq %rax
jmp 0x37a78
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x431f4
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x37a58
cmpb $0x0, (%r14)
je 0x37a58
leaq 0x21f... | /OLSR[P]OONF/src/olsrv2/netjsoninfo/netjsoninfo.c |
print_routing_tree | static void
_print_routing_tree(struct json_session *session, struct nhdp_domain *domain, int af_type) {
struct olsrv2_routing_entry *rtentry;
const struct netaddr *originator;
char ibuf[IF_NAMESIZE];
struct nhdp_metric_str mbuf;
struct domain_id_str dbuf;
struct _node_id_str idbuf;
originator = olsrv2_o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %edi
callq 0x3323f
movq %rax, %r12
movzbl 0x10(%rax), %eax
cmpl %ebp, %eax
jne 0x390c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x43253
leaq 0x24b04(%rip),... | /OLSR[P]OONF/src/olsrv2/netjsoninfo/netjsoninfo.c |
cleanup | static void
_cleanup(void) {
struct nhdp_interface *nhdp_if, *nhdp_if_it;
struct _nhdp_if_autoll4 *auto_ll4;
avl_for_each_element_safe(nhdp_interface_get_tree(), nhdp_if, _node, nhdp_if_it) {
_cb_remove_nhdp_interface(nhdp_if);
auto_ll4 = oonf_class_get_extension(&_nhdp_if_extenstion, nhdp_if);
if (... | pushq %r15
pushq %r14
pushq %rbx
callq 0x2ccdc
movq (%rax), %r15
movq (%r15), %r14
movq 0x8(%r15), %rbx
callq 0x2ccdc
cmpq 0x8(%rax), %rbx
je 0x39f2a
movq %r15, %rbx
addq $-0x158, %rbx # imm = 0xFEA8
movq %rbx, %rdi
callq 0x3a02c
movq 0x4a97d(%rip), %rax # 0x84890
cmpb $0x1, 0x68(%rbx,%rax)
movq %r14, %r1... | /OLSR[P]OONF/src/nhdp/auto_ll4/auto_ll4.c |
cb_address_finished | static void
_cb_address_finished(struct os_interface_ip_change *os_addr, int error) {
struct _nhdp_if_autoll4 *auto_ll4;
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str nbuf;
char ibuf[IF_NAMESIZE];
#endif
/* get auto linklayer extension */
auto_ll4 = container_of(os_addr, typeof(*auto_ll4), os_addr);
if (!a... | cmpq $0x0, -0x20(%rdi)
je 0x3a176
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl 0x4a69e(%rip), %r15d # 0x84754
leaq 0x65463(%rip), %rax # 0x9f520
testb $0x1, (%rax,%r15)
je 0x3a13b
leaq 0x1fe86(%rip), %rax # 0x59f51
cmpb $0x0, 0x34(%r... | /OLSR[P]OONF/src/nhdp/auto_ll4/auto_ll4.c |
cb_2hop_change | static void
_cb_2hop_change(void *ptr) {
struct nhdp_l2hop *l2hop = ptr;
struct nhdp_interface *nhdp_if;
struct _nhdp_if_autoll4 *auto_ll4;
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str nbuf;
#endif
nhdp_if = l2hop->link->local_if;
/* get auto linklayer extension */
auto_ll4 = oonf_class_get_extension(&... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x138(%rax), %rdi
movq 0x49d18(%rip), %rax # 0x84890
cmpq $0x0, 0x60(%rdi,%rax)
je 0x3abe8
addq %rax, %rdi
cmpq $0x0, 0x58(%rdi)
jne 0x3abe8
pushq $0x1
popq %rdx
movq %rdx, %rsi
callq 0x21675
movl 0x49bb8(%rip), %r14d # 0x84754
lea... | /OLSR[P]OONF/src/nhdp/auto_ll4/auto_ll4.c |
oonf_http_add | void
oonf_http_add(struct oonf_http_handler *handler) {
handler->directory = handler->site[strlen(handler->site) - 1] == '/';
handler->node.key = handler->site;
avl_insert(&_http_site_tree, &handler->node);
OONF_DEBUG(LOG_HTTP, "Added http handler for uri: %s", handler->site);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x191b0
cmpb $0x2f, -0x1(%r14,%rax)
sete 0x40(%rbx)
movq %r14, 0x28(%rbx)
leaq 0x646b4(%rip), %rdi # 0x9f2d8
movq %rbx, %rsi
callq 0x42657
movl 0x49fa2(%rip), %esi # 0x84bd4
leaq 0x648e7(%rip), %rax # 0x9f520
testb ... | /OLSR[P]OONF/src/base/oonf_http.c |
cb_receive_data | static enum oonf_stream_session_state
_cb_receive_data(struct oonf_stream_session *session) {
struct oonf_http_session header;
struct oonf_http_handler *handler;
char uri[OONF_HTTP_MAX_URI_LENGTH + 1];
char *first_header;
char *ptr;
size_t len;
/* search for end of http header */
if ((first_header = st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %rdi, %rbx
movq 0x228(%rdi), %r14
leaq 0x1f76d(%rip), %rsi # 0x5a63e
movq %r14, %rdi
callq 0x195d0
pushq $0x1
popq %rbp
testq %rax, %rax
je 0x3aeea
movq %rax, %r12
addq $0x4, %r12
jmp 0x3af09
leaq 0x221... | /OLSR[P]OONF/src/base/oonf_http.c |
get_headertype_string | static const char *
_get_headertype_string(enum oonf_http_result type) {
switch (type) {
case HTTP_200_OK:
return HTTP_RESPONSE_200;
case HTTP_400_BAD_REQ:
return HTTP_RESPONSE_400;
case HTTP_401_UNAUTHORIZED:
return HTTP_RESPONSE_401;
case HTTP_403_FORBIDDEN:
return HTTP_RESPO... | leal -0x190(%rdi), %eax
cmpl $0x4, %eax
jbe 0x3b933
cmpl $0xc8, %edi
je 0x3b973
cmpl $0x19d, %edi # imm = 0x19D
je 0x3b97b
cmpl $0x1f4, %edi # imm = 0x1F4
je 0x3b94b
cmpl $0x1f5, %edi # imm = 0x1F5
je 0x3b96b
cmpl $0x1f7, %edi # imm = 0x1F7
jne 0x3b94b
leaq 0x1ea4e(%rip), %ra... | /OLSR[P]OONF/src/base/oonf_http.c |
create_http_header | static void
_create_http_header(
struct oonf_stream_session *session, enum oonf_http_result code, const char *content_type, size_t content_length) {
struct autobuf buf;
struct timeval currtime;
abuf_init(&buf);
abuf_appendf(&buf, "%s %d %s\r\n", HTTP_VERSION_1_0, code, _get_headertype_string(code));
/* D... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x41ea0
movl %ebp, %edi
callq 0x3b8f8
leaq 0x1eb8b(%rip), %rsi # 0x5a542
leaq 0x1e9d6(%rip), %rdx # 0x5a394
movq %r12, %rd... | /OLSR[P]OONF/src/base/oonf_http.c |
cb_telnet_handler | static enum oonf_http_result
_cb_telnet_handler(struct autobuf *out, struct oonf_http_session *session) {
static char EOL = 0;
enum oonf_telnet_result result;
char buffer[1024];
char *ptr1, *ptr2, *ptr3;
session->content_type = HTTP_CONTENTTYPE_TEXT;
strscpy(buffer, &session->decoded_request_uri[sizeof(HTT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1eca3(%rip), %rax # 0x5a87a
movq %rax, 0x1b8(%rsi)
movq 0x18(%rsi), %rsi
addq $0x8, %rsi
movq %rsp, %r12
movl $0x400, %edx # imm = 0x400
movq %r12, %rdi
call... | /OLSR[P]OONF/src/base/oonf_http.c |
router_process_session_update | static enum dlep_parser_error
_router_process_session_update(struct dlep_extension *ext __attribute((unused)), struct dlep_session *session) {
struct oonf_layer2_net *l2net;
struct netaddr ip;
struct dlep_parser_value *value;
bool add_ip;
l2net = oonf_layer2_net_get(session->l2_listener.name);
if (!l2net) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x138(%rsi), %r14
callq 0x1b7cc
movq %rax, %rdi
movq %r14, %rsi
callq 0x424c4
leaq -0x7a0(%rax), %r14
testq %rax, %rax
cmoveq %rax, %r14
je 0x3c173
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x3f9d3
movq %rax, %r13
l... | /OLSR[P]OONF/src/generic/dlep/ext_base_ip/ip.c |
router_process_destination_update | static enum dlep_parser_error
_router_process_destination_update(struct dlep_extension *ext __attribute((unused)), struct dlep_session *session) {
struct oonf_layer2_neigh *l2neigh;
struct netaddr ip;
struct dlep_parser_value *value;
bool add_ip;
l2neigh = dlep_extension_get_l2_neighbor(session);
if (!l2ne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x3d4e3
testq %rax, %rax
je 0x3c621
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x3f9d3
movq %rax, %r13
leaq 0x6(%rsp), %r15
leaq 0x5(%rsp), %r12
pushq $-0x1
popq %rbp
testq %r13, %r13... | /OLSR[P]OONF/src/generic/dlep/ext_base_ip/ip.c |
process_session_ip_tlvs | static void
_process_session_ip_tlvs(
const struct oonf_layer2_origin *origin, struct oonf_layer2_net *l2net, struct netaddr *ip, bool add) {
struct oonf_layer2_peer_address *l2addr;
if (add) {
oonf_layer2_net_add_ip(l2net, origin, ip);
}
else if ((l2addr = oonf_layer2_net_get_local_ip(l2net, ip))) {
... | pushq %rbx
movq %rdi, %rbx
testl %ecx, %ecx
je 0x3c9a1
movq %rsi, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1ae01
addq $0xb8, %rsi
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x424c4
testq %rax, %rax
je 0x3c9c8
addq $-0x60, %rax
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1aeb0
popq %rbx
retq
| /OLSR[P]OONF/src/generic/dlep/ext_base_ip/ip.c |
process_destination_ip_tlv | static void
_process_destination_ip_tlv(
const struct oonf_layer2_origin *origin, struct oonf_layer2_neigh *l2neigh, struct netaddr *ip, bool add) {
struct oonf_layer2_neighbor_address *l2addr;
struct oonf_layer2_peer_address *peer_ip;
int af;
af = netaddr_get_address_family(ip);
if (add) {
if (!oonf_l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
je 0x3cacd
movzbl 0x10(%r14), %ebp
cmpl $0x2, %ebp
je 0x3cb0d
cmpl $0xa, %ebp
jne 0x3cb33
pushq $0x46
jmp 0x3cb0f
subq $-0x80, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x424c4
... | /OLSR[P]OONF/src/generic/dlep/ext_base_ip/ip.c |
reader_map_array | static int
_reader_map_array (struct oonf_layer2_data *data, const struct oonf_layer2_metadata *meta,
struct dlep_session *session, uint16_t dlep_tlv, uint64_t scaling, enum oonf_layer2_network_index l2idx) {
struct dlep_parser_value *value;
int64_t l2value;
const uint8_t *dlepvalue;
uint64_t tmp64[2] = { 0, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r13d
movq %r8, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
movl %ecx, %esi
callq 0x3f9d3
testq %rax, %rax
je 0x3cf61
movq %rax, %rbp
movl %r13d, 0xc(%rsp)
movzwl 0x6(%rax), %edx
pushq $-0x1
popq %r13
... | /OLSR[P]OONF/src/generic/dlep/ext_l1_statistics/l1_statistics.c |
process_session_init_ack | static enum dlep_parser_error
_process_session_init_ack(struct dlep_extension *ext __attribute__((unused)), struct dlep_session *session) {
uint16_t length;
if (dlep_reader_lid_length_tlv(&length, session, NULL)) {
session->cfg.lid_length = DLEP_DEFAULT_LID_LENGTH;
return DLEP_NEW_PARSER_OKAY;
}
if (l... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
xorl %ebx, %ebx
leaq 0x6(%rsp), %rdi
xorl %edx, %edx
callq 0x3fc8a
testl %eax, %eax
je 0x3d0e5
movl $0x4, 0x1c(%r14)
jmp 0x3d10f
movzwl 0x6(%rsp), %eax
cmpl $0x11, %eax
jb 0x3d10b
leaq 0x1dc53(%rip), %r8 # 0x5ad49
pushq $0x5
popq %rsi
pushq $0x2
popq %rcx
movq %r14,... | /OLSR[P]OONF/src/generic/dlep/ext_lid/lid.c |
dlep_extension_add_processing | void
dlep_extension_add_processing(
struct dlep_extension *ext, bool radio, struct dlep_extension_implementation *processing, size_t proc_count) {
size_t i, j;
for (j = 0; j < proc_count; j++) {
for (i = 0; i < ext->signal_count; i++) {
if (ext->signals[i].id == processing[j].id) {
if (radio) {... | pushq %rbx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x3d282
movq 0x18(%rdi), %r10
imulq $0x18, %rax, %r8
addq %rdx, %r8
xorl %r9d, %r9d
subq $0x1, %r10
jb 0x3d27d
movq 0x10(%rdi), %r11
movl (%r11,%r9), %ebx
cmpl (%r8), %ebx
je 0x3d24e
addq $0x58, %r9
jmp 0x3d235
movq 0x8(%r8), %r10
testb %sil, %sil
je 0x3d26b
movq %r10, 0x38... | /OLSR[P]OONF/src/generic/dlep/dlep_extension.c |
process_interface_specific_update | static enum dlep_parser_error
_process_interface_specific_update(struct dlep_extension *ext, struct dlep_session *session) {
struct oonf_layer2_net *l2net;
int result;
l2net = oonf_layer2_net_add(session->l2_listener.name);
if (!l2net) {
OONF_INFO(session->log_source, "Could not add l2net for new interface... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x138(%rsi), %rdi
callq 0x1a92e
testq %rax, %rax
je 0x3d317
movq %rax, %r15
leaq 0x390(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x401a3
testl %eax, %eax
je 0x3d35e
movl %eax, %r10d
movl 0x130(%rbx), %esi
leaq 0x62238(%rip), %rax # 0x9f52... | /OLSR[P]OONF/src/generic/dlep/dlep_extension.c |
dlep_extension_radio_write_session_init_ack | int
dlep_extension_radio_write_session_init_ack(
struct dlep_extension *ext, struct dlep_session *session, const struct oonf_layer2_neigh_key *neigh __attribute__((unused))) {
const struct oonf_layer2_metadata *meta;
struct oonf_layer2_net *l2net;
struct oonf_layer2_data *l2data;
enum oonf_layer2_neighbor_ind... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x138(%rsi), %rdi
callq 0x1a92e
testq %rax, %rax
je 0x3d779
movq %rax, 0x8(%rsp)
leaq 0x390(%rax), %r12
pushq $0x18
popq %rbp
xorl %r15d, %r15d
cmpq 0x38(%rbx), %r15
jae 0x3d666
movq 0x30(%rbx), %rax
... | /OLSR[P]OONF/src/generic/dlep/dlep_extension.c |
dlep_extension_radio_write_destination | int
dlep_extension_radio_write_destination(
struct dlep_extension *ext, struct dlep_session *session, const struct oonf_layer2_neigh_key *neigh) {
struct oonf_layer2_neigh *l2neigh;
union oonf_layer2_neigh_key_str nbuf;
int result;
l2neigh = dlep_session_get_local_l2_neighbor(session, neigh);
if (!l2neigh)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3f475
testq %rax, %rax
je 0x3da73
leaq 0xc8(%r12), %rdi
movq %rax, %rdx
addq $0xb0, %rdx
movl $0x390, %ecx # imm = 0x390
addq 0x28(%rax), %rcx
movq %r15, %rsi
c... | /OLSR[P]OONF/src/generic/dlep/dlep_extension.c |
dlep_if_remove | void
dlep_if_remove(struct dlep_if *interface) {
struct dlep_extension *ext;
OONF_DEBUG(interface->session.log_source, "remove session %s", interface->l2_ifname);
avl_for_each_element(dlep_extension_get_tree(), ext, _node) {
if (interface->session.radio) {
if (ext->cb_session_cleanup_radio) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x130(%rdi), %esi
leaq 0x615db(%rip), %rax # 0x9f520
testb $0x1, (%rax,%rsi)
je 0x3df7b
leaq 0x370(%rbx), %r10
leaq 0x1d061(%rip), %r11 # 0x5afba
leaq 0x1d038(%rip), %rdx # 0x5af98
pushq $0x1
popq %rdi
movl $0x94, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xor... | /OLSR[P]OONF/src/generic/dlep/dlep_interface.c |
dlep_session_add | int
dlep_session_add(struct dlep_session *session, const char *l2_ifname, const struct oonf_layer2_origin *l2_origin,
const struct oonf_layer2_origin *l2_default_origin, struct autobuf *out, bool radio,
int (*if_changed)(struct os_interface_listener *), enum oonf_log_source log_source) {
struct dlep_session_parse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rdi
leaq 0x4408(%rip), %rsi # 0x42469
xorl %edx, %edx
callq 0x424ac
leaq 0xe0(%rbx), %rdi
leaq -0x2361e(%rip), %rsi # 0x1... | /OLSR[P]OONF/src/generic/dlep/dlep_session.c |
dlep_session_process_tcp | enum oonf_stream_session_state
dlep_session_process_tcp(struct oonf_stream_session *tcp_session, struct dlep_session *session)
{
ssize_t processed;
OONF_DEBUG(
session->log_source, "Process TCP buffer of %" PRINTF_SIZE_T_SPECIFIER " bytes", abuf_getlen(&tcp_session->in));
processed = dlep_session_process_bu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x130(%rsi), %esi
leaq 0x60d77(%rip), %r13 # 0x9f520
testb $0x1, (%r13,%rsi)
je 0x3e7df
leaq 0x1c9d6(%rip), %r10 # 0x5b18e
leaq 0x1c8c2(%rip), %rdx # 0x5b081
pushq $0x1
popq %rdi
movl $0x123, %ecx # imm = ... | /OLSR[P]OONF/src/generic/dlep/dlep_session.c |
dlep_reader_heartbeat_tlv | int
dlep_reader_heartbeat_tlv(uint64_t *interval, struct dlep_session *session, struct dlep_parser_value *value) {
uint32_t tmp;
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, DLEP_HEARTBEAT_INTERVAL_TLV);
if (!value) {
return -1;
}
}
ptr = dlep_session_get_t... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
jne 0x3fb02
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x3f9d3
movq %rax, %rdx
testq %rax, %rax
je 0x3fb1f
movq 0xa8(%r14), %rax
movzwl 0x4(%rdx), %ecx
movl (%rax,%rcx), %eax
bswapl %eax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
p... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_reader_peer_type | int
dlep_reader_peer_type(
char *text, size_t text_length, bool *secured_medium, struct dlep_session *session, struct dlep_parser_value *value) {
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, DLEP_PEER_TYPE_TLV);
if (!value) {
return -1;
}
}
if (value->length... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
pushq $-0x1
popq %rbp
testq %r8, %r8
jne 0x3fb59
pushq $0x4
popq %rsi
movq %r13, %rdi
callq 0x3f9d3
movq %rax, %r15
testq %rax, %rax
je 0x3fbd2
cmpw $0x0, 0x6(%r15)... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_reader_mac_tlv | int
dlep_reader_mac_tlv(struct oonf_layer2_neigh_key *key, struct dlep_session *session, struct dlep_parser_value *value) {
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, DLEP_MAC_ADDRESS_TLV);
if (!value) {
return -1;
}
}
ptr = dlep_session_get_tlv_binary(sess... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
jne 0x3fc05
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x3f9d3
movq %rax, %rdx
testq %rax, %rax
je 0x3fc2b
movzwl 0x4(%rdx), %esi
addq 0xa8(%r14), %rsi
movzwl 0x6(%rdx), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
movl $0xff, %r8d
addq $0x8, %rs... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_reader_ipv4_subnet_tlv | int
dlep_reader_ipv4_subnet_tlv(
struct netaddr *ipv4, bool *add, struct dlep_session *session, struct dlep_parser_value *value) {
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, DLEP_IPV4_SUBNET_TLV);
if (!value) {
return -1;
}
}
ptr = dlep_session_get_tlv_bi... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
jne 0x3fdbb
pushq $0xa
popq %rsi
movq %r15, %rdi
callq 0x3f9d3
movq %rax, %rcx
testq %rax, %rax
je 0x3fded
movq 0xa8(%r15), %rax
movzwl 0x4(%rcx), %ecx
leaq (%rax,%rcx), %rsi
incq %rsi
movb -0x1(%rsi), %al
andb $0x1, %al
m... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_reader_uint64 | int
dlep_reader_uint64(uint64_t *number, uint16_t tlv_id, struct dlep_session *session, struct dlep_parser_value *value) {
uint64_t tmp;
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, tlv_id);
if (!value) {
return -1;
}
}
ptr = dlep_session_get_tlv_binary(ses... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rcx, %rcx
jne 0x3ffaf
movzwl %si, %esi
movq %r14, %rdi
callq 0x3f9d3
movq %rax, %rcx
testq %rax, %rax
je 0x3ffce
movq 0xa8(%r14), %rax
movzwl 0x4(%rcx), %ecx
movq (%rax,%rcx), %rax
bswapq %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq ... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_reader_status | int
dlep_reader_status(enum dlep_status *status, char *text, size_t text_length, struct dlep_session *session,
struct dlep_parser_value *value) {
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, DLEP_STATUS_TLV);
if (!value) {
return -1;
}
}
ptr = dlep_session_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
testq %r8, %r8
jne 0x40049
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0x3f9d3
movq %rax, %r15
testq %rax, %rax
je 0x400bf
movq 0xa8(%r13), %rsi
movzwl 0x4(%r15), %eax
movzbl (%rsi,%rax),... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
cb_init_router | static void
_cb_init_router(struct dlep_session *session) {
if (session->restrict_signal == DLEP_SESSION_INITIALIZATION_ACK) {
/*
* we are waiting for a Peer Init Ack,
* so we need to send a Peer Init
*/
dlep_session_generate_signal(session, DLEP_SESSION_INITIALIZATION, NULL);
session->cb_s... | cmpl $0x2, 0x20(%rdi)
jne 0x40a05
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3f711
movq %rbx, %rdi
xorl %esi, %esi
callq *0x118(%rbx)
movq 0x10(%rbx), %rax
movq %rax, 0x230(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x3cbb9
retq
| /OLSR[P]OONF/src/generic/dlep/ext_base_proto/proto_router.c |
cb_cleanup_router | static void
_cb_cleanup_router(struct dlep_session *session) {
struct oonf_layer2_net *l2net;
l2net = oonf_layer2_net_get(session->l2_listener.name);
if (l2net) {
/* remove DLEP mark from interface */
l2net->if_type = OONF_LAYER2_TYPE_UNDEFINED;
l2net->if_dlep = false;
/* and remove all DLEP dat... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x138(%rdi), %r14
callq 0x1b7cc
movq %rax, %rdi
movq %r14, %rsi
callq 0x424c4
testq %rax, %rax
je 0x40b03
andl $0x0, -0x750(%rax)
movq %rax, %rdi
addq $-0x7a0, %rdi # imm = 0xF860
movb $0x0, -0x74c(%rax)
movq 0x108(%rbx), %rsi
callq 0x1a533
movq %rbx, %rdi... | /OLSR[P]OONF/src/generic/dlep/ext_base_proto/proto_router.c |
cb_config_changed | static void
_cb_config_changed(void) {
struct dlep_router_if *interface;
const char *ifname;
char ifbuf[IF_NAMESIZE];
ifname = cfg_get_phy_if(ifbuf, _router_section.section_name);
if (!_router_section.post) {
/* remove old session object */
interface = dlep_router_get_by_layer2_if(ifname);
if (i... | pushq %rbx
subq $0x20, %rsp
movq 0x4660f(%rip), %rsi # 0x879f0
leaq 0x10(%rsp), %rdi
callq 0x48540
cmpq $0x0, 0x465f5(%rip) # 0x879e8
je 0x41462
movq %rax, %rdi
callq 0x41621
testq %rax, %rax
je 0x414ad
movq %rax, %rbx
movq 0x465d8(%rip), %rsi # 0x879e8
leaq 0x46619(%rip), %rdx # 0x87a30
pushq $0xb
popq... | /OLSR[P]OONF/src/generic/dlep/router/dlep_router.c |
dlep_router_interface_init | void
dlep_router_interface_init(void) {
oonf_class_add(&_router_if_class);
dlep_extension_init();
dlep_session_init();
dlep_router_session_init();
dlep_base_proto_router_init();
dlep_base_metric_init();
dlep_base_ip_init();
dlep_l1_statistics_init();
dlep_l2_statistics_init();
dlep_radio_attributes... | pushq %rax
leaq 0x46e0c(%rip), %rdi # 0x882c8
callq 0x19740
callq 0x3d14c
callq 0x3e010
callq 0x41978
callq 0x40978
callq 0x3be9c
callq 0x3beb4
callq 0x3ce6c
callq 0x3d078
callq 0x3d090
callq 0x3d0a8
leaq 0x46e5e(%rip), %rdi # 0x88358
callq 0x1a4a0
leaq 0x46ea2(%rip), %rdi # 0x883a8
popq %rax
jmp 0x213b8
| /OLSR[P]OONF/src/generic/dlep/router/dlep_router_interface.c |
dlep_router_interface_cleanup | void
dlep_router_interface_cleanup(void) {
struct dlep_router_if *interf, *it;
avl_for_each_element_safe(dlep_if_get_tree(false), interf, interf._node, it) {
dlep_router_remove_interface(interf);
}
oonf_class_remove(&_router_if_class);
dlep_base_ip_cleanup();
dlep_router_session_cleanup();
dlep_ext... | pushq %r15
pushq %r14
pushq %rbx
xorl %edi, %edi
callq 0x3dae0
movq (%rax), %rbx
movq (%rbx), %r14
movq 0x8(%rbx), %r15
xorl %edi, %edi
callq 0x3dae0
cmpq 0x8(%rax), %r15
je 0x41543
addq $-0xb50, %rbx # imm = 0xF4B0
movq %rbx, %rdi
callq 0x4157b
movq %r14, %rbx
jmp 0x4151b
leaq 0x46d7e(%rip), %rdi # 0x882... | /OLSR[P]OONF/src/generic/dlep/router/dlep_router_interface.c |
dlep_router_remove_interface | void
dlep_router_remove_interface(struct dlep_router_if *interface) {
/* close all sessions */
_cleanup_interface(interface);
/* cleanup generic interface */
dlep_if_remove(&interface->interf);
/* remove session */
free(interface->interf.session.cfg.peer_type);
oonf_class_free(&_router_if_class, interfa... | pushq %rbx
movq %rdi, %rbx
callq 0x41729
movq %rbx, %rdi
callq 0x3df30
movq (%rbx), %rdi
callq 0x19060
leaq 0x46d2d(%rip), %rdi # 0x882c8
movq %rbx, %rsi
popq %rbx
jmp 0x199ff
| /OLSR[P]OONF/src/generic/dlep/router/dlep_router_interface.c |
cb_tcp_lost | static void
_cb_tcp_lost(struct oonf_stream_session *tcp_session) {
struct dlep_extension *ext;
struct dlep_router_session *router_session;
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str nbuf;
#endif
router_session = container_of(tcp_session->stream_socket, struct dlep_router_session, tcp);
OONF_DEBUG(LOG_DL... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x170(%rdi), %rbx
leaq 0x5d697(%rip), %rax # 0x9f3c0
movl (%rax), %r14d
leaq 0x5d7ed(%rip), %rax # 0x9f520
testb $0x1, (%rax,%r14)
je 0x41d7a
movq %rdi, %rsi
addq $0x18, %rsi
leaq 0xa(%rsp), %rdi
callq 0x43fe7
movq %rax, %r10
leaq 0x1a335(%rip), ... | /OLSR[P]OONF/src/generic/dlep/router/dlep_router_session.c |
abuf_init | int
abuf_init(struct autobuf *autobuf) {
autobuf->_len = 0;
autobuf->_buf = calloc(1, getpagesize());
if (autobuf->_buf == NULL) {
autobuf->_error = true;
return -1;
}
autobuf->_total = getpagesize();
autobuf->_error = false;
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
callq 0x19550
movslq %eax, %r14
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x19350
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x41ed1
movq %r14, (%rbx)
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x41ed6
pushq $-0x1
popq %rax
movb $0x1, %cl
movb %cl, 0x18(%rb... | /OLSR[P]OONF/src/libcommon/autobuf.c |
abuf_vappendf | static int
_vappendf(struct autobuf *autobuf, const char *format, va_list ap, va_list ap2) {
int rc;
size_t min_size;
if (autobuf == NULL)
return 0;
rc = vsnprintf(autobuf->_buf + autobuf->_len, autobuf->_total - autobuf->_len, format, ap);
if (rc < 0) {
autobuf->_error = true;
return rc;
}
... | testq %rdi, %rdi
je 0x41f83
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq %rax, 0x10(%rsp)
movups (%rdx), %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
movq %r14, %rdx... | /OLSR[P]OONF/src/libcommon/autobuf.c |
abuf_appendf | int
abuf_appendf(struct autobuf *autobuf, const char *fmt, ...) {
int rc;
va_list ap;
if (autobuf == NULL)
return 0;
va_start(ap, fmt);
rc = abuf_vappendf(autobuf, fmt, ap);
va_end(ap);
return rc;
} | subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x41ff2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0x... | /OLSR[P]OONF/src/libcommon/autobuf.c |
abuf_puts | int
abuf_puts(struct autobuf *autobuf, const char *s) {
size_t len;
if (autobuf == NULL || s == NULL)
return 0;
len = strlen(s);
if (_autobuf_enlarge(autobuf, autobuf->_len + len + 1) < 0) {
return -1;
}
strcpy(autobuf->_buf + autobuf->_len, s);
autobuf->_len += len;
return len;
} | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x42087
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x191b0
movq %rax, %r15
movq 0x8(%rbx), %rax
leaq (%r15,%rax), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x42090
testl %eax, %eax
js 0x42083
mo... | /OLSR[P]OONF/src/libcommon/autobuf.c |
abuf_strftime | int
abuf_strftime(struct autobuf *autobuf, const char *format, const struct tm *tm) {
size_t rc;
if (autobuf == NULL)
return 0;
rc = strftime(autobuf->_buf + autobuf->_len, autobuf->_total - autobuf->_len, format, tm);
if (rc == 0) {
/* we had an error! Probably the buffer too small. So we add some by... | testq %rdi, %rdi
je 0x42146
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x194c0
testq %rax, %rax
je 0x42149
addq %rax, 0x8(%rbx)
j... | /OLSR[P]OONF/src/libcommon/autobuf.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 0x42200
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rsi
addq %rdx, %rsi
callq 0x42090
testl %eax, %eax
js 0x421fd
movq 0x10(%r15), %rdi
addq 0x8(%r15), %rdi
mo... | /OLSR[P]OONF/src/libcommon/autobuf.c |
abuf_hexdump | void
abuf_hexdump(struct autobuf *out, const char *prefix, const void *buffer, size_t length) {
const uint8_t *buf;
size_t j, l;
buf = buffer;
for (j = 0; j < length; j += 32) {
abuf_appendf(out, "%s%04zx:", prefix, j);
l = length - j;
if (l > 32) {
l = 32;
}
_print_hexline(out, &bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
pushq $0x20
popq %rbx
leaq 0x1e240(%rip), %rbp # 0x60564
movq %rcx, 0x10(%rsp)
movq %rcx, %rax
xorl %ecx, %ecx
cmpq $0x20, %rax
movq %rbx, %r13
cmovbq %rax, %r13
movq 0x10(%rsp), %... | /OLSR[P]OONF/src/libcommon/autobuf.c |
avl_find | struct avl_node *
avl_find(const struct avl_tree *tree, const void *key) {
struct avl_node *node;
int diff;
if (tree->root == NULL)
return NULL;
node = _avl_find_rec(tree->root, key, tree->comp, &diff);
return diff == 0 ? node : NULL;
} | movq %rdi, %rax
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x424f8
pushq %rbx
subq $0x10, %rsp
movq 0x20(%rax), %rdx
leaq 0xc(%rsp), %rbx
movq %rbx, %rcx
callq 0x424fb
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x0, (%rbx)
cmoveq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq
xorl %eax, %eax
retq
| /OLSR[P]OONF/src/libcommon/avl.c |
avl_find_lessequal | struct avl_node *
avl_find_lessequal(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 left as long as key<node.key */
while (diff < 0) {
if (list_is_first(&t... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x4258f
movq %rsi, %rbx
movq 0x20(%r14), %rdx
leaq 0xc(%rsp), %r12
movq %r12, %rcx
callq 0x424fb
movq %rax, %r15
movl (%r12), %eax
testl %eax, %eax
jns 0x425a3
cmpq %r15, (%r14)
je 0x4258f
m... | /OLSR[P]OONF/src/libcommon/avl.c |
avl_rotate_right | static void
_avl_rotate_right(struct avl_tree *tree, struct avl_node *node) {
struct avl_node *left, *parent;
left = node->left;
parent = node->parent;
left->parent = parent;
node->parent = left;
if (parent == NULL)
tree->root = left;
else {
if (parent->left == node)
parent->left = left;... | movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rax
movq %rcx, 0x10(%rax)
movq %rax, 0x10(%rsi)
testq %rcx, %rcx
je 0x42afa
leaq 0x18(%rcx), %rdx
leaq 0x20(%rcx), %rdi
cmpq %rsi, 0x18(%rcx)
cmoveq %rdx, %rdi
jmp 0x42afe
addq $0x10, %rdi
movq %rax, (%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rsi)
movq %rsi, 0x20(%rax)
movq 0x... | /OLSR[P]OONF/src/libcommon/avl.c |
bitstream_r_memcpy | int
bitstream_r_memcpy(struct bitstream_r *stream, void *dst, size_t bytes) {
const uint8_t *buffer;
size_t offset;
bitstream_r_pad(stream);
offset = stream->bit_offset / 8;
if (offset + bytes > stream->length) {
return -1;
}
buffer = stream->ptr;
memcpy(dst, &buffer[offset], bytes);
stream->bi... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
testb $0x7, %al
je 0x42cc3
andq $-0x8, %rax
addq $0x8, %rax
movq %rax, 0x10(%r14)
shrq $0x3, %rax
leaq (%rax,%rbx), %rcx
cmpq 0x8(%r14), %rcx
jbe 0x42cd6
pushq $-0x1
popq %rax
jmp 0x42cf1
addq (%r14), %rax
movq %rsi, %rdi
movq %rax, ... | /OLSR[P]OONF/src/libcommon/bitstream.c |
bitstream_w_write | int
bitstream_w_write(struct bitstream_w *stream, uint64_t src, int32_t bits) {
uint32_t bit_start, bit_end;
size_t offset, size;
uint8_t *buffer;
if (bits <= 0) {
return 0;
}
if (bits > 56) {
return -1;
}
buffer = stream->ptr;
/* copy range */
bit_start = stream->bit_offset;
bit_end =... | testl %edx, %edx
jle 0x42e69
pushq $-0x1
popq %rax
cmpl $0x38, %edx
ja 0x42e6b
movq 0x10(%rdi), %rcx
leal (%rcx,%rdx), %r8d
addl $0x7, %r8d
shrl $0x3, %r8d
cmpq %r8, 0x8(%rdi)
jb 0x42e6b
leal (%rcx,%rdx), %r10d
movl %ecx, %eax
shrl $0x3, %eax
movq (%rdi), %r9
movl %edx, %r11d
addq %rcx, %r11
movq %r11, 0x10(%rdi)
pushq... | /OLSR[P]OONF/src/libcommon/bitstream.c |
isonumber_from_s64 | const char *
isonumber_from_s64(struct isonumber_str *out, int64_t number, const char *unit, uint64_t scaling, bool raw) {
char *outbuf = out->buf;
uint64_t num;
size_t len;
len = sizeof(*out);
if (number == INT64_MIN) {
*outbuf++ = '-';
len--;
num = 1ull << 63;
}
else if (number < 0) {
*... | pushq %rbx
movq %rcx, %rax
movq %rdx, %rcx
movq %rdi, %rbx
movq %rsi, %r9
negq %r9
jno 0x43004
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
leaq 0x1(%rbx), %rdi
movb $0x2d, (%rbx)
pushq $0x2f
popq %rsi
jmp 0x43021
movq %rsi, %rdx
testq %rsi, %rsi
js 0x43014
pushq $0x30
popq %rsi
movq %rbx, %rdi
jmp 0x4... | /OLSR[P]OONF/src/libcommon/isonumber.c |
isonumber_to_u64 | int
isonumber_to_u64(uint64_t *dst, const char *iso, uint64_t scaling) {
static const char symbol_large[] = " kMGTPE";
uint64_t num, fraction_scale, factor;
char *next = NULL, *prefix;
errno = 0;
num = strtoull(iso, &next, 10);
if (errno) {
return -1;
}
if (*next == 0) {
if (num > UINT64_MAX ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
andq $0x0, (%r12)
callq 0x190c0
movq %rax, %r13
andl $0x0, (%rax)
pushq $0xa
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x19340
pushq $-0x1
popq %rbp
cmpl $0x0, (%r13)
je 0x4... | /OLSR[P]OONF/src/libcommon/isonumber.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
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x43320
leaq 0x190cc(%rip), %rsi # 0x5c3ea
jmp 0x4332d
cmpb $0x0, (%r14)
jne 0x43335
leaq 0x1d7d0(%rip), %rsi # 0x60afd
movq %rbx, %rdi
callq 0x4202d
leaq 0x18db3(%rip... | /OLSR[P]OONF/src/libcommon/json.c |
netaddr_from_binary_prefix | int
netaddr_from_binary_prefix(struct netaddr *dst, const void *binary, size_t len, uint8_t addr_type, uint8_t prefix_len) {
memset(dst->_addr, 0, sizeof(dst->_addr));
if (addr_type != 0) {
dst->_type = addr_type;
}
else {
switch (len) {
case 4:
dst->_type = AF_INET;
break;
... | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
testl %ecx, %ecx
je 0x4351b
movb %cl, 0x10(%rbx)
leal (,%rdx,8), %eax
cmpb $-0x1, %r8b
movzbl %r8b, %ecx
movzbl %al, %eax
cmovnel %ecx, %eax
movb %al, 0x11(%rbx)
movq %rbx, %rdi
callq 0x193a0
xorl %eax, %eax
cmpb $0x1, 0x10(%rbx)
sbbl %eax, %eax
popq %r... | /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_to_socket | int
netaddr_to_socket(union netaddr_socket *dst, const struct netaddr *src) {
/* copy address type */
dst->std.sa_family = src->_type;
switch (src->_type) {
case AF_INET:
/* ipv4 */
memcpy(&dst->v4.sin_addr, src->_addr, 4);
break;
case AF_INET6:
/* ipv6 */
memcpy(&dst->v6.si... | movzbl 0x10(%rsi), %eax
movw %ax, (%rdi)
movzbl 0x10(%rsi), %eax
cmpl $0xa, %eax
je 0x435f3
cmpl $0x2, %eax
jne 0x43604
movl (%rsi), %eax
movl %eax, 0x4(%rdi)
jmp 0x435fa
movups (%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
movzbl 0x10(%rsi), %eax
movw %ax, (%rdi)
xorl %eax, %eax
retq
pushq $-0x1
popq %rax
retq
| /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_create_prefix | int
netaddr_create_prefix(
struct netaddr *prefix, const struct netaddr *host, const struct netaddr *netmask, bool truncate) {
int len, maxlen;
if (host->_type != netmask->_type || host->_type == AF_UNSPEC) {
return -1;
}
/* get address length */
maxlen = netaddr_get_af_maxprefix(host->_type) / 8;
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movzbl 0x10(%rsi), %edi
pushq $-0x1
popq %rbx
testl %edi, %edi
je 0x437f9
movq %rdx, %r15
cmpb 0x10(%rdx), %dil
jne 0x437f9
movl %ecx, %ebp
movq %rsi, %r12
callq 0x43808
shrb $0x3, %al
movb $0x0, 0x11(%r14)
movb 0x10(%r12), %cl
movb %cl, 0x10(%r14)
... | /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_get_af_maxprefix | uint8_t
netaddr_get_af_maxprefix(uint32_t af_type) {
switch (af_type) {
case AF_INET:
return 32;
break;
case AF_INET6:
return 128;
case AF_MAC48:
return 48;
break;
case AF_EUI64:
return 64;
break;
default:
return 0;
}
} | cmpl $0x2, %edi
je 0x43825
cmpl $0x30, %edi
je 0x4381f
cmpl $0x2f, %edi
je 0x43822
cmpl $0xa, %edi
jne 0x43828
movb $-0x80, %al
retq
movb $0x40, %al
retq
movb $0x30, %al
retq
movb $0x20, %al
retq
xorl %eax, %eax
retq
| /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_socket_init | int
netaddr_socket_init(union netaddr_socket *combined, const struct netaddr *addr, uint16_t port, unsigned if_index) {
/* initialize memory block */
memset(combined, 0, sizeof(*combined));
switch (addr->_type) {
case AF_INET:
/* ipv4 */
memcpy(&combined->v4.sin_addr, addr->_addr, 4);
combi... | xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movzbl 0x10(%rsi), %eax
cmpl $0xa, %eax
je 0x438f5
cmpl $0x2, %eax
jne 0x43911
movl (%rsi), %eax
movl %ea... | /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_socket_get_port | uint16_t
netaddr_socket_get_port(const union netaddr_socket *sock) {
switch (sock->std.sa_family) {
case AF_INET:
return ntohs(sock->v4.sin_port);
case AF_INET6:
return ntohs(sock->v6.sin6_port);
default:
return 0;
}
} | movzwl (%rdi), %eax
orl $0x8, %eax
cmpl $0xa, %eax
jne 0x43929
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
retq
xorl %eax, %eax
retq
| /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_from_string | int
netaddr_from_string(struct netaddr *dst, const char *src) {
struct netaddr_str buf;
unsigned int colon_count, minus_count;
int result;
int prefix_len;
bool has_coloncolon, has_point;
bool last_was_colon;
char *ptr1, *ptr2, *ptr3;
size_t i;
memset(dst, 0, sizeof(*dst));
if (strcmp(src, "-") == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %r12
andw $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpb $0x2d, (%rsi)
jne 0x43b60
cmpb $0x0, 0x1(%r14)
je 0x43b9d
xorl %ecx, %ecx
leaq 0x34137(%rip), %rbx # 0x77ca0
leaq 0x10(%rcx), %r15
cmp... | /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) {
... | pushq %rbp
pushq %rbx
pushq %rax
movzbl 0x10(%rdi), %ebp
movzwl (%rsi), %ecx
movl %ebp, %eax
subl %ecx, %eax
jne 0x4415c
movq %rdi, %rbx
cmpl $0xa, %ebp
je 0x44139
cmpl $0x2, %ebp
jne 0x4414c
addq $0x4, %rsi
pushq $0x4
jmp 0x4413f
addq $0x8, %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x19320
testl %eax, %eax
jne ... | /OLSR[P]OONF/src/libcommon/netaddr.c |
netaddr_isequal_binary | bool
netaddr_isequal_binary(const struct netaddr *addr, const void *bin, size_t len, uint16_t af, uint8_t prefix_len) {
uint32_t addr_len;
if (addr->_type != af || addr->_prefix_len != prefix_len) {
return false;
}
addr_len = netaddr_get_maxprefix(addr) >> 3;
if (addr_len != len) {
return false;
}... | movzbl 0x10(%rdi), %eax
cmpw %cx, %ax
jne 0x441a8
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
cmpb %r8b, 0x11(%rdi)
jne 0x441ab
movq %rdx, %rbx
movq %rsi, %r14
movzwl %ax, %edi
callq 0x43808
shrb $0x3, %al
movzbl %al, %eax
cmpq %rbx, %rax
jne 0x441ab
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19440
te... | /OLSR[P]OONF/src/libcommon/netaddr.c |
binary_is_in_subnet | static bool
_binary_is_in_subnet(const struct netaddr *subnet, const void *bin) {
size_t byte_length, bit_length;
const uint8_t *_bin;
_bin = bin;
/* split prefix length into whole bytes and bit rest */
byte_length = subnet->_prefix_len / 8;
bit_length = subnet->_prefix_len % 8;
/* compare whole bytes ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movzbl 0x11(%rdi), %ebp
movl %ebp, %r14d
shrl $0x3, %r14d
movq %r14, %rdx
callq 0x19440
testl %eax, %eax
je 0x44217
xorl %eax, %eax
jmp 0x44238
andl $0x7, %ebp
je 0x44236
movzbl (%r15,%r14), %eax
movb $0x8, %cl
subb %bpl, %cl
shrl %c... | /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
callq 0x4428c
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movq 0x8(%r14), %r15
pushq $-0x1
popq %rbp
testq %r15, %r15
je 0x444af
pushq $0x12
... | /OLSR[P]OONF/src/libcommon/netaddr_acl.c |
strscpy | char *
strscpy(char *dest, const char *src, size_t size) {
if (dest == NULL || src == NULL || size == 0) {
return dest;
}
/* src does not need to be null terminated */
strncpy(dest, src, size - 1);
dest[size - 1] = 0;
return dest;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
jne 0x445c7
movq %rdx, %r14
decq %rdx
movq %rbx, %rdi
callq 0x190d0
movb $0x0, -0x1(%rbx,%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /OLSR[P]OONF/src/libcommon/string.c |
str_cpynextword | const char *
str_cpynextword(char *dst, const char *src, size_t len) {
size_t i;
/* sanity check */
if (src == NULL) {
*dst = 0;
return NULL;
}
/* skip whitespace prefix */
while (isblank(*src)) {
src++;
}
/* copy next word */
i = 0;
while (*src != 0 && !isblank(*src) && i < len - 1) ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x44791
movq %rdx, %r15
movq %rsi, %rbx
callq 0x195f0
movq (%rax), %rdx
addq $-0x2, %rbx
movsbq 0x2(%rbx), %rcx
incq %rbx
testb $0x1, (%rdx,%rcx,2)
jne 0x44739
decq %r15
xorl %edx, %edx
testb %cl, %cl
je 0x44771
movq (%rax), %rsi
movsbq %cl, %rdi
test... | /OLSR[P]OONF/src/libcommon/string.c |
str_countwords | size_t
str_countwords(const char *src) {
size_t count = 0;
/* sanity check */
if (src != NULL) {
/* skip whitespace prefix */
while (isblank(*src)) {
src++;
}
while (src != NULL && *src != 0) {
count++;
src = str_skipnextword(src);
}
}
return count;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4483a
movq %rdi, %rbx
callq 0x195f0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x1, (%rax,%rcx,2)
jne 0x4480f
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x4483d
cmpb $0x0, (%rbx)
je 0x4483d
incq %r14
movq %rbx, %rdi
callq 0x447a0
movq %rax, %rbx... | /OLSR[P]OONF/src/libcommon/string.c |
strhex_to_bin | ssize_t
strhex_to_bin(uint8_t *buffer, size_t buffer_len, const char *src) {
size_t srclen, i, j;
int8_t v1, v2;
srclen = strlen(src);
if ((srclen & 1) != 0 || buffer_len < srclen/2) {
return -1;
}
for (i=0, j=0; i<srclen; j++) {
v1 = _hexchar_to_value(src[i++]);
v2 = _hexchar_to_value(src[i++]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x191b0
movq %rax, %r12
shrq %rax
cmpq %r15, %rax
seta %al
orb %r12b, %al
pushq $-0x1
popq %r13
testb $0x1, %al
jne 0x4492c
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r12, %r... | /OLSR[P]OONF/src/libcommon/string.c |
strarray_copy | int
strarray_copy(struct strarray *dst, const struct strarray *src) {
char *ptr;
size_t block;
if (src->value == NULL || src->length == 0) {
memset(dst, 0, sizeof(*dst));
return 0;
}
block = STRARRAY_MEMSIZE(src->length);
ptr = realloc(dst->value, block);
if (!ptr) {
return -1;
}
memcpy(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rsi)
je 0x449d9
movq %rsi, %r15
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x449d9
addq $0x3f, %r14
andq $-0x40, %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x19480
testq %rax, %rax
je 0x449ec
movq %rax, %r12
movq (%r15), %rsi
movq 0x8(%... | /OLSR[P]OONF/src/libcommon/string.c |
strarray_append | int
strarray_append(struct strarray *array, const char *string) {
size_t length, new_length;
char *ptr;
length = strlen(string) + 1;
new_length = array->length + length;
ptr = realloc(array->value, STRARRAY_MEMSIZE(new_length));
if (ptr == NULL) {
return -1;
}
memcpy(ptr + array->length, string, ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x191b0
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %r13
leaq (%rax,%r13), %rsi
addq $0x40, %rsi
andq $-0x40, %rsi
callq 0x19480
testq %rax, %rax
je 0x44a51
movq %rax, %r12
addq %r15, %r13
incq %r13
incq %... | /OLSR[P]OONF/src/libcommon/string.c |
strarray_prepend | int
strarray_prepend(struct strarray *array, const char *string) {
size_t length, new_length;
char *ptr;
length = strlen(string) + 1;
new_length = array->length + length;
ptr = realloc(array->value, STRARRAY_MEMSIZE(new_length));
if (ptr == NULL) {
return -1;
}
memmove(ptr + length, ptr, array->l... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x191b0
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %r13
leaq (%rax,%r13), %rsi
addq $0x40, %rsi
andq $-0x40, %rsi
callq 0x19480
testq %rax, %rax
je 0x44acc
movq %rax, %r12
addq %r15, %r13
incq %r13
incq %... | /OLSR[P]OONF/src/libcommon/string.c |
strarray_get_count | size_t
strarray_get_count(const struct strarray *array) {
size_t count = 0;
char *ptr;
strarray_for_each_element(array, ptr) {
count++;
}
return count;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
xorl %r14d, %r14d
movq %r12, %r15
testq %r15, %r15
je 0x44b8b
movq 0x8(%rbx), %rax
addq %r12, %rax
cmpq %r15, %rax
jbe 0x44b8b
incq %r14
movq %r15, %rdi
callq 0x191b0
addq %rax, %r15
incq %r15
jmp 0x44b67
movq %r14, %rax
addq $0x8,... | /OLSR[P]OONF/src/libcommon/string.c |
cfg_cmd_handle_set | int
cfg_cmd_handle_set(
struct cfg_instance *instance __attribute__((unused)), struct cfg_db *db, const char *arg, struct autobuf *log) {
struct _parsed_argument pa;
char *ptr;
bool dummy;
int result;
/* get temporary copy of argument string */
ptr = strdup(arg);
if (!ptr)
return -1;
/* prepare ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdx, %rdi
callq 0x19580
testq %rax, %rax
je 0x44fa1
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x45009
pushq $-0x1
popq %rbp
testl %eax, %eax
jne 0x44fcd
movq 0x... | /OLSR[P]OONF/src/libconfig/cfg_cmd.c |
cfg_cmd_handle_query | int
cfg_cmd_handle_query(
struct cfg_instance *instance __attribute__((unused)), struct cfg_db *db, const char *arg, struct autobuf *log) {
struct _parsed_argument pa;
const struct const_strarray *array;
const char *tmp;
char *arg_copy;
int result;
if (arg == NULL || *arg == 0) {
cfg_append_printable... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r12
testq %rdx, %rdx
je 0x4554f
cmpb $0x0, (%r12)
je 0x4554f
movq %rsi, %r13
movq %r12, %rdi
callq 0x19580
testq %rax, %rax
je 0x45567
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq... | /OLSR[P]OONF/src/libconfig/cfg_cmd.c |
cfg_cmd_handle_schema | int
cfg_cmd_handle_schema(struct cfg_db *db, const char *arg, struct autobuf *log) {
struct cfg_schema_section *s_section;
char *copy, *ptr;
int result;
if (db->schema == NULL) {
abuf_puts(log, "Internal error, database not connected to schema\n");
return -1;
}
if (arg == NULL || *arg == 0) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq 0x28(%rdi), %rbp
testq %rbp, %rbp
je 0x45836
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x4579e
cmpb $0x0, (%r15)
je 0x4579e
leaq 0x19b78(%rip), %rsi # 0x5f1a1
movq %r15, %rdi
callq 0x19360
testl %eax, %... | /OLSR[P]OONF/src/libconfig/cfg_cmd.c |
cfg_db_set_entry_ext | struct cfg_entry *
cfg_db_set_entry_ext(struct cfg_db *db, const char *section_type, const char *section_name, const char *entry_name,
const char *value, bool append, bool front) {
struct cfg_entry *entry;
struct cfg_named_section *named;
bool new_section = false, new_entry = NULL;
/* create section */
nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r13
leaq 0xf(%rsp), %rcx
movb $0x0, (%rcx)
callq 0x45cc3
testq %rax, %rax
je 0x45f04
movq %rax, %r14
movq %rbx, 0x10(%rsp)
movq %rax, %rbx
addq $0x48, %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq ... | /OLSR[P]OONF/src/libconfig/cfg_db.c |
cfg_db_remove_sectiontype | int
cfg_db_remove_sectiontype(struct cfg_db *db, const char *section_type) {
struct cfg_section_type *section;
/* find section */
section = cfg_db_find_sectiontype(db, section_type);
if (section == NULL) {
return -1;
}
_free_sectiontype(section);
return 0;
} | pushq %rax
callq 0x424c4
testq %rax, %rax
je 0x45f4f
movq %rax, %rdi
callq 0x45b16
xorl %eax, %eax
jmp 0x45f52
pushq $-0x1
popq %rax
popq %rcx
retq
| /OLSR[P]OONF/src/libconfig/cfg_db.c |
cfg_db_remove_namedsection | int
cfg_db_remove_namedsection(struct cfg_db *db, const char *section_type, const char *section_name) {
struct cfg_named_section *named;
named = cfg_db_find_namedsection(db, section_type, section_name);
if (named == NULL) {
return -1;
}
/* only free named section */
_free_namedsection(named);
return... | pushq %rax
callq 0x45f54
testq %rax, %rax
je 0x45f8d
movq %rax, %rdi
callq 0x45f92
xorl %eax, %eax
jmp 0x45f90
pushq $-0x1
popq %rax
popq %rcx
retq
| /OLSR[P]OONF/src/libconfig/cfg_db.c |
cfg_db_get_entry_value | const struct const_strarray *
cfg_db_get_entry_value(struct cfg_db *db, const char *section_type, const char *section_name, const char *entry_name) {
struct cfg_schema_entry_key key;
struct cfg_schema_entry *s_entry;
struct cfg_entry *entry;
entry = cfg_db_find_entry(db, section_type, section_name, entry_name)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x46012
testq %rax, %rax
je 0x46081
addq $0x40, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %r12, %r12
je 0x4609b
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %ed... | /OLSR[P]OONF/src/libconfig/cfg_db.c |
cfg_help_netaddr | void
cfg_help_netaddr(struct autobuf *out, bool preamble, bool prefix, const int8_t *af_types, size_t af_types_count) {
int8_t type;
bool first;
size_t i;
if (preamble) {
abuf_puts(out, CFG_HELP_INDENT_PREFIX "Parameter must be an address of the following type: ");
}
first = true;
for (i = 0; i < af... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movl %edx, 0x4(%rsp)
movq %rdi, %rbx
testl %esi, %esi
je 0x463b2
leaq 0x16864(%rip), %rsi # 0x5cc0e
movq %rbx, %rdi
callq 0x4202d
movb $0x1, %al
xorl %r13d, %r13d
leaq 0x11a22(%rip), %rbp # 0x57de0
cmpq %... | /OLSR[P]OONF/src/libconfig/cfg_help.c |
find_io | static struct cfg_io *
_find_io(struct cfg_instance *instance, const char *url, const char **io_param, struct autobuf *log) {
struct cfg_io *io = NULL;
const char *ptr1;
ptr1 = strstr(url, CFG_IO_URL_SPLITTER);
if (ptr1 == url) {
cfg_append_printable_line(log, "Illegal URL '%s' as parameter for io selectio... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
leaq 0x16b83(%rip), %rsi # 0x5d2a0
movq %r14, %rdi
callq 0x195d0
cmpq %r14, %rax
je 0x46738
movq %rax, %r12
testq %rax, %rax
je 0x46741
addq $0x3, %r12
jmp 0x46748
leaq 0x16b65(%rip), %rsi # 0x... | /OLSR[P]OONF/src/libconfig/cfg_io.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
andq $0x0, (%rdx)
callq 0x46701
testq %rax, %rax
je 0x467d3
movq 0x50(%rax), %rcx
testq %rcx, %rcx
je 0x467e2
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 |
cfg_avlcmp_schemaentries | int
cfg_avlcmp_schemaentries(const void *p1, const void *p2) {
const struct cfg_schema_entry_key *key1, *key2;
int result;
key1 = p1;
key2 = p2;
result = cfg_avlcmp_keys(key1->type, key2->type);
if (result != 0) {
return result;
}
return cfg_avlcmp_keys(key1->entry, key2->entry);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x484c6
testl %eax, %eax
je 0x46861
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x484c6
| /OLSR[P]OONF/src/libconfig/cfg_schema.c |
cfg_schema_add_section | void
cfg_schema_add_section(struct cfg_schema *schema, struct cfg_schema_section *section) {
struct cfg_schema_entry *entry;
size_t i;
/* make sure definitions in compiled code are correct */
assert(cfg_is_allowed_key(section->type));
assert(section->def_name == NULL || cfg_is_allowed_section_name(section->d... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rdi
callq 0x484a2
testb %al, %al
je 0x46986
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x468af
pushq $0x20
popq %rsi
callq 0x191f0
testq %rax, %rax
jne 0x4699f
movq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq %r14, %... | /OLSR[P]OONF/src/libconfig/cfg_schema.c |
cfg_schema_remove_section | void
cfg_schema_remove_section(struct cfg_schema *schema, struct cfg_schema_section *section) {
size_t i;
if (section->_section_node.key) {
avl_remove(&schema->sections, §ion->_section_node);
section->_section_node.key = NULL;
for (i = 0; i < section->entry_count; i++) {
avl_remove(&schema->... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x0, 0x28(%rsi)
je 0x46a1c
movq %rdi, %r14
movq %rbx, %rsi
callq 0x4286a
andq $0x0, 0x28(%rbx)
addq $0x28, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq 0x98(%rbx), %r12
jae 0x46a1c
movq 0x90(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0... | /OLSR[P]OONF/src/libconfig/cfg_schema.c |
cfg_schema_tobin | int
cfg_schema_tobin(void *target, struct cfg_named_section *named, const struct cfg_schema_entry *entries, size_t count) {
char *ptr;
size_t i;
const struct const_strarray *value;
ptr = (char *)target;
for (i = 0; i < count; i++) {
if (entries[i].cb_to_binary == NULL) {
continue;
}
value... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x46ffd
cmpq $0x0, 0x98(%r15)
je 0x46fed
movq %r12, %rdi
movq %r15, %rsi
callq 0x460cf
movq 0xa0(%r15), %rdx
addq %r13, %rdx
mov... | /OLSR[P]OONF/src/libconfig/cfg_schema.c |
section_needs_default_named_one | static bool
_section_needs_default_named_one(struct cfg_section_type *type) {
struct cfg_named_section *named;
if (type == NULL || type->names.count == 0) {
/* no named sections there, so we need the default one */
return true;
}
if (type->names.count > 1) {
/* more than one section, that means at... | movb $0x1, %al
testq %rdi, %rdi
je 0x477b0
movl 0x60(%rdi), %ecx
testl %ecx, %ecx
je 0x477b0
cmpl $0x1, %ecx
jne 0x477b1
movq 0x48(%rdi), %rax
cmpq $0x0, 0x38(%rax)
sete %al
retq
xorl %eax, %eax
retq
| /OLSR[P]OONF/src/libconfig/cfg_schema.c |
cfg_tobin_strptr | int
cfg_tobin_strptr(void *reference, size_t bin_size, const struct const_strarray *value) {
char **ptr;
if (bin_size != sizeof(*ptr)) {
return -1;
}
ptr = (char **)reference;
if (*ptr) {
free(*ptr);
}
*ptr = strdup(strarray_get_first_c(value));
return *ptr == NULL ? -1 : 0;
} | cmpq $0x8, %rsi
jne 0x4797e
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x19060
movq (%r14), %rdi
callq 0x19580
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
retq
| /OLSR[P]OONF/src/libconfig/cfg_tobin.c |
cfg_tobin_choice | int
cfg_tobin_choice(void *reference, size_t bin_size, const struct const_strarray *value,
const char *(*callback)(size_t idx, const void *ptr), size_t choices_count, const void *ptr) {
int *result;
if (bin_size != sizeof(int)) {
return -1;
}
result = (int *)reference;
*result = cfg_get_choice_index(... | cmpq $0x4, %rsi
jne 0x479bf
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq 0x484e5
movl %eax, (%rbx)
xorl %eax, %eax
popq %rbx
retq
pushq $-0x1
popq %rax
retq
| /OLSR[P]OONF/src/libconfig/cfg_tobin.c |
cfg_tobin_acl | int
cfg_tobin_acl(void *reference, size_t bin_size, const struct const_strarray *value) {
struct netaddr_acl *ptr;
if (bin_size != sizeof(*ptr)) {
return -1;
}
ptr = (struct netaddr_acl *)reference;
netaddr_acl_remove(ptr);
return netaddr_acl_from_strarray(ptr, value);
} | cmpq $0x28, %rsi
jne 0x47a65
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x4428c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x442b2
pushq $-0x1
popq %rax
retq
| /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... | cmpq $0x20, %rsi
jne 0x47b63
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), %r12
leaq 0x17706(%rip), %r13 # 0x5f1a1
leaq 0x1439f(%rip), %rbp # 0x5be41
testq %r12, %r12
je 0x... | /OLSR[P]OONF/src/libconfig/cfg_tobin.c |
cfg_tobin_stringlist | int
cfg_tobin_stringlist(void *reference, size_t bin_size, const struct const_strarray *value) {
struct strarray *array;
if (bin_size != sizeof(*array)) {
return -1;
}
array = (struct strarray *)reference;
if (!value->value[0]) {
strarray_init(array);
return 0;
}
return strarray_copy_c(arra... | cmpq $0x10, %rsi
jne 0x47bbe
movq (%rdx), %rax
cmpb $0x0, (%rax)
je 0x47bc2
movq %rdx, %rsi
jmp 0x44971
pushq $-0x1
popq %rax
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
retq
| /OLSR[P]OONF/src/libconfig/cfg_tobin.c |
cfg_validate_printable | int
cfg_validate_printable(
struct autobuf *out, const char *section_name, const char *entry_name, const char *value, size_t len) {
if (cfg_validate_strlen(out, section_name, entry_name, value, len)) {
return -1;
}
if (!str_is_printable(value)) {
/* not a printable ascii character */
cfg_append_prin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
callq 0x47d5d
pushq $-0x1
popq %rbp
testl %eax, %eax
jne 0x47d52
movq %r15, %rdi
callq 0x44848
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x47d54
leaq 0x1586e(%rip), %rsi # 0x5d5ad
movq %r1... | /OLSR[P]OONF/src/libconfig/cfg_validate.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 0x484e5
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x47dfd
leaq 0x15851(%rip), %rsi # 0x5d638
movq %r12, %rdi
mov... | /OLSR[P]OONF/src/libconfig/cfg_validate.c |
cfg_validate_int | int
cfg_validate_int(struct autobuf *out, const char *section_name, const char *entry_name, const char *value, int64_t min,
int64_t max, uint16_t bytelen, uint16_t fraction) {
int64_t i, min64, max64;
uint64_t j, scaling;
struct isonumber_str hbuf;
for (j = 0, scaling = 1; j < fraction; j++, scaling*=10);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movzwl 0x98(%rsp), %r14d
movzwl %r14w, %ebx
pushq $0x1
popq %rbp
movq %rbx, %rax
subq $0x1, %rax
jb 0x47e49
imulq $0xa, %rbp, %rbp
jmp 0x47e3d
leaq... | /OLSR[P]OONF/src/libconfig/cfg_validate.c |
cfg_validate_acl | int
cfg_validate_acl(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_acl dummy;
if (netaddr_acl_handle_keywords(&dummy, value) == 0) {
return 0;
}
if (*value == '+' || *value == '-') {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x10(%rsp), %rdi
movq %rcx, %rsi
callq 0x443dc
testl %eax, %eax
je 0x480d5
movq 0x70(%rsp), %rax
movzbl (%r14), %ecx
cmpl $0x2d, %ecx
je ... | /OLSR[P]OONF/src/libconfig/cfg_validate.c |
cfg_validate_bitmap256 | int
cfg_validate_bitmap256(struct autobuf *out, const char *section_name, const char *entry_name, const char *value) {
int num;
char *end;
if (strcasecmp(value, "all") == 0 || strcasecmp(value, "none") == 0) {
return 0;
}
errno = 0;
num = strtol(value, &end, 10);
if (errno != 0 || *end != 0 || num <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x1709d(%rip), %rsi # 0x5f1a1
movq %rcx, %rdi
callq 0x19080
xorl %ebp, %ebp
testl %eax, %eax
je 0x48162
leaq 0x13d28(%rip), %rsi # 0x5be41
movq %r15, %rdi
callq 0x190... | /OLSR[P]OONF/src/libconfig/cfg_validate.c |
cfg_validate_tokens | int
cfg_validate_tokens(struct autobuf *out, const char *section_name, const char *entry_name, const char *value,
struct cfg_schema_entry *entries, size_t entry_count, struct cfg_schema_token_customizer *custom) {
char buffer[256];
char section_name_entry[32];
const char *ptr;
uint32_t parameter_count, option... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r9, %r15
movq %r8, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, (%rsp)
movq 0x190(%rsp), %rax
testq %rax, %rax
je 0x481be
movl 0x18(%rax), %r14d
jmp 0x481c1
xorl %r14d, %r14d
movq %rcx, %rdi
movq %rcx, ... | /OLSR[P]OONF/src/libconfig/cfg_validate.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.