name string | code string | asm string | file string |
|---|---|---|---|
Ptex::v2_2::PtexReaderCache::processMru() | void PtexReaderCache::processMru()
{
// use a non-blocking lock so we can proceed as soon as space has been freed in the mru list
// (which happens almost immediately in the processMru thread that has the lock)
if (!_mruLock.trylock()) return;
if (_mruList->next < numMruFiles) {
_mruLock.unlock(... | subq $0x78, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x110, %rdi # imm = 0x110
callq 0x80a880
testb $0x1, %al
jne 0x809b28
jmp 0x809d6f
movq 0x8(%rsp), %rax
movq 0x480(%rax), %rax
movl (%rax), %eax
cmpl $0x32, %eax
jge 0x809b51
movq 0x8(%rsp), %rdi
addq $0x110, %rdi ... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexCache.cpp |
Ptex::v2_2::PtexReaderCache::pruneData() | void PtexReaderCache::pruneData()
{
size_t memUsedChangeTotal = 0;
size_t memUsed = _memUsed;
while (memUsed + memUsedChangeTotal > _maxMem) {
PtexCachedReader* reader = _activeFiles.pop();
if (!reader) break;
size_t memUsedChange;
if (reader->tryPrune(memUsedChange)) {
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x90(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0x28(%rsp), %rax
cmpq 0x10(%rcx), %rax
jbe 0x809eb3
movq 0x8(%rsp), %rdi
addq $0x4a0, %rdi # imm = 0x4A0
callq 0x... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexCache.cpp |
Ptex::v2_2::PtexHashMap<Ptex::v2_2::StringKey, Ptex::v2_2::PtexCachedReader*>::deleteContents() | void deleteContents()
{
for (uint32_t i = 0; i < _numEntries; ++i) {
if (_entries[i].value) delete _entries[i].value;
}
delete [] _entries;
for (size_t i = 0; i < _oldEntries.size(); ++i) {
delete [] _oldEntries[i];
}
std::vector<Entry*>().swap... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x60(%rsp)
movl $0x0, 0x8c(%rsp)
movq 0x60(%rsp), %rcx
movl 0x8c(%rsp), %eax
movl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jae 0x80b991
movq 0x60(%rsp), %rax
movq (%rax), %rax
movl 0x8c(%rsp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
cmpq ... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_2::PtexHashMap<Ptex::v2_2::StringKey, Ptex::v2_2::PtexCachedReader*>::grow(Ptex::v2_2::PtexHashMap<Ptex::v2_2::StringKey, Ptex::v2_2::PtexCachedReader*>::Entry*, unsigned long&) | Entry* grow(Entry* oldEntries, size_t& newMemUsed)
{
_oldEntries.push_back(oldEntries);
uint32_t numNewEntries = _numEntries*2;
Entry* entries = new Entry[numNewEntries];
newMemUsed = numNewEntries * sizeof(Entry);
uint32_t mask = numNewEntries-1;
for (uint32_t oldInd... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x10, %rdi
leaq 0x98(%rsp), %rsi
callq 0x80c370
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
shll %eax
movl %eax, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
movq %rax, 0x38(%rsp)
movl $0x20, %ecx
mul... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_2::PtexPointFilter::PtexPointFilter(Ptex::v2_2::PtexTexture*) | virtual void eval(float* result, int firstchan, int nchannels,
int faceid, float u, float v,
float /*uw1*/, float /*vw1*/, float /*uw2*/, float /*vw2*/,
float /*width*/, float /*blur*/)
{
if (!_tx || nchannels <= 0) return;
if (faceid... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x80d350
movq (%rsp), %rax
leaq 0x2c03021(%rip), %rcx # 0x3410038
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexFilters.cpp |
Ptex::v2_2::PtexPointFilter::release() | virtual void eval(float* result, int firstchan, int nchannels,
int faceid, float u, float v,
float /*uw1*/, float /*vw1*/, float /*uw2*/, float /*vw2*/,
float /*width*/, float /*blur*/)
{
if (!_tx || nchannels <= 0) return;
if (faceid... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x80d3d4
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexFilters.cpp |
Ptex::v2_2::PtexUtils::reciprocalPow2(int) | inline float reciprocalPow2(int power)
{
// 1.0/pow(2,power)
union {
float f;
int32_t i;
};
i = (127-power)<<23;
return f;
} | movl %edi, -0x4(%rsp)
movl $0x7f, %eax
subl -0x4(%rsp), %eax
shll $0x17, %eax
movl %eax, -0x8(%rsp)
movss -0x8(%rsp), %xmm0
retq
nopl (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexUtils.h |
Ptex::v2_2::PtexBoxFilter::buildKernel(Ptex::v2_2::PtexSeparableKernel&, float, float, float, float, Ptex::v2_2::Res) | virtual void buildKernel(PtexSeparableKernel& k, float u, float v, float uw, float vw,
Res faceRes)
{
// clamp filter width to no larger than 1.0
uw = PtexUtils::min(uw, 1.0f);
vw = PtexUtils::min(vw, 1.0f);
// clamp filter width to no smaller than a tex... | subq $0x68, %rsp
movw %dx, %ax
movw %ax, 0x66(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movss %xmm0, 0x4c(%rsp)
movss %xmm1, 0x48(%rsp)
movss %xmm2, 0x44(%rsp)
movss %xmm3, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movss 0x44(%rsp), %xmm0
movss 0x3d54e(%rip), %xmm1 # 0x84b154
callq 0x80da80
movs... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexFilters.cpp |
Ptex::v2_2::PtexWidth4Filter::buildKernelAxis(signed char&, int&, int&, float*, float, float, int) | void buildKernelAxis(int8_t& k_ureslog2, int& k_u, int& k_uw, float* ku,
float u, float uw, int f_ureslog2)
{
// build 1 axis (note: "u" labels may repesent either u or v axis)
// clamp filter width to no smaller than a texel
uw = PtexUtils::max(uw, PtexUtils::recip... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
movq %r8, 0xd0(%rsp)
movss %xmm0, 0xcc(%rsp)
movss %xmm1, 0xc8(%rsp)
movl %r9d, 0xc4(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movss 0xc8(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movl 0xc4(%rsp), %edi
callq 0x80db... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexFilters.cpp |
Ptex::v2_2::PtexPointFilterTri::eval(float*, int, int, int, float, float, float, float, float, float, float, float) | virtual void eval(float* result, int firstchan, int nchannels,
int faceid, float u, float v,
float /*uw1*/, float /*vw1*/, float /*uw2*/, float /*vw2*/,
float /*width*/, float /*blur*/)
{
if (!_tx || nchannels <= 0) return;
if (faceid... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movl %ecx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movss %xmm0, 0x68(%rsp)
movss %xmm1, 0x64(%rsp)
movss %xmm2, 0x60(%rsp)
movss %xmm3, 0x5c(%rsp)
movss %xmm4, 0x58(%rsp)
movss %xmm5, 0x54(%rsp)
movss %xmm6, 0x50(%rsp)
movss %xmm7, 0x4c(%rsp)
m... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexFilters.cpp |
Ptex::v2_2::PtexReader::getFaceInfo(int) | const Ptex::FaceInfo& PtexReader::getFaceInfo(int faceid)
{
if (faceid >= 0 && uint32_t(faceid) < _faceinfo.size())
return _faceinfo[faceid];
static Ptex::FaceInfo dummy;
return dummy;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
jl 0x810a10
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %eax
movq %rax, (%rsp)
addq $0x150, %rdi # imm = 0x150
callq 0x8158d0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x810a10
... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::readMetaData() | void PtexReader::readMetaData()
{
// get read lock and make sure we still need to read
AutoMutex locker(readlock);
if (_metadata) {
return;
}
// allocate new meta data (keep local until fully initialized)
MetaData* newmeta = new MetaData(this);
size_t metaDataMemUsed = sizeof(MetaDa... | subq $0x98, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rsi
movq %rsi, 0x38(%rsp)
addq $0x8, %rsi
leaq 0x78(%rsp), %rdi
callq 0x8155f0
movq 0x38(%rsp), %rax
cmpq $0x0, 0x140(%rax)
je 0x810c86
movl $0x1, 0x74(%rsp)
jmp 0x810e86
movl $0x58, %edi
callq 0x3273b0
movq %rax, 0x30(%rsp)
jmp 0x810c97
movq 0x38(%rsp), %rsi
mov... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::readMetaDataBlock(Ptex::v2_2::PtexReader::MetaData*, long, int, int, unsigned long&) | void PtexReader::readMetaDataBlock(MetaData* metadata, FilePos pos, int zipsize, int memsize, size_t& metaDataMemUsed)
{
seek(pos);
// read from file
bool useNew = memsize > AllocaMax;
char* buff = useNew ? new char[memsize] : (char*)alloca(memsize);
if (readZipBlock(buff, zipsize, memsize)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq -0x18(%rbp), %rsi
callq 0x8159b0
cmpl $0x4000, -0x20(%rbp) # imm = 0x4000
setg %al
andb... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::readEditFaceData() | void PtexReader::readEditFaceData()
{
// read header
EditFaceDataHeader efdh;
if (!readBlock(&efdh, EditFaceDataHeaderSize)) return;
// update face info
int faceid = efdh.faceid;
if (faceid < 0 || size_t(faceid) >= _header.nfaces) return;
FaceInfo& f = _faceinfo[faceid];
f = efdh.facein... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x44(%rsp), %rdi
callq 0x8160b0
movq 0x10(%rsp), %rdi
leaq 0x44(%rsp), %rsi
movl $0x1c, %edx
movl $0x1, %ecx
callq 0x810140
testb $0x1, %al
jne 0x8114af
jmp 0x811642
movl 0x44(%rsp), %eax
movl %eax, 0x40(%rsp)
cmpl $0x0, 0x40(%rsp)
... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::getData(int, void*, int, Ptex::v2_2::Res) | void PtexReader::getData(int faceid, void* buffer, int stride, Res res)
{
if (!_ok || faceid < 0 || size_t(faceid) >= _header.nfaces) {
PtexUtils::fill(&_errorPixel[0], buffer, stride, res.u(), res.v(), _pixelsize);
return;
}
// note - all locking is handled in called getData methods
in... | subq $0x168, %rsp # imm = 0x168
movw %r8w, %ax
movw %ax, 0x166(%rsp)
movq %rdi, 0x158(%rsp)
movl %esi, 0x154(%rsp)
movq %rdx, 0x148(%rsp)
movl %ecx, 0x144(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0xc8(%rsp)
testb $0x1, 0x51(%rax)
je 0x812440
cmpl $0x0, 0x154(%rsp)
jl 0x812440
movq 0xc8(%rsp), %rcx
movslq 0x15... | /anderslanglands[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
oonf_class_remove | void
oonf_class_remove(struct oonf_class *ci) {
struct oonf_class_extension *ext, *iterator;
/* remove memcookie from tree */
avl_remove(&_classes_tree, &ci->_node);
/* remove all free memory blocks */
_free_freelist(ci);
/* remove all listeners */
list_for_each_element_safe(&ci->_extensions, ext, _nod... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %rsi
leaq 0x70288(%rip), %rdi # 0x89a98
callq 0x4286a
movq %rbx, %rdi
callq 0x19884
movq 0x70(%rbx), %rdi
movq 0x8(%rdi), %rax
cmpq 0x78(%rbx), %rax
je 0x1983c
movq (%rdi), %r14
addq $-0x38, %rdi
callq 0x198c1
movq %r14, %rdi
jmp 0x19821
movl 0x5eb6a... | /OLSR[P]OONF/src/base/oonf_class.c |
oonf_class_malloc | void *
oonf_class_malloc(struct oonf_class *ci) {
struct list_entity *entity;
void *ptr;
#ifdef OONF_LOG_DEBUG_INFO
bool reuse = false;
#endif
/*
* Check first if we have reusable memory.
*/
if (list_is_empty(&ci->_free_list)) {
/*
* No reusable memory block on the free_list.
* Allocate ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x60(%rdi), %rax
movq 0x60(%rdi), %rbx
cmpq %rax, %rbx
jne 0x19908
cmpq %rax, 0x68(%r14)
je 0x19996
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x20(%r14), %rdx
movq %rbx, %rdi
xorl %esi,... | /OLSR[P]OONF/src/base/oonf_class.c |
oonf_class_extension_add | int
oonf_class_extension_add(struct oonf_class_extension *ext) {
struct oonf_class *c;
if (oonf_class_is_extension_registered(ext)) {
/* already registered */
return 0;
}
c = avl_find_element(&_classes_tree, ext->class_name, c, _node);
if (c == NULL) {
OONF_WARN(LOG_CLASS, "Unknown class %s for ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, 0x38(%rdi)
je 0x19ac9
xorl %ebx, %ebx
cmpq $0x0, 0x40(%r14)
jne 0x19c30
movq 0x8(%r14), %rsi
leaq 0x6ffc4(%rip), %rdi # 0x89a98
callq 0x424c4
testq %rax, %rax
je 0x19be6
movq %rax, %r12
leaq -0x28(%rax), %r15
cmpl $0x0, 0x60(%rax)
je ... | /OLSR[P]OONF/src/base/oonf_class.c |
oonf_class_event | void
oonf_class_event(struct oonf_class *c, void *ptr, enum oonf_class_event evt) {
struct oonf_class_extension *ext;
#ifdef OONF_LOG_DEBUG_INFO
struct oonf_objectkey_str buf;
#endif
OONF_DEBUG(LOG_CLASS, "Fire '%s' event for %s", OONF_CLASS_EVENT_NAME[evt], c->to_keystring(&buf, c, ptr));
list_for_each_elemen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x5e74e(%rip), %r12d # 0x783ac
leaq 0x858bb(%rip), %r13 # 0x9f520
testb $0x1, (%r13,%r12)
je 0x19cbf
movl %ebx, %eax
leaq 0x5dd2a(%rip), %rcx # 0x779a0
movq (%rcx,%rax,8), %... | /OLSR[P]OONF/src/base/oonf_class.c |
test | enum oonf_duplicate_result
_test(struct oonf_duplicate_set *dupset, struct oonf_duplicate_entry *entry, uint64_t seqno, bool set)
{
int64_t diff;
if (seqno == entry->current) {
return OONF_DUPSET_CURRENT;
}
/* eliminate rollover */
diff = _seqno_difference(dupset, seqno, entry->current);
if (diff < -3... | movl %ecx, %r8d
movq %rdx, %rcx
subq 0x20(%rsi), %rcx
jne 0x1a250
pushq $0x3
popq %rax
retq
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1a266
andq %rax, %rcx
cmpq 0x30(%rdi), %rcx
jle 0x1a266
subq 0x38(%rdi), %rcx
cmpq $-0x20, %rcx
jg 0x1a292
movl 0x28(%rsi), %ecx
incl %ecx
movw %cx, 0x28(%rsi)
xorl %eax, %eax
cmpw $0x... | /OLSR[P]OONF/src/base/oonf_duplicate_set.c |
cb_vtime | static void
_cb_vtime(struct oonf_timer_instance *ptr) {
struct oonf_duplicate_entry *entry;
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str nbuf;
#endif
entry = container_of(ptr, struct oonf_duplicate_entry, _vtime);
OONF_DEBUG(LOG_DUPLICATE_SET, "Duplicate entry timed out: %s/%u", netaddr_to_string(&nbuf, &ent... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x70(%rdi), %rbx
movl 0x5e0de(%rip), %r14d # 0x78504
leaq 0x850f3(%rip), %rax # 0x9f520
testb $0x1, (%rax,%r14)
je 0x1a482
movq %rdi, %r15
leaq 0x2(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4392c
movq %rax, %r10
movzbl -0x5e(%r15), %r11d
subq $0x8... | /OLSR[P]OONF/src/base/oonf_duplicate_set.c |
oonf_layer2_net_remove | bool
oonf_layer2_net_remove(struct oonf_layer2_net *l2net, const struct oonf_layer2_origin *origin) {
struct oonf_layer2_neigh *l2neigh, *l2neigh_it;
bool changed = false;
if (!avl_is_node_added(&l2net->_node)) {
return false;
}
avl_for_each_element_safe(&l2net->neighbors, l2neigh, _node, l2neigh_it) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x7a0(%rdi)
je 0x1a586
movq %rdi, %rbx
cmpq $0x0, 0x7a8(%rdi)
je 0x1a586
movq %rsi, %r14
movq 0x90(%rbx), %rdi
xorl %r15d, %r15d
movq 0x8(%rdi), %rax
cmpq 0x98(%rbx), %rax
je 0x1a58a
movq (%rdi), %r12
addq $-0x4c0, %rdi # imm = 0xFB40
movq %r14... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_data_to_string | const char *
oonf_layer2_data_to_string(
char *buffer, size_t length, const struct oonf_layer2_data *data, const struct oonf_layer2_metadata *meta, bool raw) {
struct isonumber_str iso_str;
switch (meta->type) {
case OONF_LAYER2_INTEGER_DATA:
if (!isonumber_from_s64(&iso_str, data->_value.integer, meta... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rcx), %eax
cmpl $0x1, %eax
je 0x1a68a
testl %eax, %eax
jne 0x1a680
movq (%rdx), %rsi
movq 0x20(%rcx), %rax
addq $0x14, %rcx
movzbl %r8b, %r8d
leaq 0x8(%rsp), %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x42fdc
testq %rax, %rax
je 0x1a680
l... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_data_set | bool
oonf_layer2_data_set(struct oonf_layer2_data *l2data, const struct oonf_layer2_origin *origin,
const struct oonf_layer2_metadata *meta, const union oonf_layer2_value *input) {
bool changed = false;
if (meta == NULL) {
OONF_ASSERT(l2data->_meta != NULL, LOG_LAYER2, "Tried to set layer2 data without metad... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rcx
testq %rdx, %rdx
je 0x1a6d7
movq %rdx, %r12
testq %rcx, %rcx
jne 0x1a6df
xorl %ecx, %ecx
jmp 0x1a6fd
movq %rcx, %r12
testq %rcx, %rcx
je 0x1a70a
movq 0x20(%r14), %rax
testq %rax, %rax
sete %dl
cm... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_neigh_remove | static INLINE bool
list_is_node_added(const struct list_entity *node) {
return node->next != NULL && node->prev != NULL;
} | cmpq $0x0, 0x4c0(%rdi)
je 0x1abef
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x4c8(%rdi)
je 0x1abe2
movq %rsi, %r14
movq 0x58(%rbx), %r15
xorl %ebp, %ebp
movq 0x60(%rbx), %rax
cmpq %rax, 0x8(%r15)
je 0x1ab94
movq %r15, %rdi
movq (%r15), %r15
cmpq %r14, -0x8(%rdi)
jne 0x1ab74
addq ... | /OLSR[P]OONF/include/oonf/libcommon/list.h |
oonf_layer2_net_add_ip | struct oonf_layer2_peer_address *
oonf_layer2_net_add_ip(
struct oonf_layer2_net *l2net, const struct oonf_layer2_origin *origin, const struct netaddr *ip) {
struct oonf_layer2_peer_address *l2addr;
l2addr = oonf_layer2_net_get_local_ip(l2net, ip);
if (!l2addr) {
l2addr = oonf_class_malloc(&_l2net_addr_cla... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r12
leaq 0xb8(%rdi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x424c4
testq %rax, %rax
je 0x1ae33
movq %rax, %r14
addq $-0x60, %r14
jmp 0x1ae9a
leaq 0x5d93e(%rip), %rdi # 0x78778
callq 0x198ea
testq %rax, %rax
je 0x... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_net_get_best_neighbor_match | struct oonf_layer2_neighbor_address *
oonf_layer2_net_get_best_neighbor_match(const struct netaddr *addr) {
struct oonf_layer2_neighbor_address *best_match, *l2addr;
struct oonf_layer2_neigh *l2neigh;
struct oonf_layer2_net *l2net;
int prefix_length;
prefix_length = 256;
best_match = NULL;
avl_for_each_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6ebde(%rip), %r14 # 0x89b00
movl $0x100, %ebp # imm = 0x100
movq $0x0, (%rsp)
movq (%r14), %r14
movq 0x8(%r14), %rax
cmpq 0x6ebcb(%rip), %rax # 0x89b08
je 0x1af9d
leaq -0x710(%r14), %r13
movq (%r13), %... | /OLSR[P]OONF/src/base/oonf_layer2.c |
neigh_remove | static void
_neigh_remove(struct oonf_layer2_neigh *l2neigh) {
struct oonf_layer2_destination *l2dst, *l2dst_it;
struct oonf_layer2_neighbor_address *l2addr, *l2addr_it;
/* free all embedded destinations */
avl_for_each_element_safe(&l2neigh->destinations, l2dst, _node, l2dst_it) {
oonf_layer2_destination_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq 0x60(%rbx), %rax
je 0x1b2ba
movq (%rdi), %r14
addq $-0x28, %rdi
callq 0x1b179
movq %r14, %rdi
jmp 0x1b29f
movq 0x80(%rbx), %r14
movq 0x8(%r14), %rax
cmpq 0x88(%rbx), %rax
je 0x1b2e0
leaq -0x60(%r14), %rdi
movq -0x40(%r14), ... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_neigh_add_path | struct oonf_layer2_data *
oonf_layer2_neigh_add_path(const char *ifname, const struct netaddr *l2neigh_addr, enum oonf_layer2_neighbor_index idx) {
struct oonf_layer2_net *l2net;
struct oonf_layer2_neigh *l2neigh;
/* query layer2 database about neighbor */
l2net = oonf_layer2_net_add(ifname);
if (l2net == ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
callq 0x1a92e
testq %rax, %rax
je 0x1b5e7
xorps %xmm0, %xmm0
movq %rsp, %rsi
movups %xmm0, 0x12(%rsi)
movb $0x0, 0x22(%rsi)
movups (%r14), %xmm0
movaps %xmm0, (%rsi)
movzwl 0x10(%r14), %ecx
movw %cx, 0x10(%rsi)
movq %rax, %rdi
callq 0x1b086
testq %r... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_validate_mac_lid | int
oonf_layer2_validate_mac_lid(const struct cfg_schema_entry *entry,
const char *section_name, const char *value, struct autobuf *out) {
struct oonf_layer2_neigh_key key;
int result;
result = oonf_layer2_neigh_key_from_string(&key, value);
switch (result) {
case -1:
cfg_append_printable_line(ou... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x5(%rsp), %rdi
movq %rdx, %rsi
callq 0x1b6c7
xorl %ecx, %ecx
cmpl $-0x4, %eax
jb 0x1b6b9
addl $0x4, %eax
leaq 0x3646e(%rip), %rcx # 0x51b08
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
mo... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_neigh_key_from_string | int
oonf_layer2_neigh_key_from_string(struct oonf_layer2_neigh_key *key, const char *string) {
struct netaddr_str nbuf;
const char *split, *addr;
ssize_t len;
memset(key, 0, sizeof(*key));
split = strchr(string, ',');
if (!split) {
addr = string;
}
else {
len = split - string;
if (len > (s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
andl $0x0, 0x1f(%rdi)
pushq $0x2c
popq %rsi
movq %r15, %rdi
callq 0x191f0
testq %rax, %rax
je 0x1b709
movq %rax, %r12
movq %rax, %rdx
subq %r15, %rdx
cmpq $0x3e, ... | /OLSR[P]OONF/src/base/oonf_layer2.c |
init | static int
_init(void) {
oonf_class_add(&_l2network_class);
oonf_class_add(&_l2neighbor_class);
oonf_class_add(&_l2dst_class);
oonf_class_add(&_l2net_addr_class);
oonf_class_add(&_l2neigh_addr_class);
oonf_class_add(&_lid_class);
avl_init(&_oonf_layer2_net_tree, avl_comp_strcasecmp, false);
avl_init(&_... | pushq %rbx
leaq 0x5ce7e(%rip), %rdi # 0x786e8
callq 0x19740
leaq 0x5d022(%rip), %rdi # 0x78898
callq 0x19740
leaq 0x5d136(%rip), %rdi # 0x789b8
callq 0x19740
leaq 0x5ceea(%rip), %rdi # 0x78778
callq 0x19740
leaq 0x5d08e(%rip), %rdi # 0x78928
callq 0x19740
leaq 0x5cf62(%rip), %rdi # 0x78808
callq... | /OLSR[P]OONF/src/base/oonf_layer2.c |
cleanup | static void
_cleanup(void) {
struct oonf_layer2_net *l2net, *l2n_it;
struct oonf_layer2_lid *lid, *lid_it;
avl_for_each_element_safe(&_oonf_layer2_net_tree, l2net, _node, l2n_it) {
_net_remove(l2net);
}
avl_for_each_element_safe(&_lid_tree, lid, _node, lid_it) {
avl_remove(&_lid_tree, &lid->_node);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x6e1e8(%rip), %rdi # 0x89b00
movq 0x8(%rdi), %rax
cmpq 0x6e1e5(%rip), %rax # 0x89b08
je 0x1b939
movq (%rdi), %rbx
addq $-0x7a0, %rdi # imm = 0xF860
callq 0x1ac63
movq %rbx, %rdi
jmp 0x1b918
movq 0x6e210(%rip), %rsi # 0x89b50
leaq 0x6e209... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_packet_send | int
oonf_packet_send(struct oonf_packet_socket *pktsocket, union netaddr_socket *remote, const void *data, size_t length) {
int result;
struct netaddr_str buf;
if (abuf_getlen(&pktsocket->out) == 0) {
/* no backlog of outgoing packets, try to send directly */
result = os_fd_sendto(&pktsocket->scheduler_e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0xe0(%rdi)
je 0x1bc20
leaq 0xd8(%rbx), %r15
movl $0x80, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x421a4
leaq 0xa(%rsp), %rsi
movw %r12w, (%rsi)
pushq $0x2
popq... | /OLSR[P]OONF/src/base/oonf_packet_socket.c |
apply_managed | static int
_apply_managed(struct oonf_packet_managed *managed) {
struct os_interface *os_if = NULL;
bool changed = false;
int result = 0;
/* get interface */
if (managed->_if_listener.name) {
os_if = managed->_if_listener.data;
}
if (_apply_managed_socketpair(AF_INET, managed, os_if, &changed, &mana... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb $0x0, 0x17(%rsp)
cmpq $0x0, 0x6d0(%rdi)
je 0x1c1f7
movq 0x6e8(%rbx), %r14
jmp 0x1c1fa
xorl %r14d, %r14d
leaq 0x180(%rbx), %r9
leaq 0x690(%rbx), %rax
movq %rax, (%rsp)
pushq $0x2
popq %rdi
leaq 0x17(%rsp), %r15
movq %rbx, %rsi
movq %r14, %... | /OLSR[P]OONF/src/base/oonf_packet_socket.c |
oonf_packet_managed_is_active | bool
oonf_packet_managed_is_active(struct oonf_packet_managed *managed, int af_type) {
switch (af_type) {
case AF_INET:
return oonf_packet_is_active(&managed->socket_v4);
case AF_INET6:
return oonf_packet_is_active(&managed->socket_v6);
default:
return false;
}
} | cmpl $0xa, %esi
je 0x1c3e2
cmpl $0x2, %esi
jne 0x1c3fa
cmpq $0x0, (%rdi)
je 0x1c3fa
pushq $0x8
popq %rax
jmp 0x1c3f1
movl $0x308, %eax # imm = 0x308
cmpq $0x0, 0x300(%rdi)
je 0x1c3fa
cmpq $0x0, (%rdi,%rax)
setne %al
retq
xorl %eax, %eax
retq
| /OLSR[P]OONF/src/base/oonf_packet_socket.c |
oonf_rfc5444_remove_protocol | void
oonf_rfc5444_remove_protocol(struct oonf_rfc5444_protocol *protocol) {
struct oonf_rfc5444_interface *interf, *i_it;
OONF_INFO(LOG_RFC5444, "Remove protocol %s (refcount was %d)", protocol->name, protocol->_refcount);
if (protocol->_refcount > 1) {
/* There are still users left for this protocol */
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x5b991(%rip), %esi # 0x78b84
leaq 0x82326(%rip), %rax # 0x9f520
testb $0x2, (%rax,%rsi)
je 0x1d237
movl 0x2e0(%rbx), %r10d
subq $0x8, %rsp
leaq 0x35013(%rip), %r11 # 0x52225
leaq 0x34f7e(%rip), %rdx # 0x52197
pushq $0x2
popq %rdi
movl $0x1e7, %ecx ... | /OLSR[P]OONF/src/base/oonf_rfc5444.c |
oonf_rfc5444_send_target_data | void
oonf_rfc5444_send_target_data(struct oonf_rfc5444_target *target, const void *ptr, size_t len) {
union netaddr_socket sock;
struct os_interface_listener *interf;
interf = oonf_rfc5444_get_core_if_listener(target->interface);
netaddr_socket_init(&sock, &target->dst, target->interface->protocol->port, inter... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x98(%rdi), %rax
leaq 0x80(%rdi), %rsi
movq 0x10(%rax), %rcx
movzwl 0x20(%rcx), %edx
movq 0x770(%rax), %rax
movl 0x1c(%rax), %ecx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x438b6
movl 0x7be37(%rip), %edi ... | /OLSR[P]OONF/src/base/oonf_rfc5444.c |
oonf_rfc5444_send_interface_data | void
oonf_rfc5444_send_interface_data(
struct oonf_rfc5444_interface *interf, const struct netaddr *dst, const void *ptr, size_t len) {
union netaddr_socket sock;
struct os_interface_listener *os_interf;
os_interf = oonf_rfc5444_get_core_if_listener(interf);
netaddr_socket_init(&sock, dst, interf->protocol->... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x10(%rdi), %rax
movzwl 0x20(%rax), %edx
movq 0x770(%rdi), %rax
movl 0x1c(%rax), %ecx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x438b6
movl 0x7bb6b(%rip), %edi # 0x99bc0
le... | /OLSR[P]OONF/src/base/oonf_rfc5444.c |
cb_receive_data | static void
_cb_receive_data(struct oonf_packet_socket *sock, union netaddr_socket *from, void *ptr, size_t length) {
struct oonf_rfc5444_protocol *protocol;
struct oonf_rfc5444_interface *interf;
enum rfc5444_result result;
struct netaddr source_ip;
struct netaddr_str buf;
interf = sock->config.user;
pr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
movq 0x120(%rdi), %r13
movq 0x10(%r13), %rbx
leaq 0x8(%rsp), %rdi
callq 0x435a0
testl %eax, %eax
je 0x1e7e4
movl 0x5a3f1(%rip), %ebx # 0x78b84
leaq 0x80d86(%rip), %rax ... | /OLSR[P]OONF/src/base/oonf_rfc5444.c |
cb_add_seqno | static void
_cb_add_seqno(struct rfc5444_writer *writer, struct rfc5444_writer_target *rfc5444_target) {
struct oonf_rfc5444_target *target;
bool seqno;
target = container_of(rfc5444_target, struct oonf_rfc5444_target, rfc5444_target);
seqno = target->_pktseqno_refcount > 0 || target->interface->protocol->_pk... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x13c(%rsi)
jle 0x1e9b8
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d2b2
jmp 0x1e9df
movq 0x98(%rbx), %rax
movq 0x10(%rax), %rax
movl 0x2e4(%rax), %ebp
xorl %edx, %edx
testl %ebp, %ebp
setg %dl
movq %r14, %rdi
movq %rbx, %rsi
... | /OLSR[P]OONF/src/base/oonf_rfc5444.c |
cb_send_unicast_packet | static void
_cb_send_unicast_packet(
struct rfc5444_writer *writer __attribute__((unused)), struct rfc5444_writer_target *target, void *ptr, size_t len) {
struct oonf_rfc5444_target *t;
union netaddr_socket sock;
struct os_interface_listener *interf;
t = container_of(target, struct oonf_rfc5444_target, rfc54... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x98(%rsi), %rax
addq $0x80, %rsi
movq 0x10(%rax), %rcx
movzwl 0x20(%rcx), %edx
movq 0x770(%rax), %rax
movl 0x1c(%rax), %ecx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x438b6
movl 0x7b171(%rip), %edi #... | /OLSR[P]OONF/src/base/oonf_rfc5444.c |
cb_parse_request | static INLINE bool
oonf_socket_is_read(struct oonf_socket_entry *entry) {
return os_fd_event_is_read(&entry->fd);
} | testb $0x1, 0x10(%rdi)
je 0x1f469
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r14
leaq 0x28(%rsp), %rdx
movl $0x80, (%rdx)
movl 0x8(%rdi), %edi
leaq 0x68(%rsp), %rsi
callq 0x19500
testl %eax, %eax
js 0x1f37c
movl %eax, %ebx
movl %eax, 0x18(%rsp)
movl $0x1, 0x24(%rs... | /OLSR[P]OONF/include/oonf/base/oonf_socket.h |
oonf_stream_connect_to | struct oonf_stream_session *
oonf_stream_connect_to(struct oonf_stream_socket *stream_socket, const union netaddr_socket *remote) {
struct oonf_stream_session *session;
struct os_fd sock;
struct netaddr remote_addr;
bool wait_for_connect = false;
struct netaddr_str nbuf1;
#ifdef OONF_LOG_DEBUG_INFO
struct n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x5a578(%rip), %r15d # 0x79ae4
leaq 0x7ffad(%rip), %r13 # 0x9f520
testb $0x1, (%r13,%r15)
je 0x1f5d7
leaq 0x10(%rbx), %rsi
leaq 0x2c(%rsp), %rdi
callq 0x43fe7
movq %rax, %r12
leaq 0x6a(%rsp), %... | /OLSR[P]OONF/src/base/oonf_stream_socket.c |
oonf_stream_apply_managed | int
oonf_stream_apply_managed(struct oonf_stream_managed *managed, struct oonf_stream_managed_config *config) {
bool if_changed;
int result;
if_changed = strcmp(config->interface, managed->_managed_config.interface) != 0 ||
!list_is_node_added(&managed->_if_listener._node);
oonf_stream_copy_man... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsi), %r14
leaq 0x3a0(%rdi), %r12
leaq 0x3c8(%rdi), %rsi
movq %r14, %rdi
callq 0x19360
movb $0x1, %bpl
testl %eax, %eax
jne 0x1fc9b
cmpq $0x0, 0x430(%rbx)
je 0x1fc9b
cmpq $0x0, 0x438(%rbx)
sete %bpl
movq %r12, %rdi
movq %r... | /OLSR[P]OONF/src/base/oonf_stream_socket.c |
apply_managed_socket | static int
_apply_managed_socket(
int af_type, struct oonf_stream_managed *managed, struct oonf_stream_socket *stream, struct os_interface *data) {
struct netaddr_acl *bind_ip_acl;
const struct netaddr *bind_ip;
union netaddr_socket sock;
struct netaddr_str buf;
bind_ip_acl = &managed->_managed_config.bind... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x3d8(%rsi), %r15
testq %rcx, %rcx
je 0x1ff06
cmpb $0x1, 0x24(%r12)
jne 0x1ff36
movq 0x58(%r12), %rsi
movzbl 0x10(%rsi), %eax
cmpl %ebp, %eax
jne 0x1ff06
movq %r15, %rd... | /OLSR[P]OONF/src/base/oonf_stream_socket.c |
telnet_handle_command | static enum oonf_telnet_result
_telnet_handle_command(struct oonf_telnet_data *data) {
struct oonf_telnet_command *cmd;
#ifdef OONF_LOG_INFO
struct netaddr_str buf;
#endif
cmd = avl_find_element(&_telnet_cmd_tree, data->command, cmd, _node);
if (cmd) {
cmd = _check_telnet_command_acl(data, cmd);
}
if (c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
leaq 0x79a3b(%rip), %rdi # 0x9a440
callq 0x424c4
pushq $0x4
popq %rbp
testq %rax, %rax
je 0x20aa2
addq $-0x28, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x212ed
testq %rax, %rax
je 0x20aa2
movq %rax, %r14
... | /OLSR[P]OONF/src/base/oonf_telnet.c |
cb_telnet_receive_data | static enum oonf_stream_session_state
_cb_telnet_receive_data(struct oonf_stream_session *session) {
struct oonf_telnet_session *telnet_session;
enum oonf_telnet_result cmd_result;
bool processedCommand = false;
bool chainCommands = false;
char *eol;
int len;
/* get telnet session pointer */
telnet_ses... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
leaq 0x218(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x98(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x240(%rdi), %rax
movq %rax, 0x10(%rsp)
pushq $0x1
popq %rbp
xorl %r14d, %r14d
xorl %r12d, %r12d
movq 0x220(%r15), %rdx
testq %r... | /OLSR[P]OONF/src/base/oonf_telnet.c |
cb_telnet_help | static enum oonf_telnet_result
_cb_telnet_help(struct oonf_telnet_data *data) {
struct oonf_telnet_command *cmd;
if (data->parameter != NULL && data->parameter[0] != 0) {
cmd = avl_find_element(&_telnet_cmd_tree, data->parameter, cmd, _node);
if (cmd) {
cmd = _check_telnet_command_acl(data, cmd);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0x210e3
cmpb $0x0, (%rsi)
je 0x210e3
leaq 0x7939a(%rip), %rdi # 0x9a440
callq 0x424c4
testq %rax, %rax
je 0x2114d
addq $-0x28, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x212ed
testq %rax, %rax
je 0x211... | /OLSR[P]OONF/src/base/oonf_telnet.c |
check_telnet_command_acl | static struct oonf_telnet_command *
_check_telnet_command_acl(struct oonf_telnet_data *data, struct oonf_telnet_command *cmd) {
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str buf;
#endif
if (cmd->acl == NULL) {
return cmd;
}
if (!netaddr_acl_check_accept(cmd->acl, data->remote)) {
OONF_DEBUG(LOG_TELNET... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0x21377
movq (%r15), %rsi
callq 0x444eb
testb %al, %al
jne 0x21377
movl 0x5898a(%rip), %r14d # 0x79ca4
leaq 0x7e1ff(%rip), %rax # 0x9f520
testb $0x1, (%rax,%r14)
jne 0x2132c
xorl... | /OLSR[P]OONF/src/base/oonf_telnet.c |
oonf_viewer_output_print_line | void
oonf_viewer_output_print_line(struct oonf_viewer_template *template) {
if (!template->create_json) {
abuf_add_template(template->out, template->_storage, false);
abuf_puts(template->out, "\n");
}
else {
/* JSON output */
json_start_object(&template->_json, NULL);
json_print_templates(&tem... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
je 0x219a4
leaq 0x48(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x43253
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
callq 0x43400
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x433ed
movq (%rbx), %rdi
movq 0x40(%rbx)... | /OLSR[P]OONF/src/base/oonf_viewer.c |
os_fd_generic_getsocket | int
os_fd_generic_getsocket(struct os_fd *sock, const union netaddr_socket *bind_to, bool tcp, size_t recvbuf,
const struct os_interface *os_if, enum oonf_log_source log_src __attribute__((unused))) {
int s;
s = socket(bind_to->std.sa_family, tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
if (s < 0) {
OONF_WARN(log_sr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %r14
movzwl (%rsi), %edi
pushq $0x2
popq %rsi
subl %edx, %esi
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x19600
testl %eax, %eax
js 0x22352
movl %eax, (%r14)
movl $0x1, 0xc(... | /OLSR[P]OONF/src/base/os_generic/os_fd_generic_getsocket.c |
os_fd_linux_event_wait | int
os_fd_linux_event_wait(struct os_fd_select *sel) {
struct os_fd *sock;
uint64_t maxdelay;
int i;
maxdelay = oonf_clock_get_relative(sel->deadline);
if (maxdelay > INT32_MAX) {
maxdelay = INT32_MAX;
}
sel->_event_count = epoll_wait(sel->_epoll_fd, sel->_events, ARRAYSIZE(sel->_events), maxdelay);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc8(%rdi), %r14
callq 0x19ee9
subq %rax, %r14
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpq %rax, %r14
cmovaeq %rax, %r14
movl 0xc4(%rbx), %edi
pushq $0x10
popq %rdx
movq %rbx, %rsi
movl %r14d, %ecx
callq 0x194a0
m... | /OLSR[P]OONF/src/base/os_linux/os_fd_linux.c |
os_interface_linux_remove | void
os_interface_linux_remove(struct os_interface_listener *if_listener) {
struct os_interface *data;
if (!if_listener->data) {
/* interface not hooked up to data */
return;
}
OONF_INFO(LOG_OS_INTERFACE, "Remove interface from tracking: %s", if_listener->name);
if (if_listener->mesh) {
if_list... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x232ee
movl 0x5798d(%rip), %esi # 0x7ac04
leaq 0x7c2a2(%rip), %rax # 0x9f520
testb $0x2, (%rax,%rsi)
je 0x232b1
leaq 0x30cb2(%rip), %r10 # 0x53f3d
leaq 0x30c84(%rip), %rdx # 0x53f16
pushq $0x2
popq %rdi
movl $0x162, %ecx # ... | /OLSR[P]OONF/src/base/os_linux/os_interface_linux.c |
cb_cfg_changed | static void
_cb_cfg_changed(void) {
struct os_interface *data;
int result;
/* get pointer to interface if available */
data = avl_find_element(&_interface_data_tree, _interface_section.section_name, data, _node);
if (_interface_section.post && !data) {
/* make sure interface data is available */
dat... | pushq %rbx
movq 0x5711b(%rip), %rsi # 0x7ae20
leaq 0x767ac(%rip), %rdi # 0x9a4b8
callq 0x424c4
movq %rax, %rbx
testq %rax, %rax
setne %al
movq 0x570f7(%rip), %rsi # 0x7ae18
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x23d3d
testq %rbx, %rbx
je 0x23df1
addq $-0xc8, %rbx
jmp 0x23d5c
movq 0x570dc(%rip), %rdi ... | /OLSR[P]OONF/src/base/os_linux/os_interface_linux.c |
refresh_mesh | static void
_refresh_mesh(struct os_interface *os_if, char *old_redirect, char *old_spoof) {
char procfile[FILENAME_MAX];
if (os_if->flags.loopback || os_if->flags.any) {
/* ignore loopback and unspecific interface*/
return;
}
if (!os_if->flags.mesh) {
/* this is no mesh interface */
return;
... | cmpb $0x0, 0x27(%rdi)
jne 0x24af9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1010, %rsp # imm = 0x1010
movq %rdi, %r14
cmpb $0x0, 0x28(%rdi)
jne 0x24ae9
cmpb $0x1, 0x2a(%r14)
jne 0x24ae9
movq %rdx, %rbx
movq %rsi, %r15
movl 0x56228(%rip), %esi # 0x7ac04
leaq 0x7ab3d(%rip), %r13 # 0... | /OLSR[P]OONF/src/base/os_linux/os_interface_linux.c |
cb_rtnetlink_done | static void
_cb_rtnetlink_done(uint32_t seq) {
struct os_interface_ip_change *addr;
OONF_INFO(LOG_OS_INTERFACE, "Netlink operation finished: %u", seq);
list_for_each_element(&_rtnetlink_feedback, addr, _internal._node) {
if (seq == addr->_internal.nl_seq) {
_address_finished(addr, 0);
break;
... | pushq %rbx
movl %edi, %ebx
movl 0x55847(%rip), %esi # 0x7ac04
leaq 0x7a15c(%rip), %rax # 0x9f520
testb $0x2, (%rax,%rsi)
je 0x253f2
leaq 0x2f1d0(%rip), %r10 # 0x545a1
leaq 0x2eb3e(%rip), %rdx # 0x53f16
pushq $0x2
popq %rdi
movl $0x50a, %ecx # imm = 0x50A
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %... | /OLSR[P]OONF/src/base/os_linux/os_interface_linux.c |
os_interface_generic_get_prefix_from_dst | const struct os_interface_ip *
os_interface_generic_get_prefix_from_dst(struct netaddr *destination, struct os_interface *os_if) {
const struct os_interface_ip *ip;
if (os_if == NULL) {
avl_for_each_element(os_interface_get_tree(), os_if, _node) {
ip = os_interface_get_prefix_from_dst(destination, os_if)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2574b
movq %rsi, %r15
leaq 0x60(%rsi), %r14
movq (%r14), %r14
movq 0x8(%r14), %rax
cmpq 0x68(%r15), %rax
je 0x25781
leaq 0x5c(%r14), %rdi
movq %rbx, %rsi
callq 0x44243
testb %al, %al
je 0x2572c
jmp 0x25784
callq 0x236e3
movq %r... | /OLSR[P]OONF/src/base/os_generic/os_interface_generic.c |
os_routing_generic_init_half_os_route_key | void
os_routing_generic_init_half_os_route_key(
struct netaddr *ipany, struct netaddr *specific, const struct netaddr *source) {
memcpy(specific, source, sizeof(*source));
switch (netaddr_get_address_family(source)) {
case AF_INET:
memcpy(ipany, &NETADDR_IPV4_ANY, sizeof(struct netaddr));
break;
... | movzwl 0x10(%rdx), %eax
movw %ax, 0x10(%rsi)
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
movzbl 0x10(%rdx), %eax
cmpl $0xa, %eax
je 0x258e5
cmpl $0x2, %eax
jne 0x258fb
leaq 0x3686b(%rip), %rax # 0x5c14e
jmp 0x258ec
leaq 0x36874(%rip), %rax # 0x5c160
movzwl 0x10(%rax), %ecx
movw %cx, 0x10(%rdi)
movups (%rax), %xmm... | /OLSR[P]OONF/src/base/os_generic/os_routing_generic_init_half_route_key.c |
init | static int
_init(void) {
if (os_system_linux_netlink_add(&_rtnetlink_socket, NETLINK_ROUTE)) {
return -1;
}
if (os_system_linux_netlink_add_mc(&_rtnetlink_socket, _rtnetlink_mcast, ARRAYSIZE(_rtnetlink_mcast))) {
os_system_linux_netlink_remove(&_rtnetlink_socket);
return -1;
}
avl_init(&_rtnetlink... | pushq %rbx
leaq 0x553f9(%rip), %rdi # 0x7b2c8
xorl %esi, %esi
callq 0x267ce
pushq $-0x1
popq %rbx
testl %eax, %eax
jne 0x25f44
leaq 0x553e4(%rip), %rdi # 0x7b2c8
leaq 0x2eb4d(%rip), %rsi # 0x54a38
pushq $0x2
popq %rdx
callq 0x27317
testl %eax, %eax
je 0x25f05
leaq 0x553ca(%rip), %rdi # 0x7b2c8
callq 0x2... | /OLSR[P]OONF/src/base/os_linux/os_routing_linux.c |
cb_rtnetlink_message | static void
_cb_rtnetlink_message(struct nlmsghdr *msg) {
struct os_route_listener *listener;
struct os_route *filter;
struct os_route rt;
int result;
#ifdef OONF_LOG_DEBUG_INFO
struct os_route_str rbuf;
#endif
OONF_DEBUG(LOG_OS_ROUTING, "Got message: %d %d 0x%04x", msg->nlmsg_seq, msg->nlmsg_type, msg->nl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdi, %rbx
movl 0x552d1(%rip), %esi # 0x7b274
leaq 0x79576(%rip), %r14 # 0x9f520
testb $0x1, (%r14,%rsi)
je 0x25fee
movl 0x8(%rbx), %r10d
movzwl 0x4(%rbx), %r11d
movzwl 0x6(%rbx), %r15d
leaq 0x2eb7a... | /OLSR[P]OONF/src/base/os_linux/os_routing_linux.c |
os_system_linux_netlink_add_mc | int
os_system_linux_netlink_add_mc(struct os_system_netlink *nl, const uint32_t *groups, size_t groupcount) {
size_t i;
for (i = 0; i < groupcount; i++) {
if (setsockopt(os_fd_get_fd(&nl->socket.fd), SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &groups[i], sizeof(groups[i]))) {
OONF_WARN(nl->used_by->logging, "C... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x4
popq %r12
subq $0x1, %r15
jb 0x273a3
movl 0x10(%rbx), %edi
movl $0x10e, %esi # imm = 0x10E
movl %ebp, %edx
movq %r14, %rcx
movl %r12d, %r8d
callq 0x19140
addq $0x4, %r14
test... | /OLSR[P]OONF/src/base/os_linux/os_system_linux.c |
os_system_linux_netlink_addreq | int
os_system_linux_netlink_addreq(
struct os_system_netlink *nl, struct nlmsghdr *nlmsg, int type, const void *data, int len) {
struct nlattr *nl_attr;
size_t aligned_msg_len, aligned_attr_len;
/* calculate aligned length of message and new attribute */
aligned_msg_len = NLMSG_ALIGN(nlmsg->nlmsg_len);
ali... | pushq %rbx
movl %edx, %eax
movq %rdi, %r10
movl (%rsi), %edi
addl $0x3, %edi
andl $-0x4, %edi
movslq %r8d, %rdx
leaq (%rdx,%rdi), %r9
addq $0x4, %r9
cmpq $0x401, %r9 # imm = 0x401
jb 0x274ad
movl 0x53fd3(%rip), %esi # 0x7b444
leaq 0x780a8(%rip), %rax # 0x9f520
pushq $-0x1
popq %rbx
testb $0x4, (%rax... | /OLSR[P]OONF/src/base/os_linux/os_system_linux.c |
init | static int
_init(void) {
_ioctl_v4 = socket(AF_INET, SOCK_DGRAM, 0);
if (_ioctl_v4 == -1) {
OONF_WARN(LOG_OS_SYSTEM, "Cannot open ipv4 ioctl socket: %s (%d)", strerror(errno), errno);
return -1;
}
_ioctl_v6 = socket(AF_INET6, SOCK_DGRAM, 0);
if (_ioctl_v6 == -1) {
OONF_INFO(LOG_OS_SYSTEM, "Node i... | pushq %r15
pushq %r14
pushq %rbx
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x19600
movl %eax, 0x73052(%rip) # 0x9a544
cmpl $-0x1, %eax
je 0x2755d
pushq $0xa
popq %rdi
pushq $0x2
popq %rsi
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x19600
movl %eax, 0x73034(%rip) # 0x9a540
cmpl $-0x1, %eax
jne 0x275... | /OLSR[P]OONF/src/base/os_linux/os_system_linux.c |
netlink_job_finished | static void
_netlink_job_finished(struct os_system_netlink *nl) {
if (nl->msg_in_transit > 0) {
nl->msg_in_transit--;
}
if (nl->msg_in_transit == 0) {
oonf_timer_stop(&nl->timeout);
if (!list_is_empty(&nl->buffered) || nl->out_messages > 0) {
oonf_socket_set_write(&nl->socket, true);
}
}
... | pushq %rbx
movq %rdi, %rbx
movl 0x98(%rdi), %eax
testl %eax, %eax
jle 0x2761c
decl %eax
movl %eax, 0x98(%rbx)
testl %eax, %eax
jne 0x2764e
leaq 0xc0(%rbx), %rdi
callq 0x2142f
leaq 0x70(%rbx), %rax
cmpq %rax, 0x70(%rbx)
jne 0x27642
cmpq %rax, 0x78(%rbx)
jne 0x27642
cmpl $0x0, 0x68(%rbx)
je 0x2764e
leaq 0x8(%rbx), %rdi
p... | /OLSR[P]OONF/src/base/os_linux/os_system_linux.c |
cb_create_text_interface_ip | static int
_cb_create_text_interface_ip(struct oonf_viewer_template *template) {
struct oonf_layer2_net *net;
struct oonf_layer2_peer_address *peer_ip;
avl_for_each_element(oonf_layer2_get_net_tree(), net, _node) {
_initialize_if_values(net);
avl_for_each_element(&net->local_peer_ips, peer_ip, _net_node... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b7cc
movq %rax, %r14
leaq 0x73ff7(%rip), %r15 # 0x9c1bf
leaq 0x74031(%rip), %r12 # 0x9c200
pushq $0x10
popq %r13
movq (%r14), %r14
movq 0x8(%r14), %rbp
callq 0x1b7cc
cmpq 0x8(%rax), %rbp
je 0x28233
leaq -0x7a0(... | /OLSR[P]OONF/src/generic/layer2info/layer2info.c |
initialize_if_values | static void
_initialize_if_values(struct oonf_layer2_net *net) {
struct os_interface *os_if;
os_if = net->if_listener.data;
strscpy(_value_if, net->name, sizeof(_value_if));
snprintf(_value_if_index, sizeof(_value_if_index), "%u", os_if->index);
strscpy(_value_if_ident, net->if_ident, sizeof(_value_if_ident... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %r15
leaq 0x73bb5(%rip), %rdi # 0x9c0b0
pushq $0x10
popq %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x44594
movl 0x1c(%r15), %ecx
leaq 0x73bab(%rip), %rdi # 0x9c0c0
leaq 0x304bd(%rip), %rdx # 0x589d9
pushq $0xc
popq %rsi
xorl %eax, %eax
callq... | /OLSR[P]OONF/src/generic/layer2info/layer2info.c |
cb_create_text_memory | static int
_cb_create_text_memory(struct oonf_viewer_template *template) {
struct oonf_class *c;
avl_for_each_element(oonf_class_get_tree(), c, _node) {
_initialize_memory_values(template, c);
/* generate template output */
oonf_viewer_output_print_line(template);
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x19dea
movq %rax, %r14
leaq 0x3488f(%rip), %r13 # 0x5d0f0
leaq 0x744a8(%rip), %r15 # 0x9cd10
leaq 0x744d1(%rip), %r12 # 0x9cd40
movq (%r14), %r14
movq 0x8(%r14), %rbp
callq 0x19dea
cmpq 0x8(%rax), %rbp
je 0x2... | /OLSR[P]OONF/src/generic/systeminfo/systeminfo.c |
nhdp_set_originator | void
nhdp_set_originator(const struct netaddr *addr) {
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str buf;
#endif
OONF_DEBUG(LOG_NHDP, "Set originator to %s", netaddr_to_string(&buf, addr));
if (netaddr_get_address_family(addr) == AF_INET) {
memcpy(&_originator_v4, addr, sizeof(*addr));
}
else if (netaddr... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7437b(%rip), %r14d # 0x9d1c0
leaq 0x766d4(%rip), %rax # 0x9f520
testb $0x1, (%rax,%r14)
je 0x28e91
leaq 0xa(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4392c
movq %rax, %r10
leaq 0x2c930(%rip), %r11 # 0x5579c
leaq 0x2c914(%rip), %rdx #... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp.c |
nhdp_db_neighbor_set_originator | void
nhdp_db_neighbor_set_originator(struct nhdp_neighbor *neigh, const struct netaddr *originator) {
struct nhdp_neighbor *neigh2;
struct nhdp_link *lnk;
if (memcmp(&neigh->originator, originator, sizeof(*originator)) == 0) {
/* same originator, nothing to do */
return;
}
if (netaddr_get_address_fa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x12
popq %rdx
callq 0x19440
testl %eax, %eax
je 0x29d89
cmpb $0x0, 0x10(%rbx)
je 0x29ca6
leaq 0xa8(%rbx), %rsi
leaq 0x735bb(%rip), %rdi # 0x9d230
callq 0x4286a
leaq 0x38(%rbx), %r15
movl $0x1f0, %r12... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_db.c |
nhdp_db_link_addr_add | struct nhdp_laddr *
nhdp_db_link_addr_add(struct nhdp_link *lnk, const struct netaddr *addr) {
struct nhdp_laddr *laddr;
laddr = oonf_class_malloc(&_laddr_info);
if (laddr == NULL) {
return NULL;
}
/* initialize key */
memcpy(&laddr->link_addr, addr, sizeof(laddr->link_addr));
laddr->_link_node.key ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x53031(%rip), %rdi # 0x7d0f0
callq 0x198ea
movq %rax, %rbx
testq %rax, %rax
je 0x2a14a
movzwl 0x10(%r15), %eax
movw %ax, 0x10(%rbx)
movups (%r15), %xmm0
movups %xmm0, (%rbx)
leaq 0x28(%rbx), %rsi
movq %rbx, 0x50(%rbx)
leaq 0x60(%rbx), %r15
movq ... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_db.c |
nhdp_db_link_calculate_status | int
_nhdp_db_link_calculate_status(struct nhdp_link *lnk) {
const struct netaddr *local_originator;
const struct os_interface *localif;
int af_type;
af_type = netaddr_get_address_family(&lnk->if_addr);
local_originator = nhdp_get_originator(af_type);
localif = nhdp_interface_get_if_listener(lnk->local_if)-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x150(%rdi), %r15
movzbl 0x160(%rdi), %edi
callq 0x28f03
movq 0x138(%rbx), %r12
movq 0x38(%r12), %r14
pushq $-0x1
popq %rbp
testq %rax, %rax
je 0x2a40e
movq %rax, %r13
cmpb $0x0, 0x10(%rax)
je 0x2a40e
pushq $0x12
popq %rdx... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_db.c |
nhdp_domain_metric_remove | void
nhdp_domain_metric_remove(struct nhdp_domain_metric *metric) {
struct nhdp_domain *domain;
list_for_each_element(&_domain_list, domain, _node) {
if (domain->metric == metric) {
_remove_metric(domain);
break;
}
}
avl_remove(&_domain_metrics, &metric->_node);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x72909(%rip), %rdi # 0x9d278
movq 0x7290a(%rip), %rax # 0x9d280
movq (%rdi), %rdi
cmpq %rax, 0x8(%rdi)
je 0x2a994
cmpq %rbx, -0x280(%rdi)
jne 0x2a976
addq $-0x2a0, %rdi # imm = 0xFD60
callq 0x2a9a8
subq $-0x80, %rbx
leaq 0x72909(%rip), %rdi # 0x9d2a8
movq %rbx, %rs... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_domain.c |
nhdp_domain_encode_willingness_tlvvalue | size_t
nhdp_domain_encode_willingness_tlvvalue(uint8_t *tlvvalue, size_t tlvsize) {
struct nhdp_domain *domain;
uint8_t value;
size_t idx, len;
memset(tlvvalue, 0, tlvsize);
len = 0;
/* set flooding willingness */
tlvvalue[0] = _flooding_domain.local_willingness;
OONF_DEBUG(LOG_NHDP_W, "Set flooding w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
movq %rbx, %rdx
callq 0x19270
movzbl 0x71a13(%rip), %r10d # 0x9d328
movb %r10b, (%r14)
leaq 0x718cd(%rip), %rax # 0x9d1ec
movl (%rax), %esi
leaq 0x73bf8(%rip), %rax # 0x9f520
testb $0x... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_domain.c |
recalculate_neighbor_metric | static bool
_recalculate_neighbor_metric(struct nhdp_domain *domain, struct nhdp_neighbor *neigh) {
struct nhdp_link *lnk;
struct nhdp_link_domaindata *linkdata;
struct nhdp_l2hop *l2hop;
struct nhdp_l2hop_domaindata *l2hopdata;
struct nhdp_neighbor_domaindata *neighdata;
bool changed;
#ifdef OONF_LOG_INFO
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movslq 0x34(%rdi), %rax
shlq $0x5, %rax
leaq (%rsi,%rax), %r13
addq $0xe0, %r13
movabsq $0xffffff00ffffff, %rax # imm = 0xFFFFFF00FFFFFF
movq %rax, (%r13)
andq $0x0, 0x8(%r13)
andl $0x0, 0x14(%r13)
leaq 0x... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_domain.c |
nhdp_reader_init | void
nhdp_reader_init(struct oonf_rfc5444_protocol *p) {
_protocol = p;
rfc5444_reader_add_message_consumer(
&_protocol->reader, &_nhdp_message_pass1_consumer, _nhdp_message_tlvs, ARRAYSIZE(_nhdp_message_tlvs));
rfc5444_reader_add_message_consumer(
&_protocol->reader, &_nhdp_address_pass1_consumer, _nhdp... | pushq %rax
movq %rdi, 0x708d4(%rip) # 0x9d610
addq $0x48, %rdi
leaq 0x509c9(%rip), %rsi # 0x7d710
leaq 0x50a42(%rip), %rdx # 0x7d790
pushq $0x6
popq %rcx
callq 0x4fd42
movq 0x708b3(%rip), %rdi # 0x9d610
addq $0x48, %rdi
leaq 0x50b78(%rip), %rsi # 0x7d8e0
leaq 0x50bf1(%rip), %rdx # 0x7d960
pushq ... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_reader.c |
cb_addMessageHeader | static int
_cb_addMessageHeader(struct rfc5444_writer *writer, struct rfc5444_writer_message *message) {
struct oonf_rfc5444_target *target;
const struct netaddr *originator;
struct netaddr_str buf;
if (!message->target_specific) {
OONF_WARN(LOG_NHDP_W, "non interface-specific NHDP message!");
return R... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x61(%rsi)
je 0x2e3d4
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %r12
movq 0x98(%r12), %rax
cmpq 0x838(%rax), %r12
je 0x2e3f6
cmpq 0x830(%rax), %r12
je 0x2e3f6
leaq 0x6ee68(%rip), %rax # 0x9d1ec
movl (%rax), %ebx
lea... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_writer.c |
nhdp_writer_cleanup | void
nhdp_writer_cleanup(void) {
/* remember we already did shut down the writer */
_cleanedup = true;
/* remove pbb writer */
rfc5444_writer_unregister_content_provider(
&_protocol->writer, &_nhdp_msgcontent_provider, _nhdp_addrtlvs, ARRAYSIZE(_nhdp_addrtlvs));
rfc5444_writer_unregister_message(&_protoc... | pushq %rbx
movb $0x1, 0x6f128(%rip) # 0x9d690
movl $0xc0, %ebx
movq 0x6f10c(%rip), %rdi # 0x9d680
addq %rbx, %rdi
leaq 0x4f662(%rip), %rsi # 0x7dbe0
leaq 0x4f6bb(%rip), %rdx # 0x7dc40
pushq $0x4
popq %rcx
callq 0x503ce
addq 0x6f0ec(%rip), %rbx # 0x9d680
movq 0x6f0ed(%rip), %rsi # 0x9d688
movq %r... | /OLSR[P]OONF/src/nhdp/nhdp/nhdp_writer.c |
cleanup | static void
_cleanup(void) {
struct nhdp_interface *nhdp_if, *nhdp_if_it;
struct ff_dat_if_config *ifconfig;
avl_for_each_element_safe(nhdp_interface_get_tree(), nhdp_if, _node, nhdp_if_it) {
ifconfig = oonf_class_get_extension(&_nhdpif_extenstion, nhdp_if);
if (ifconfig->registered) {
nhdp_interfa... | pushq %r15
pushq %r14
pushq %rbx
callq 0x2ccdc
movq (%rax), %r14
movq (%r14), %rbx
movq 0x8(%r14), %r15
callq 0x2ccdc
cmpq 0x8(%rax), %r15
je 0x2f12a
movq %r14, %rdi
addq $-0x158, %rdi # imm = 0xFEA8
movq 0x4ef3a(%rip), %rax # 0x7e050
cmpb $0x1, 0x70(%rdi,%rax)
movq %rbx, %r14
jne 0x2f0f3
callq 0x2c28d
mo... | /OLSR[P]OONF/src/nhdp/ff_dat_metric/ff_dat_metric.c |
get_raw_rx_linkspeed | static int64_t
_get_raw_rx_linkspeed(struct nhdp_link *lnk) {
struct os_interface *os_if;
struct oonf_layer2_net *l2net;
struct oonf_layer2_neigh *l2neigh;
const struct oonf_layer2_data *rx_bitrate_entry;
/* get local interface data */
os_if = nhdp_interface_get_if_listener(lnk->local_if)->data;
rx_b... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x138(%rdi), %rax
movq 0x38(%rax), %r14
addq $0xc, %r14
leaq 0x162(%rdi), %rsi
pushq $0x5
popq %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0x1b4c7
testq %rax, %rax
je 0x2fc84
movq %rax, %rbx
cmpq $0x0, 0x20(%rax)
je 0x2fc7c
movq 0x18(%rbx),... | /OLSR[P]OONF/src/nhdp/ff_dat_metric/ff_dat_metric.c |
link_to_string | static const char *
_link_to_string(struct nhdp_metric_str *buf, uint32_t metric) {
uint64_t value;
if (metric < DATFF_LINKCOST_MINIMUM) {
value = (uint32_t)DATFF_LINKSPEED_MINIMUM * (uint32_t)DATFF_LINKSPEED_RANGE;
}
else if (metric > DATFF_LINKCOST_MAXIMUM) {
strscpy(buf->buf, "infinite", sizeof(*buf... | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x30024
cmpl $0xffff01, %esi # imm = 0xFFFF01
jb 0x3002b
leaq 0x26d8b(%rip), %rsi # 0x56da0
movl $0x80, %edx
movq %rbx, %rdi
callq 0x44594
jmp 0x3004b
movl $0x80000000, %esi # imm = 0x80000000
jmp 0x30036
movl $0x80000000, %eax # imm = 0x80000000
xo... | /OLSR[P]OONF/src/nhdp/ff_dat_metric/ff_dat_metric.c |
path_to_string | static const char *
_path_to_string(struct nhdp_metric_str *buf, uint32_t metric, uint8_t hopcount) {
struct nhdp_metric_str mbuf;
if (hopcount == 0) {
/* prevent division by zero */
hopcount = 1;
}
snprintf(buf->buf, sizeof(*buf), "%s (%u hops)", _link_to_string(&mbuf, metric / hopcount), hopcount);
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %eax
movq %rdi, %rbx
cmpb $0x1, %dl
adcl $0x0, %edx
movzbl %dl, %ebp
xorl %edx, %edx
divl %ebp
movq %rsp, %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x2fffe
leaq 0x26d2e(%rip), %rdx # 0x56daf
movl $0x80, %esi
movq %rbx, %rdi
movq %r14, %rcx
movl %ebp, %r8... | /OLSR[P]OONF/src/nhdp/ff_dat_metric/ff_dat_metric.c |
cleanup | static void
_cleanup(void) {
struct l2_config_if_data *if_data, *if_data_it;
avl_for_each_element_safe(&_if_data_tree, if_data, _node, if_data_it) {
_remove_if_data(if_data);
}
oonf_telnet_remove(&_telnet_l2config[0]);
oonf_timer_remove(&_reconfigure_timer);
oonf_class_extension_remove(&_l2net_listene... | pushq %rbx
movq 0x6d21e(%rip), %rdi # 0x9d738
movq 0x8(%rdi), %rax
cmpq 0x6d21b(%rip), %rax # 0x9d740
je 0x30538
movq (%rdi), %rbx
addq $-0x70, %rdi
callq 0x30847
movq %rbx, %rdi
jmp 0x3051a
leaq 0x4f761(%rip), %rdi # 0x7fca0
callq 0x208b6
leaq 0x4e245(%rip), %rdi # 0x7e790
callq 0x213d8
leaq 0x4f6b1(%r... | /OLSR[P]OONF/src/generic/layer2_config/layer2_config.c |
cb_neigh_value_validator | static int
_cb_neigh_value_validator(struct autobuf *out, const char *section_name, const char *entry_name, const char *value,
struct cfg_schema_entry *entries, size_t entry_count) {
struct l2_config_data l2_data;
const struct oonf_layer2_metadata *meta;
union oonf_layer2_value dst;
if (cfg_tobin_tokens(&l2_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
xorl %r12d, %r12d
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %r9, %rcx
xorl %r8d, %r8d
callq 0x47bcb
testl %eax, %eax
je 0x30bad
pushq $-0x1
popq %r12
jmp 0x3... | /OLSR[P]OONF/src/generic/layer2_config/layer2_config.c |
init | static int
_init(void) {
_protocol = oonf_rfc5444_get_default_protocol();
if (oonf_class_extension_add(&_link_extenstion)) {
return -1;
}
_probing_message = rfc5444_writer_register_message(&_protocol->writer, RFC5444_MSGTYPE_PROBING, true);
if (_probing_message == NULL) {
oonf_rfc5444_remove_protoco... | pushq %r14
pushq %rbx
pushq %rax
callq 0x1d7a2
movq %rax, 0x6c5b4(%rip) # 0x9d770
leaq 0x4ed75(%rip), %rdi # 0x7ff38
callq 0x19aaa
pushq $-0x1
popq %rbx
testl %eax, %eax
je 0x311d9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xc0, %r14d
movq 0x6c58a(%rip), %rdi # 0x9d770
addq %r14, %rdi
p... | /OLSR[P]OONF/src/nhdp/neighbor_probing/neighbor_probing.c |
cb_probe_link | static void
_cb_probe_link(struct oonf_timer_instance *ptr __attribute__((unused))) {
struct nhdp_link *lnk, *best_lnk;
struct _probing_link_data *ldata, *best_ldata;
struct nhdp_interface *nhdp_if;
struct os_interface_listener *if_listener;
struct oonf_layer2_net *l2net;
struct oonf_layer2_neigh *l2neigh;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl 0x4e95e(%rip), %esi # 0x7fd54
leaq 0x6e123(%rip), %rbp # 0x9f520
testb $0x1, (%rbp,%rsi)
je 0x3142f
subq $0x8, %rsp
leaq 0x26734(%rip), %r10 # 0x57b43
leaq 0x266bb(%rip), %rdx # 0x57ad1
pushq $0x1
popq %rdi
movl $0x1... | /OLSR[P]OONF/src/nhdp/neighbor_probing/neighbor_probing.c |
cb_create_text_if_address | static int
_cb_create_text_if_address(struct oonf_viewer_template *template) {
struct nhdp_interface *nhdp_if;
struct nhdp_interface_addr *nhdp_addr;
avl_for_each_element(nhdp_interface_get_tree(), nhdp_if, _node) {
/* fill output buffers for template engine */
_initialize_interface_values(nhdp_if);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2ccdc
movq %rax, %r14
pushq $0x6
popq %r13
leaq 0x6c4fa(%rip), %rbp # 0x9deaf
movq (%r14), %r14
movq 0x8(%r14), %r15
callq 0x2ccdc
cmpq 0x8(%rax), %r15
je 0x31a75
leaq -0x158(%r14), %rdi
callq 0x31f71
leaq 0x38(%r14... | /OLSR[P]OONF/src/nhdp/nhdpinfo/nhdpinfo.c |
cb_create_text_neighbor | static int
_cb_create_text_neighbor(struct oonf_viewer_template *template) {
struct nhdp_neighbor *neigh;
struct nhdp_domain *domain;
list_for_each_element(nhdp_db_get_neigh_list(), neigh, _global_node) {
_initialize_nhdp_neighbor_values(neigh);
list_for_each_element(nhdp_domain_get_list(), domain, _nod... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x2a4bd
movq %rax, %r15
leaq 0x1ffd2(%rip), %rbp # 0x51d46
leaq 0x1ffd0(%rip), %r14 # 0x51d4b
pushq $0x6
popq %r12
movq (%r15), %r15
movq 0x8(%r15), %rbx
callq 0x2a4bd
cmpq 0x8(%rax), %rbx
je 0x31e8f
l... | /OLSR[P]OONF/src/nhdp/nhdpinfo/nhdpinfo.c |
olsrv2_mpr_shall_process | bool
olsrv2_mpr_shall_process(struct rfc5444_reader_tlvblock_context *context, uint64_t vtime) {
enum oonf_duplicate_result dup_result;
bool process;
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str buf;
#endif
/* check if message has originator and sequence number */
if (!context->has_origaddr || !context->has... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, 0x37(%rdi)
jne 0x3248d
cmpb $0x0, 0x4a(%r14)
je 0x3248d
movq %rsi, %r8
movl $0x200, %edi # imm = 0x200
addq 0x6c0f8(%rip), %rdi # 0x9e4d0
movzbl 0x30(%r14), %esi
leaq 0x38(%r14), %r12
movzwl 0x4c... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2.c |
olsrv2_generate_tcs | void
olsrv2_generate_tcs(bool generate) {
uint64_t interval;
interval = _overwrite_tc_interval;
if (!interval) {
interval = _olsrv2_config.tc_interval;
}
if (generate && !oonf_timer_is_active(&_tc_timer)) {
oonf_timer_set(&_tc_timer, interval);
}
else if (!generate && oonf_timer_is_active(&_tc_ti... | movq 0x6bb56(%rip), %rdx # 0x9e438
testq %rdx, %rdx
jne 0x328ee
movq 0x6bb52(%rip), %rdx # 0x9e440
movq 0x4e43b(%rip), %rax # 0x80d30
testl %edi, %edi
je 0x3290d
testq %rax, %rax
jne 0x3291e
leaq 0x4e3d3(%rip), %rdi # 0x80cd8
movq %rdx, %rsi
jmp 0x21675
testq %rax, %rax
je 0x3291e
leaq 0x4e3bf(%rip), %r... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2.c |
cleanup | static void
_cleanup(void) {
/* remove interface listener */
os_interface_remove(&_if_listener);
/* cleanup configuration */
netaddr_acl_remove(&_olsrv2_config.routable_acl);
netaddr_acl_remove(&_olsrv2_config.originator_acl);
/* cleanup all parts of olsrv2 */
olsrv2_routing_cleanup();
olsrv2_originat... | pushq %rax
leaq 0x4ef21(%rip), %rdi # 0x818e8
callq 0x23264
leaq 0x6ba9d(%rip), %rdi # 0x9e470
callq 0x4428c
leaq 0x6bab9(%rip), %rdi # 0x9e498
callq 0x4428c
callq 0x346b9
callq 0x331d3
callq 0x35b35
callq 0x32fef
andq $0x0, 0x6bad0(%rip) # 0x9e4d0
popq %rax
retq
| /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2.c |
olsrv2_originator_cleanup | void
olsrv2_originator_cleanup(void) {
struct olsrv2_originator_set_entry *entry, *e_it;
/* remove all originator entries */
avl_for_each_element_safe(&_originator_set_tree, entry, _node, e_it) {
_remove_originator_entry(entry);
}
/* remove timer and class */
oonf_timer_remove(&_originator_entry_timer... | pushq %rbx
movq 0x6b33d(%rip), %rdi # 0x9e518
movq 0x8(%rdi), %rax
cmpq 0x6b33a(%rip), %rax # 0x9e520
je 0x331f9
movq (%rdi), %rbx
addq $-0x18, %rdi
callq 0x33212
movq %rbx, %rdi
jmp 0x331db
leaq 0x4e888(%rip), %rdi # 0x81a88
callq 0x213d8
leaq 0x4e7ec(%rip), %rdi # 0x819f8
popq %rbx
jmp 0x197fe
| /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_originator.c |
olsrv2_originator_is_local | bool
olsrv2_originator_is_local(const struct netaddr *addr) {
if (netaddr_cmp(&_originator_v4, addr) == 0) {
return true;
}
if (netaddr_cmp(&_originator_v6, addr) == 0) {
return true;
}
return olsrv2_originator_get_entry(addr) != NULL;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6b2d5(%rip), %rdi # 0x9e540
pushq $0x12
popq %rdx
movq %rbx, %rsi
callq 0x19440
movb $0x1, %bpl
testl %eax, %eax
je 0x332a9
leaq 0x6b2ce(%rip), %rdi # 0x9e552
pushq $0x12
popq %rdx
movq %rbx, %rsi
callq 0x19440
testl %eax, %eax
je 0x332a9
leaq 0x6b27e(%rip... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_originator.c |
cb_addresstlvs | static enum rfc5444_result
_cb_addresstlvs(struct rfc5444_reader_tlvblock_context *context __attribute__((unused))) {
struct rfc5444_reader_tlvblock_entry *tlv;
struct nhdp_domain *domain;
struct olsrv2_tc_edge *edge;
struct olsrv2_tc_attachment *end;
uint32_t cost_in[NHDP_MAXIMUM_DOMAINS];
uint32_t cost_ou... | cmpq $0x0, 0x6a9c3(%rip) # 0x9e570
je 0x340e6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
xorl %eax, %eax
movl $0xffffff, %ecx # imm = 0xFFFFFF
cmpq $0x4, %rax
je 0x33be1
movl %ecx, 0x50(%rsp,%rax,4)
movl %ecx, 0x10(%rsp,%rax,4)
incq %rax
jmp 0x33bce
le... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_reader.c |
olsrv2_routing_initiate_shutdown | void
olsrv2_routing_initiate_shutdown(void) {
struct olsrv2_routing_entry *entry, *e_it;
int i;
/* remember we are in shutdown */
_initiate_shutdown = true;
_freeze_routes = false;
/* remove all routes */
for (i = 0; i < NHDP_MAXIMUM_DOMAINS; i++) {
avl_for_each_element_safe(&_routing_tree[i], entry... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, 0x6a4d2(%rip) # 0x9e698
movb $0x0, 0x6a4cc(%rip) # 0x9e699
xorl %r14d, %r14d
leaq 0x73(%rip), %r12 # 0x3424a
cmpq $0x4, %r14
je 0x34237
imulq $0x28, %r14, %rax
leaq 0x6a3c8(%rip), %rcx # 0x9e5b0
leaq (%rcx,%rax), ... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_routing.c |
olsrv2_routing_force_update | void
olsrv2_routing_force_update(bool skip_wait) {
struct nhdp_domain *domain;
bool splitv4, splitv6;
if (_initiate_shutdown || _freeze_routes) {
/* no dijkstra anymore when in shutdown */
return;
}
/* handle dijkstra rate limitation timer */
if (oonf_timer_is_active(&_rate_limit_timer)) {
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
cmpb $0x0, 0x69de1(%rip) # 0x9e698
jne 0x34e14
cmpb $0x0, 0x69dd5(%rip) # 0x9e699
jne 0x34e14
cmpq $0x0, 0x4d63e(%rip) # 0x81f10
je 0x348e9
testb %dil, %dil
je 0x34e26
leaq 0x4d5d4(%rip), %rdi # ... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_routing.c |
run_dijkstra | static void
_run_dijkstra(struct nhdp_domain *domain, int af_family, bool use_non_ss, bool use_ss) {
OONF_INFO(LOG_OLSRV2_ROUTING, "Run %s dijkstra on domain %d: %s/%s", af_family == AF_INET ? "ipv4" : "ipv6",
domain->index, use_non_ss ? "true" : "false", use_ss ? "true" : "false");
/* add direct neighbors to ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebp
movl %esi, %edx
movq %rdi, %r14
leaq 0x694df(%rip), %r13 # 0x9e4dc
movl (%r13), %esi
leaq 0x6a518(%rip), %rax # 0x9f520
movb (%rax,%rsi), %al
testb $0x2, %al
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
je 0x35090
cm... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_routing.c |
cb_metric_update | static void
_cb_metric_update(struct nhdp_domain *domain) {
if (!domain) {
list_for_each_element(nhdp_domain_get_list(), domain, _node) {
_cb_metric_update(domain);
}
return;
}
OONF_INFO(LOG_OLSRV2, "Metric update for domain %u", domain->index);
_update_ansn = true;
_domain_changed[domain-... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3560a
movq %rdi, %rbx
leaq 0x68f1c(%rip), %rax # 0x9e4c8
movl (%rax), %esi
leaq 0x69f6b(%rip), %rax # 0x9f520
testb $0x2, (%rax,%rsi)
je 0x355e8
movl 0x34(%rbx), %r10d
leaq 0x2368e(%rip), %r11 # 0x58c54
leaq 0x23606(%rip), %rdx # 0x58bd3
pushq $0x2
... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_routing.c |
update_routing_entry | static void
_update_routing_entry(struct nhdp_domain *domain, struct os_route_key *dst_prefix, const struct netaddr *dst_originator,
struct nhdp_neighbor *first_hop, uint8_t distance, uint32_t pathcost, uint8_t path_hops, bool single_hop,
const struct netaddr *last_originator) {
struct nhdp_neighbor_domaindata *n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, %r15d
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r12
movzbl 0x10(%rsi), %edi
callq 0x3323f
pushq $0x12
popq %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x19440
testl %eax, %eax
je 0x35aaa
... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_routing.c |
olsrv2_tc_endpoint_remove | void
olsrv2_tc_endpoint_remove(struct olsrv2_tc_attachment *net) {
oonf_class_event(&_tc_attached_class, net, OONF_OBJECT_REMOVED);
/* remove from node */
avl_remove(&net->src->_attached_networks, &net->_src_node);
/* remove from endpoint */
avl_remove(&net->dst->_attached_networks, &net->_endpoint_node);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4c37d(%rip), %rdi # 0x82038
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0x19c3e
movl $0x128, %edi # imm = 0x128
addq (%rbx), %rdi
leaq 0x28(%rbx), %rsi
callq 0x4286a
movl $0x88, %edi
addq 0x8(%rbx), %rdi
leaq 0x60(%rbx), %rsi
callq 0x4286a
movq 0x8(%... | /OLSR[P]OONF/src/olsrv2/olsrv2/olsrv2_tc.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.