From ae5243cc95eb31f992160be76857ced3cd43bc36 Mon Sep 17 00:00:00 2001 From: Jeff Becker Date: Mon, 21 May 2018 10:28:15 -0400 Subject: [PATCH] add clang format but don't format YET --- .clang-format | 34 +++++++++++ Makefile | 6 +- include/llarp/link.h | 7 +-- llarp/iwp_link.cpp | 140 +++++++++++++++++++++++++++++-------------- llarp/link.c | 4 +- llarp/net.hpp | 6 ++ 6 files changed, 146 insertions(+), 51 deletions(-) create mode 100644 .clang-format diff --git a/.clang-format b/.clang-format new file mode 100644 index 000000000..88c9a6952 --- /dev/null +++ b/.clang-format @@ -0,0 +1,34 @@ +--- +BasedOnStyle: Google +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: 'true' +AlignConsecutiveDeclarations: 'false' +AlignEscapedNewlinesLeft: 'true' +AlignOperands: 'false' +AlignTrailingComments: 'true' +AllowShortBlocksOnASingleLine: 'false' +AllowShortCaseLabelsOnASingleLine: 'false' +AllowShortFunctionsOnASingleLine: None +AllowShortIfStatementsOnASingleLine: 'false' +AllowShortLoopsOnASingleLine: 'false' +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakTemplateDeclarations: 'true' +BreakBeforeBinaryOperators: NonAssignment +BreakBeforeBraces: Allman +BreakBeforeTernaryOperators: 'true' +BreakConstructorInitializersBeforeComma: 'true' +Cpp11BracedListStyle: 'true' +KeepEmptyLinesAtTheStartOfBlocks: 'false' +Language: Cpp +NamespaceIndentation: All +PenaltyBreakString: '3' +SpaceBeforeParens: Never +SpacesInAngles: 'true' +SpacesInContainerLiterals: 'false' +SpacesInParentheses: 'false' +SpacesInSquareBrackets: 'false' +Standard: Cpp11 +UseTab: Never + +... diff --git a/Makefile b/Makefile index 8738f5721..a5432fa85 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,8 @@ all: remove-build clean compile remove-build: - rm -f build.ninja + rm -f build.ninja rules.ninja cmake_install.cmake CMakeCache.txt + rm -rf CMakeFiles clean: build.ninja ninja clean @@ -12,3 +13,6 @@ build.ninja: compile: build.ninja ninja + +format: + clang -i $(find daemon llarp include | grep -E '\.[h,c](pp)?$') diff --git a/include/llarp/link.h b/include/llarp/link.h index cace6894a..e8f6af87f 100644 --- a/include/llarp/link.h +++ b/include/llarp/link.h @@ -76,7 +76,9 @@ struct llarp_link { void (*try_establish)(struct llarp_link *, struct llarp_link_establish_job, struct llarp_link_session_listener); - struct llarp_link_session * (*acquire_session_for_addr)(struct llarp_link *, const struct sockaddr *); + /** + struct llarp_link_session * (*acquire_session_for_addr)(struct llarp_link *, const struct sockaddr *); + */ void (*mark_session_active)(struct llarp_link *, struct llarp_link_session *); void (*free_impl)(struct llarp_link *); }; @@ -90,9 +92,6 @@ struct llarp_link_session { /** send an entire message, splits up into smaller pieces and does encryption */ bool (*sendto)(struct llarp_link_session *, llarp_buffer_t); - /** receive raw data from link layer */ - void (*recv)(struct llarp_link_session *, const void *, size_t); - /** return true if this session is timed out */ bool (*timeout)(struct llarp_link_session *); /** explicit close session */ diff --git a/llarp/iwp_link.cpp b/llarp/iwp_link.cpp index b5862bc20..fa61ac7d1 100644 --- a/llarp/iwp_link.cpp +++ b/llarp/iwp_link.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include "crypto.hpp" @@ -18,6 +19,9 @@ namespace iwp { + // session activity timeout is 10s + constexpr llarp_time_t SESSION_TIMEOUT = 10000; + enum header_flag { eSessionInvalidated = (1 << 0), @@ -294,7 +298,7 @@ struct session frame_state frame; uint8_t token[32]; - uint8_t workbuf[1024]; + uint8_t workbuf[256]; enum State { @@ -350,33 +354,39 @@ struct session } } - // this is done in net threadpool - static void handle_recv(llarp_link_session * s, const void * buf, size_t sz) + // this is called from net thread + void recv(const void * buf, size_t sz) { - session * self = static_cast(s->impl); - switch (self->state) + switch (state) { case eIntroSent: // got intro ack - self->on_intro_ack(buf, sz); + on_intro_ack(buf, sz); return; case eEstablished: // session is started - self->decrypt_frame(buf, sz); + decrypt_frame(buf, sz); default: // invalid state? return; } } + + bool timedout(llarp_time_t now, llarp_time_t timeout=SESSION_TIMEOUT) + { + return now - frame.lastEvent >= timeout; + } + static bool is_timedout(llarp_link_session * s) { - return false; + auto now = llarp_time_now_ms(); + return static_cast(s->impl)->timedout(now); } static void close(llarp_link_session * s) { - + // TODO: implement } static void handle_verify_introack(iwp_async_introack * introack) @@ -456,7 +466,7 @@ struct session iwp_async_frame * alloc_frame(const void * buf, size_t sz) { - iwp_async_frame * frame = (iwp_async_frame*) mem->alloc(mem, sizeof(iwp_async_frame), 1024); + iwp_async_frame * frame = (iwp_async_frame*) mem->alloc(mem, sizeof(iwp_async_frame), 2048); memcpy(frame->buf, buf, sz); frame->sz = sz; frame->user = this; @@ -529,6 +539,10 @@ struct session struct server { + + typedef std::mutex mtx_t; + typedef std::lock_guard lock_t; + llarp_alloc * mem; llarp_logic * logic; llarp_crypto * crypto; @@ -538,7 +552,11 @@ struct server llarp_udp_io udp; char keyfile[255]; uint32_t timeout_job_id; - std::map sessions; + + typedef std::map LinkMap_t; + + LinkMap_t m_sessions; + mtx_t m_sessions_Mutex; llarp_seckey_t seckey; @@ -550,23 +568,74 @@ struct server iwp = llarp_async_iwp_new(mem, crypto, logic, w); } - session * create_session(llarp::Addr & src) + session * create_session(const llarp::Addr & src) + { + return new session(mem, muxer, &udp, iwp, crypto, logic, src); + } + + void put_session(const llarp::Addr & src, session * impl) { - session * impl = new session(mem, muxer, &udp, iwp, crypto, logic, src); llarp_link_session s; + llarp::Zero(&s, sizeof(s)); + src.CopyInto(s.addr); s.impl = impl; - s.sendto = session::sendto; - s.recv = session::handle_recv; - s.timeout = session::is_timedout; - s.close = session::close; - sessions[src] = s; - return impl; + s.sendto = &session::sendto; + s.timeout = &session::is_timedout; + s.close = &session::close; + { + lock_t lock(m_sessions_Mutex); + m_sessions[src] = s; + } } + session * ensure_session(const llarp::Addr & src) + { + session * s = nullptr; + bool put = false; + // TODO: will this be a bottleneck since it's called in a hot path? + { + lock_t lock(m_sessions_Mutex); + auto itr = m_sessions.find(src); + if (itr == m_sessions.end()) + { + // new inbound session + s = create_session(src); + put = true; + } + else + s = static_cast(itr->second.impl); + } + if(put) + put_session(src, s); + return s; + } + + void cleanup_dead() { - // todo: implement - printf("cleanup dead\n"); + auto now = llarp_time_now_ms(); + std::vector remove; + printf("cleanup dead at %ld\n", now); + { + lock_t lock(m_sessions_Mutex); + for (auto & itr : m_sessions) + { + session * s = static_cast(itr.second.impl); + if(s->timedout(now)) + remove.push_back(itr.first); + } + + for (const auto & addr : remove) + { + auto itr = m_sessions.find(addr); + if(itr != m_sessions.end()) + { + session * s = static_cast(itr->second.impl); + m_sessions.erase(addr); + delete s; + } + } + } } uint8_t * pubkey() @@ -620,14 +689,8 @@ struct server { server * link = static_cast(udp->user); llarp::Addr src = *saddr; - auto itr = link->sessions.find(src); - if (itr == link->sessions.end()) - { - // new inbound session - link->create_session(src); - } - auto & session = link->sessions[src]; - session.recv(&session, buf, sz); + session * s = link->ensure_session(src); + s->recv(buf, sz); } void cancel_timer() @@ -738,7 +801,9 @@ void link_iter_sessions(struct llarp_link * l, struct llarp_link_session_iter * { server * link = static_cast(l->impl); iter->link = l; - for (auto & item : link->sessions) + // TODO: race condition with cleanup timer + server::LinkMap_t copy = link->m_sessions; + for (auto & item : copy) if(!iter->visit(iter, &item.second)) return; } @@ -754,19 +819,7 @@ void link_try_establish(struct llarp_link * l, struct llarp_link_establish_job j void link_mark_session_active(struct llarp_link * link, struct llarp_link_session * s) { -} - -struct llarp_link_session * link_session_for_addr(struct llarp_link * l, const struct sockaddr * saddr) -{ - if(saddr) - { - server * link = static_cast(l->impl); - for(auto & session : link->sessions) - { - if(session.second.addr == *saddr) return &link->sessions[session.first]; - } - } - return nullptr; + // TODO: implement } void link_free(struct llarp_link *l) @@ -790,7 +843,6 @@ void iwp_link_init(struct llarp_link * link, struct llarp_iwp_args args, struct link->stop_link = iwp::link_stop; link->iter_sessions = iwp::link_iter_sessions; link->try_establish = iwp::link_try_establish; - link->acquire_session_for_addr = iwp::link_session_for_addr; link->mark_session_active = iwp::link_mark_session_active; link->free_impl = iwp::link_free; } diff --git a/llarp/link.c b/llarp/link.c index 5e5c1d056..9c01a1d53 100644 --- a/llarp/link.c +++ b/llarp/link.c @@ -2,11 +2,11 @@ bool llarp_link_initialized(struct llarp_link * link) { - return link && link->impl && link->name && link->get_our_address && link->configure && link->start_link && link->stop_link && link->iter_sessions && link->try_establish && link->acquire_session_for_addr && link->mark_session_active && link->free_impl; + return link && link->impl && link->name && link->get_our_address && link->configure && link->start_link && link->stop_link && link->iter_sessions && link->try_establish && link->mark_session_active && link->free_impl; } bool llarp_link_session_initialized(struct llarp_link_session * s) { - return s && s->impl && s->sendto && s->recv && s->timeout && s->close; + return s && s->impl && s->sendto && s->timeout && s->close; } diff --git a/llarp/net.hpp b/llarp/net.hpp index 86446b6f4..6446295ad 100644 --- a/llarp/net.hpp +++ b/llarp/net.hpp @@ -84,6 +84,12 @@ namespace llarp memcpy(saddr.sa_data, other.sa_data, sizeof(saddr.sa_data)); } + void CopyInto(sockaddr & other) const + { + memcpy(other.sa_data, saddr.sa_data, sizeof(saddr.sa_data)); + other.sa_family = af; + } + operator const sockaddr * () const { return &saddr;