diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..6f03063 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +.idea/* linguist-generated \ No newline at end of file diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml new file mode 100644 index 0000000..243415c --- /dev/null +++ b/.idea/codeStyles/Project.xml @@ -0,0 +1,71 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml new file mode 100644 index 0000000..79ee123 --- /dev/null +++ b/.idea/codeStyles/codeStyleConfig.xml @@ -0,0 +1,5 @@ + + + + \ No newline at end of file diff --git a/.idea/lowjs.iml b/.idea/lowjs.iml new file mode 100644 index 0000000..f08604b --- /dev/null +++ b/.idea/lowjs.iml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..8822db8 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..7b29195 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/saveactions_settings.xml b/.idea/saveactions_settings.xml new file mode 100644 index 0000000..7d35778 --- /dev/null +++ b/.idea/saveactions_settings.xml @@ -0,0 +1,12 @@ + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..6831ec8 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..8c124be --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,177 @@ +cmake_minimum_required(VERSION 3.12) +project(lowjs) + +if (UNIX AND NOT APPLE) + set(BUILD_SHARED_LIBS OFF) +endif () + + +find_package(Threads REQUIRED) + +set(CMAKE_C_STANDARD 11) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_FLAGS_DEBUG "-g -Wall -Wextra") +set(CMAKE_CXX_FLAGS_RELEASE "-O3") +set(CMAKE_C_FLAGS_DEBUG "-g -Wall -Wextra") +set(CMAKE_C_FLAGS_RELEASE "-O3") + +set(DEP_DUK ${PROJECT_SOURCE_DIR}/deps/duktape) +set(DEP_ARES ${PROJECT_SOURCE_DIR}/deps/c-ares) +set(DEP_MBED ${PROJECT_SOURCE_DIR}/deps/mbedtls) + +set(ENABLE_TESTING OFF) +set(CARES_STATIC ON) +set(CARES_SHARED OFF) +add_subdirectory(${DEP_MBED}) +add_subdirectory(${DEP_ARES}) + +set(MBEDTLS_INCLUDE_DIRS ${DEP_MBED}/include) + +set(DUK_BUILD_FLAGS + "-DDUK_USE_FATAL_HANDLER" + "-DDUK_USE_GLOBAL_BUILTIN" + "-DDUK_USE_BOOLEAN_BUILTIN" + "-DDUK_USE_ARRAY_BUILTIN" + "-DDUK_USE_OBJECT_BUILTIN" + "-DDUK_USE_FUNCTION_BUILTIN" + "-DDUK_USE_STRING_BUILTIN" + "-DDUK_USE_NUMBER_BUILTIN" + "-DDUK_USE_DATE_BUILTIN" + "-DDUK_USE_REGEXP_SUPPORT" + "-DDUK_USE_MATH_BUILTIN" + "-DDUK_USE_JSON_BUILTIN" + "-DDUK_USE_BUFFEROBJECT_SUPPORT" + "-DDUK_USE_ENCODING_BUILTINS" + "-DDUK_USE_PERFORMANCE_BUILTIN" + "-DDUK_USE_OBJECT_BUILTIN" + "-DDUK_USE_ES6_PROXY" + "-DDUK_USE_GLOBAL_BINDING" + "-DDUK_USE_SYMBOL_BUILTIN" + "-DDUK_USE_SECTION_B" + ) + +add_custom_command( + COMMENT "Making duktape" VERBATIM + WORKING_DIRECTORY ${DEP_DUK} + OUTPUT ${DEP_DUK}/src-low/duktape.c + DEPENDS "${DEP_DUK}/src-input/" + COMMAND rm -rf ${DEP_DUK}/src-low + COMMAND python tools/configure.py --output-directory=src-low ${DUK_BUILD_FLAGS} +) + +add_custom_command( + COMMENT "Installing Node modules" VERBATIM + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + OUTPUT ${PROJECT_SOURCE_DIR}/node_modules/ + DEPENDS "${PROJECT_SOURCE_DIR}/package.json" + COMMAND pnpm install +) + +add_custom_command( + COMMENT "Making JavaScript modules" VERBATIM + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + OUTPUT ${PROJECT_SOURCE_DIR}/lib/ + DEPENDS dukc ${PROJECT_SOURCE_DIR}/node_modules/ + COMMAND rm -rf lib lib_js/build + COMMAND cd lib_js && node ../node_modules/typescript/bin/tsc + COMMAND mkdir lib + COMMAND ./util/dukc lib_js/build lib +) + +add_custom_target( + lowjs_lib + DEPENDS ${PROJECT_SOURCE_DIR}/lib/ +) + +# dukc +add_executable( + dukc + ${PROJECT_SOURCE_DIR}/util/dukc.c +) +target_include_directories( + dukc + PRIVATE ${DEP_DUK}/src-low/ +) +target_link_libraries( + dukc + duktape m +) +set_target_properties(dukc PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/util) + +# duktape +add_library( + duktape STATIC + ${DEP_DUK}/src-low/duktape.c +) +target_include_directories( + duktape + PRIVATE ${DEP_DUK}/src-low/ +) + +# lowjs +file(GLOB lowjs_src + ${PROJECT_SOURCE_DIR}/src/*.c + ${PROJECT_SOURCE_DIR}/src/*.h + ${PROJECT_SOURCE_DIR}/src/*.cpp + ) + +add_library( + lowjs STATIC + ${lowjs_src} +) + +target_include_directories( + lowjs + PRIVATE ${PROJECT_SOURCE_DIR}/include + PRIVATE ${PROJECT_SOURCE_DIR}/app + PUBLIC ${DEP_DUK}/src-low/ + PUBLIC ${MBEDTLS_INCLUDE_DIRS} +) +target_link_libraries( + lowjs + mbedtls duktape c-ares m ${CMAKE_THREAD_LIBS_INIT} + -static-libstdc++ -static-libgcc +) + +add_dependencies( + lowjs + mbedtls duktape c-ares +) + +# lowjs_main +add_executable( + lowjs_main + ${PROJECT_SOURCE_DIR}/app/main.c +) +target_include_directories( + lowjs_main + PRIVATE ${PROJECT_SOURCE_DIR}/include + PRIVATE ${PROJECT_SOURCE_DIR}/app + PUBLIC ${DEP_DUK}/src-low/ +) +target_link_libraries( + lowjs_main + lowjs +) +add_dependencies(lowjs_main lowjs_lib) + +# lowjs_with_native_modules +file(GLOB lowjs_with_native_modules_src + ${PROJECT_SOURCE_DIR}/examples/low_with_native_module/*.c + ) + +add_executable( + lowjs_with_native_modules + ${lowjs_with_native_modules_src} +) +target_include_directories( + lowjs_with_native_modules + PRIVATE ${PROJECT_SOURCE_DIR}/include + PRIVATE ${PROJECT_SOURCE_DIR}/app + PUBLIC ${DEP_DUK}/src-low/ +) +target_link_libraries( + lowjs_with_native_modules + lowjs +) +add_dependencies(lowjs_with_native_modules lowjs_lib) diff --git a/deps/c-ares b/deps/c-ares index 330b364..b688805 160000 --- a/deps/c-ares +++ b/deps/c-ares @@ -1 +1 @@ -Subproject commit 330b364a9c12d82f7bb443509f92072e55465749 +Subproject commit b68880542360484368b49eca9dc6145318eb6b28 diff --git a/deps/duktape b/deps/duktape index f74b692..b062b50 160000 --- a/deps/duktape +++ b/deps/duktape @@ -1 +1 @@ -Subproject commit f74b692f724d655026a91eeac69d546e8eca6f47 +Subproject commit b062b50ab13c4a835d1403a3c39df97557bf09c4 diff --git a/deps/mbedtls b/deps/mbedtls index 53546ea..fb1972d 160000 --- a/deps/mbedtls +++ b/deps/mbedtls @@ -1 +1 @@ -Subproject commit 53546ea099f6f53d0be653a64accd250e170337f +Subproject commit fb1972db23da39bd11d4f9c9ea6266eee665605b diff --git a/lib_js/init.js b/lib_js/init.js index 8136808..e6b5d04 100644 --- a/lib_js/init.js +++ b/lib_js/init.js @@ -115,7 +115,7 @@ class Timeout { native.clearChore(this._id); this._id = native.setChore(this._func, this._delay, this._oneshot); } -v} +} exports.setTimeout = function (func, delay) { var cb_func; var bind_args; diff --git a/src/LowCryptoHash.cpp b/src/LowCryptoHash.cpp index 2eedc16..15f5481 100644 --- a/src/LowCryptoHash.cpp +++ b/src/LowCryptoHash.cpp @@ -11,23 +11,22 @@ // LowCryptoHash::LowCryptoHash // ----------------------------------------------------------------------------- -LowCryptoHash::LowCryptoHash(low_main_t *low, - const mbedtls_md_info_t *info, - unsigned char *key, - int key_len) : - mLow(low), - mIndex(-1), mHMAC(key ? true : false), mOutputSize(info->size) +LowCryptoHash::LowCryptoHash(low_main_t *low, const mbedtls_md_info_t *info, unsigned char *key, int key_len) : mLow( + low), mIndex(-1), mHMAC(key ? true : false), mOutputSize(info->size) { mbedtls_md_init(&mContext); int res = mbedtls_md_setup(&mContext, info, mHMAC ? 1 : 0); - if(res != 0) + if (res != 0) + { duk_generic_error(mLow->duk_ctx, "mbedtls error code #%d", res); + } - res = mHMAC ? mbedtls_md_hmac_starts(&mContext, key, key_len) - : mbedtls_md_starts(&mContext); - if(res != 0) + res = mHMAC ? mbedtls_md_hmac_starts(&mContext, key, key_len) : mbedtls_md_starts(&mContext); + if (res != 0) + { duk_generic_error(mLow->duk_ctx, "mbedtls error code #%d", res); + } } // ----------------------------------------------------------------------------- @@ -38,11 +37,12 @@ LowCryptoHash::~LowCryptoHash() { mbedtls_md_free(&mContext); - if(mIndex >= 0) + if (mIndex >= 0) { - if(mIndex >= mLow->cryptoHashes.size() || - mLow->cryptoHashes[mIndex] != this) + if (mIndex >= mLow->cryptoHashes.size() || mLow->cryptoHashes[mIndex] != this) + { printf("assertion error at LowCryptoHash\n"); + } mLow->cryptoHashes[mIndex] = NULL; } @@ -54,10 +54,11 @@ LowCryptoHash::~LowCryptoHash() void LowCryptoHash::Update(unsigned char *data, int len) { - int res = mHMAC ? mbedtls_md_hmac_update(&mContext, data, len) - : mbedtls_md_update(&mContext, data, len); - if(res != 0) + int res = mHMAC ? mbedtls_md_hmac_update(&mContext, data, len) : mbedtls_md_update(&mContext, data, len); + if (res != 0) + { duk_generic_error(mLow->duk_ctx, "mbedtls error code #%d", res); + } } // ----------------------------------------------------------------------------- @@ -66,8 +67,9 @@ void LowCryptoHash::Update(unsigned char *data, int len) void LowCryptoHash::Digest(unsigned char *data, int len) { - int res = mHMAC ? mbedtls_md_hmac_finish(&mContext, data) - : mbedtls_md_finish(&mContext, data); - if(res != 0) + int res = mHMAC ? mbedtls_md_hmac_finish(&mContext, data) : mbedtls_md_finish(&mContext, data); + if (res != 0) + { duk_generic_error(mLow->duk_ctx, "mbedtls error code #%d", res); + } } \ No newline at end of file diff --git a/src/LowCryptoHash.h b/src/LowCryptoHash.h index 5ad6367..0ddf04f 100644 --- a/src/LowCryptoHash.h +++ b/src/LowCryptoHash.h @@ -13,28 +13,29 @@ using namespace std; class LowCryptoHash { - public: - LowCryptoHash(low_main_t *low, - const mbedtls_md_info_t *info, - unsigned char *key, - int key_len); - ~LowCryptoHash(); +public: + LowCryptoHash(low_main_t *low, const mbedtls_md_info_t *info, unsigned char *key, int key_len); - void SetIndex(int index) { mIndex = index; } + ~LowCryptoHash(); - void Update(unsigned char *data, int len); - void Digest(unsigned char *data, int len); + void SetIndex(int index) + { mIndex = index; } - int OutputSize() { return mOutputSize; } + void Update(unsigned char *data, int len); - private: - low_main_t *mLow; - int mIndex; + void Digest(unsigned char *data, int len); - mbedtls_md_context_t mContext; + int OutputSize() + { return mOutputSize; } - bool mHMAC; - int mOutputSize; +private: + low_main_t *mLow; + int mIndex; + + mbedtls_md_context_t mContext; + + bool mHMAC; + int mOutputSize; }; #endif /* __LOWCRYPTOHASH_H__ */ \ No newline at end of file diff --git a/src/LowDNSResolver.cpp b/src/LowDNSResolver.cpp index 4ce9f8c..a8257a8 100644 --- a/src/LowDNSResolver.cpp +++ b/src/LowDNSResolver.cpp @@ -3,6 +3,7 @@ // ----------------------------------------------------------------------------- #include "low_config.h" + #if LOW_INCLUDE_CARES_RESOLVER #include "LowDNSResolver.h" diff --git a/src/LowDNSResolver.h b/src/LowDNSResolver.h index 97891e5..1614dfd 100644 --- a/src/LowDNSResolver.h +++ b/src/LowDNSResolver.h @@ -13,94 +13,105 @@ struct low_main_t; class LowDNSResolver { - friend class LowDNSResolver_Query; - friend class LowDNSResolver_GetHostByAddr; + friend class LowDNSResolver_Query; - public: - LowDNSResolver(low_main_t *low); - virtual ~LowDNSResolver(); + friend class LowDNSResolver_GetHostByAddr; - bool Init(); - void Cancel(); +public: + LowDNSResolver(low_main_t *low); - struct ares_addr_port_node *GetServers(int &err); - int SetServers(struct ares_addr_port_node *list); + virtual ~LowDNSResolver(); - ares_channel &Channel() { return mChannel; } - bool IsActive() { return mActiveQueries != 0; } + bool Init(); - static int AresErr(int err); + void Cancel(); - private: - low_main_t *mLow; + struct ares_addr_port_node *GetServers(int &err); - ares_channel mChannel; - int mIndex, mActiveQueries; + int SetServers(struct ares_addr_port_node *list); + + ares_channel &Channel() + { return mChannel; } + + bool IsActive() + { return mActiveQueries != 0; } + + static int AresErr(int err); + +private: + low_main_t *mLow; + + ares_channel mChannel; + int mIndex, mActiveQueries; }; class LowDNSResolver_Query : public LowLoopCallback { - public: - LowDNSResolver_Query(LowDNSResolver *resolver); - virtual ~LowDNSResolver_Query(); +public: + LowDNSResolver_Query(LowDNSResolver *resolver); - void Resolve(const char *hostname, const char *type, bool ttl, int refIndex, int callIndex); + virtual ~LowDNSResolver_Query(); - protected: - virtual bool OnLoop(); + void Resolve(const char *hostname, const char *type, bool ttl, int refIndex, int callIndex); - private: - void Callback(int status, int timeouts, unsigned char *abuf, int alen); - static void CallbackStatic(void *arg, int status, int timeouts, unsigned char *abuf, int alen) - { - ((LowDNSResolver_Query *)arg)->Callback(status, timeouts, abuf, alen); - } +protected: + virtual bool OnLoop(); - private: - LowDNSResolver *mResolver; - low_main_t *mLow; - ares_channel mChannel; +private: + void Callback(int status, int timeouts, unsigned char *abuf, int alen); - bool mTTL; - int mDNSType; + static void CallbackStatic(void *arg, int status, int timeouts, unsigned char *abuf, int alen) + { + ((LowDNSResolver_Query *) arg)->Callback(status, timeouts, abuf, alen); + } - int mRefID, mCallID, mError; - const char *mSyscall; +private: + LowDNSResolver *mResolver; + low_main_t *mLow; + ares_channel mChannel; - unsigned char *mData; - int mLen; + bool mTTL; + int mDNSType; - void *mDataFree, *mAresFree; - struct hostent *mHostFree; + int mRefID, mCallID, mError; + const char *mSyscall; + + unsigned char *mData; + int mLen; + + void *mDataFree, *mAresFree; + struct hostent *mHostFree; }; class LowDNSResolver_GetHostByAddr : public LowLoopCallback { - public: - LowDNSResolver_GetHostByAddr(LowDNSResolver *resolver); - virtual ~LowDNSResolver_GetHostByAddr(); +public: + LowDNSResolver_GetHostByAddr(LowDNSResolver *resolver); + + virtual ~LowDNSResolver_GetHostByAddr(); + + int Resolve(const char *hostname, int refIndex, int callIndex); - int Resolve(const char *hostname, int refIndex, int callIndex); +protected: + virtual bool OnLoop(); - protected: - virtual bool OnLoop(); +private: + void Callback(int status, int timeouts, struct hostent *hostent); - private: - void Callback(int status, int timeouts, struct hostent *hostent); - static void CallbackStatic(void *arg, int status, int timeouts, struct hostent *hostent) - { - ((LowDNSResolver_GetHostByAddr *)arg)->Callback(status, timeouts, hostent); - } + static void CallbackStatic(void *arg, int status, int timeouts, struct hostent *hostent) + { + ((LowDNSResolver_GetHostByAddr *) arg)->Callback(status, timeouts, hostent); + } - private: - LowDNSResolver *mResolver; - low_main_t *mLow; - ares_channel mChannel; +private: + LowDNSResolver *mResolver; + low_main_t *mLow; + ares_channel mChannel; - int mRefID, mCallID, mError; - const char *mSyscall; + int mRefID, mCallID, mError; + const char *mSyscall; - char **mResult; + char **mResult; }; #endif /* __LOWDNSRESOLVER_H__ */ diff --git a/src/LowDNSWorker.cpp b/src/LowDNSWorker.cpp index 9391c9d..4a1e20f 100644 --- a/src/LowDNSWorker.cpp +++ b/src/LowDNSWorker.cpp @@ -17,8 +17,7 @@ // LowDNSWorker::LowDNSWorker // ----------------------------------------------------------------------------- -LowDNSWorker::LowDNSWorker(low_main_t *low) - : LowLoopCallback(low), LowDataCallback(low), mLow(low), mResult(NULL) +LowDNSWorker::LowDNSWorker(low_main_t *low) : LowLoopCallback(low), LowDataCallback(low), mLow(low), mResult(NULL) { } @@ -30,15 +29,16 @@ LowDNSWorker::~LowDNSWorker() { low_data_clear_callback(mLow, this); if (mResult) + { freeaddrinfo(mResult); + } } // ----------------------------------------------------------------------------- // LowDNSWorker::Lookup // ----------------------------------------------------------------------------- -bool LowDNSWorker::Lookup(const char *host, int family, int hints, - int callIndex) +bool LowDNSWorker::Lookup(const char *host, int family, int hints, int callIndex) { if (strlen(host) >= sizeof(mHost)) { @@ -53,8 +53,10 @@ bool LowDNSWorker::Lookup(const char *host, int family, int hints, mHints = hints; mLookupService = false; mCallID = low_add_stash(mLow, callIndex); - if(!mCallID) + if (!mCallID) + { return false; + } mLow->run_ref++; low_data_set_callback(mLow, this, LOW_DATA_THREAD_PRIORITY_MODIFY); @@ -79,8 +81,10 @@ bool LowDNSWorker::LookupService(const char *ip, int port, int callIndex) mPort = port; mLookupService = true; mCallID = low_add_stash(mLow, callIndex); - if(!mCallID) + if (!mCallID) + { return false; + } mLow->run_ref++; low_data_set_callback(mLow, this, LOW_DATA_THREAD_PRIORITY_MODIFY); @@ -118,10 +122,14 @@ bool LowDNSWorker::OnLoop() while (info) { if (info->ai_family == AF_INET || info->ai_family == AF_INET6) + { break; + } } if (!info) + { mError = ENODATA; + } } if (mError) @@ -140,21 +148,17 @@ bool LowDNSWorker::OnLoop() addrinfo *info = mResult; while (info) { - if ((info->ai_family == AF_INET || - info->ai_family == AF_INET6) && - inet_ntop(info->ai_family, - info->ai_family == AF_INET - ? (void *)&((sockaddr_in *)info->ai_addr) - ->sin_addr.s_addr - : (void *)((sockaddr_in6 *)info->ai_addr) - ->sin6_addr.s6_addr, - mHost, sizeof(mHost)) != NULL) + if ((info->ai_family == AF_INET || info->ai_family == AF_INET6) && inet_ntop(info->ai_family, + info->ai_family == AF_INET + ? (void *) &((sockaddr_in *) info->ai_addr)->sin_addr.s_addr + : (void *) ((sockaddr_in6 *) info->ai_addr)->sin6_addr.s6_addr, + mHost, sizeof(mHost)) != + NULL) { duk_push_object(mLow->duk_ctx); duk_push_string(mLow->duk_ctx, mHost); duk_put_prop_string(mLow->duk_ctx, -2, "address"); - duk_push_int(mLow->duk_ctx, - info->ai_family == AF_INET ? 4 : 6); + duk_push_int(mLow->duk_ctx, info->ai_family == AF_INET ? 4 : 6); duk_put_prop_string(mLow->duk_ctx, -2, "family"); duk_put_prop_index(mLow->duk_ctx, -2, arr_len++); } @@ -195,7 +199,7 @@ bool LowDNSWorker::OnData() if (isIPv4) { - sockaddr_in *addr_in = (sockaddr_in *)&addr; + sockaddr_in *addr_in = (sockaddr_in * ) & addr; addr_in->sin_family = AF_INET; if (inet_pton(AF_INET, mIP, &addr_in->sin_addr) != 1) @@ -222,8 +226,7 @@ bool LowDNSWorker::OnData() addrLen = sizeof(sockaddr_in6); } - err = getnameinfo((sockaddr *)&addr, addrLen, mHost, sizeof(mHost), - mService, sizeof(mService), 0); + err = getnameinfo((sockaddr * ) & addr, addrLen, mHost, sizeof(mHost), mService, sizeof(mService), 0); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ } else @@ -237,44 +240,44 @@ bool LowDNSWorker::OnData() switch (err) { #if !LOW_ESP32_LWIP_SPECIALITIES - case EAI_ADDRFAMILY: - case EAI_SOCKTYPE: - err = LOW_EBADFAMILY; // should not happen, as we control this - break; - case EAI_BADFLAGS: - err = LOW_EBADFLAGS; - break; - case EAI_AGAIN: - err = EAGAIN; - break; - case EAI_NODATA: - err = LOW_ENODATA; - break; - case EAI_OVERFLOW: - err = LOW_EUNKNOWN; - break; - case EAI_SYSTEM: - err = errno; - break; + case EAI_ADDRFAMILY: + case EAI_SOCKTYPE: + err = LOW_EBADFAMILY; // should not happen, as we control this + break; + case EAI_BADFLAGS: + err = LOW_EBADFLAGS; + break; + case EAI_AGAIN: + err = EAGAIN; + break; + case EAI_NODATA: + err = LOW_ENODATA; + break; + case EAI_OVERFLOW: + err = LOW_EUNKNOWN; + break; + case EAI_SYSTEM: + err = errno; + break; #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - case EAI_SERVICE: - err = LOW_EBADFAMILY; // should not happen, as we control this - break; - case EAI_FAIL: - err = LOW_ESERVFAIL; - break; - case EAI_FAMILY: - err = LOW_EBADFAMILY; - break; - case EAI_MEMORY: - err = LOW_ENOMEM; - break; - case EAI_NONAME: - err = LOW_ENONAME; - break; - default: - err = LOW_EUNKNOWN; + case EAI_SERVICE: + err = LOW_EBADFAMILY; // should not happen, as we control this + break; + case EAI_FAIL: + err = LOW_ESERVFAIL; + break; + case EAI_FAMILY: + err = LOW_EBADFAMILY; + break; + case EAI_MEMORY: + err = LOW_ENOMEM; + break; + case EAI_NONAME: + err = LOW_ENONAME; + break; + default: + err = LOW_EUNKNOWN; } mError = err; diff --git a/src/LowDNSWorker.h b/src/LowDNSWorker.h index 298a6f0..3ba8234 100644 --- a/src/LowDNSWorker.h +++ b/src/LowDNSWorker.h @@ -15,26 +15,29 @@ struct low_main_t; class LowDNSWorker : public LowLoopCallback, public LowDataCallback { public: - LowDNSWorker(low_main_t *low); - virtual ~LowDNSWorker(); + LowDNSWorker(low_main_t *low); - bool Lookup(const char *host, int family, int hints, int callIndex); - bool LookupService(const char *ip, int port, int callIndex); + virtual ~LowDNSWorker(); + + bool Lookup(const char *host, int family, int hints, int callIndex); + + bool LookupService(const char *ip, int port, int callIndex); protected: - virtual bool OnLoop(); - virtual bool OnData(); + virtual bool OnLoop(); + + virtual bool OnData(); private: - low_main_t *mLow; + low_main_t *mLow; - char mIP[INET_ADDRSTRLEN]; - char mHost[64], mService[64]; - int mFamily, mHints, mPort, mCallID; - bool mLookupService; - int mError; + char mIP[INET_ADDRSTRLEN]; + char mHost[64], mService[64]; + int mFamily, mHints, mPort, mCallID; + bool mLookupService; + int mError; - struct addrinfo *mResult; + struct addrinfo *mResult; }; #endif /* __LOWDNSWORKER_H__ */ \ No newline at end of file diff --git a/src/LowDataCallback.h b/src/LowDataCallback.h index a21bf58..efdf130 100644 --- a/src/LowDataCallback.h +++ b/src/LowDataCallback.h @@ -9,29 +9,31 @@ struct low_main_t; class LowDataCallback { - friend void *low_data_thread_main(void *arg); - friend bool low_reset(low_main_t *low); - friend void low_data_set_callback(low_main_t *low, - LowDataCallback *callback, int priority); - friend void low_data_clear_callback(low_main_t *low, - LowDataCallback *callback); + friend void *low_data_thread_main(void *arg); + + friend bool low_reset(low_main_t *low); + + friend void low_data_set_callback(low_main_t *low, LowDataCallback *callback, int priority); + + friend void low_data_clear_callback(low_main_t *low, LowDataCallback *callback); public: - LowDataCallback(low_main_t *low) - : mLow(low), mNext(nullptr), mDataClearOnReset(true) - { - } - virtual ~LowDataCallback() { low_data_clear_callback(mLow, this); } + LowDataCallback(low_main_t *low) : mLow(low), mNext(nullptr), mDataClearOnReset(true) + { + } + + virtual ~LowDataCallback() + { low_data_clear_callback(mLow, this); } protected: - virtual bool OnData() = 0; + virtual bool OnData() = 0; private: - low_main_t *mLow; - LowDataCallback *mNext; + low_main_t *mLow; + LowDataCallback *mNext; protected: - bool mDataClearOnReset; + bool mDataClearOnReset; }; #endif /* __LOWDATACALLBACK_H__ */ \ No newline at end of file diff --git a/src/LowFD.h b/src/LowFD.h index ad2c48b..fed84ff 100644 --- a/src/LowFD.h +++ b/src/LowFD.h @@ -10,71 +10,86 @@ enum LowFDType { - LOWFD_TYPE_FILE, - LOWFD_TYPE_SERVER, - LOWFD_TYPE_SOCKET, - LOWFD_TYPE_CUSTOM + LOWFD_TYPE_FILE, LOWFD_TYPE_SERVER, LOWFD_TYPE_SOCKET, LOWFD_TYPE_CUSTOM }; class LowFD { - friend void *low_web_thread_main(void *arg); - friend bool low_reset(low_main_t *low); - friend void low_web_set_poll_events(low_main_t *low, LowFD *fd, - short events); - friend void low_web_clear_poll(low_main_t *low, LowFD *fd); - friend void low_web_mark_delete(low_main_t *low, LowFD *fd); + friend void *low_web_thread_main(void *arg); + + friend bool low_reset(low_main_t *low); + + friend void low_web_set_poll_events(low_main_t *low, LowFD *fd, short events); + + friend void low_web_clear_poll(low_main_t *low, LowFD *fd); + + friend void low_web_mark_delete(low_main_t *low, LowFD *fd); public: - LowFD(low_main_t *low, LowFDType type, int fd = -1) - : mLow(low), mFD(fd), mAdvertisedFD(-1), mFDType(type), - mMarkDelete(false), mPollIndex(-1), mPollEvents(0), - mNextChanged(nullptr), mFDClearOnReset(true) - { - } - virtual ~LowFD() - { - if(mAdvertisedFD >= 0) - mLow->fds.erase(mAdvertisedFD); - low_web_clear_poll(mLow, this); - } - - virtual void Read(int pos, unsigned char *data, int len, int callIndex) = 0; - virtual void Write(int pos, unsigned char *data, int len, - int callIndex) = 0; - virtual bool Close(int callIndex) = 0; - - LowFDType FDType() { return mFDType; } - int &FD() { return mFD; } - int PollEvents() { return mPollEvents; } - - void SetFD(int fd) { mFD = fd; } - void AdvertiseFD() - { - if(mAdvertisedFD >= 0) - mLow->fds.erase(mAdvertisedFD); - mAdvertisedFD = mFD; - if(mAdvertisedFD >= 0) - mLow->fds[mAdvertisedFD] = this; - } + LowFD(low_main_t *low, LowFDType type, int fd = -1) : mLow(low), mFD(fd), mAdvertisedFD(-1), mFDType(type), + mMarkDelete(false), mPollIndex(-1), mPollEvents(0), + mNextChanged(nullptr), mFDClearOnReset(true) + { + } + + virtual ~LowFD() + { + if (mAdvertisedFD >= 0) + { + mLow->fds.erase(mAdvertisedFD); + } + low_web_clear_poll(mLow, this); + } + + virtual void Read(int pos, unsigned char *data, int len, int callIndex) = 0; + + virtual void Write(int pos, unsigned char *data, int len, int callIndex) = 0; + + virtual bool Close(int callIndex) = 0; + + LowFDType FDType() + { return mFDType; } + + int &FD() + { return mFD; } + + int PollEvents() + { return mPollEvents; } + + void SetFD(int fd) + { mFD = fd; } + + void AdvertiseFD() + { + if (mAdvertisedFD >= 0) + { + mLow->fds.erase(mAdvertisedFD); + } + mAdvertisedFD = mFD; + if (mAdvertisedFD >= 0) + { + mLow->fds[mAdvertisedFD] = this; + } + } protected: - virtual bool OnEvents(short events) { return true; } + virtual bool OnEvents(short events) + { return true; } private: - low_main_t *mLow; + low_main_t *mLow; - int mFD, mAdvertisedFD; - LowFDType mFDType; - bool mMarkDelete; + int mFD, mAdvertisedFD; + LowFDType mFDType; + bool mMarkDelete; - int mPollIndex; - short mPollEvents; + int mPollIndex; + short mPollEvents; - LowFD *mNextChanged; + LowFD *mNextChanged; protected: - bool mFDClearOnReset; + bool mFDClearOnReset; }; #endif /* __LOWFD_H__ */ \ No newline at end of file diff --git a/src/LowFSMisc.cpp b/src/LowFSMisc.cpp index dd55a38..a989eb5 100644 --- a/src/LowFSMisc.cpp +++ b/src/LowFSMisc.cpp @@ -27,9 +27,8 @@ // LowFSMisc::LowFSMisc // ----------------------------------------------------------------------------- -LowFSMisc::LowFSMisc(low_main_t *low) : - LowDataCallback(low), LowLoopCallback(low), mLow(low), mCallID(0), - mOldName(NULL), mNewName(NULL), mFileEntries(NULL) +LowFSMisc::LowFSMisc(low_main_t *low) : LowDataCallback(low), LowLoopCallback(low), mLow(low), mCallID(0), + mOldName(NULL), mNewName(NULL), mFileEntries(NULL) { pthread_mutex_init(&mMutex, NULL); } @@ -43,18 +42,22 @@ LowFSMisc::~LowFSMisc() { low_data_clear_callback(mLow, this); - if(mOldName) + if (mOldName) + { low_free(mOldName); - if(mNewName) + } + if (mNewName) + { low_free(mNewName); - while(mFileEntries) + } + while (mFileEntries) { - char *entry = *(char **)mFileEntries; + char *entry = *(char **) mFileEntries; free(mFileEntries); mFileEntries = entry; } - if(mCallID) + if (mCallID) { low_remove_stash(mLow, mCallID); mLow->run_ref--; @@ -97,7 +100,7 @@ void LowFSMisc::Rename(const char *old_name, const char *new_name) mOldName = low_strdup(old_name); mNewName = low_strdup(new_name); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(!mOldName || !mNewName) + if (!mOldName || !mNewName) { low_push_error(mLow, ENOMEM, "rename"); duk_throw(mLow->duk_ctx); @@ -130,7 +133,7 @@ void LowFSMisc::Unlink(const char *file_name) #else mOldName = low_strdup(file_name); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(!mOldName) + if (!mOldName) { low_push_error(mLow, ENOMEM, "rename"); duk_throw(mLow->duk_ctx); @@ -163,7 +166,7 @@ void LowFSMisc::Stat(const char *file_name) #else mOldName = low_strdup(file_name); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(!mOldName) + if (!mOldName) { low_push_error(mLow, ENOMEM, "rename"); duk_throw(mLow->duk_ctx); @@ -196,7 +199,7 @@ void LowFSMisc::Access(const char *file_name, int mode) #else mOldName = low_strdup(file_name); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(!mOldName) + if (!mOldName) { low_push_error(mLow, ENOMEM, "mkdir"); duk_throw(mLow->duk_ctx); @@ -230,7 +233,7 @@ void LowFSMisc::ReadDir(const char *file_name, bool withFileTypes) #else mOldName = low_strdup(file_name); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(!mOldName) + if (!mOldName) { low_push_error(mLow, ENOMEM, "mkdir"); duk_throw(mLow->duk_ctx); @@ -264,7 +267,7 @@ void LowFSMisc::MkDir(const char *file_name, bool recursive, int mode) #else mOldName = low_strdup(file_name); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(!mOldName) + if (!mOldName) { low_push_error(mLow, ENOMEM, "mkdir"); duk_throw(mLow->duk_ctx); @@ -299,7 +302,7 @@ void LowFSMisc::RmDir(const char *file_name) #else mOldName = low_strdup(file_name); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(!mOldName) + if (!mOldName) { low_push_error(mLow, ENOMEM, "rmdir"); duk_throw(mLow->duk_ctx); @@ -317,17 +320,19 @@ void LowFSMisc::RmDir(const char *file_name) void LowFSMisc::Run(int callIndex) { - if(callIndex) + if (callIndex) { mCallID = low_add_stash(mLow, callIndex); mLow->run_ref++; } else + { pthread_mutex_lock(&mMutex); + } low_data_set_callback(mLow, this, LOW_DATA_THREAD_PRIORITY_MODIFY); - if(!callIndex) + if (!callIndex) { pthread_mutex_lock(&mMutex); OnLoop(); @@ -340,39 +345,44 @@ void LowFSMisc::Run(int callIndex) // ----------------------------------------------------------------------------- #if !LOW_ESP32_LWIP_SPECIALITIES + void LowFSMisc::ReadDir() { DIR *dir = opendir(mOldName); - if(!dir) + if (!dir) { mError = errno; return; } struct dirent dirData, *ent; - while(true) + while (true) { - if(readdir_r(dir, &dirData, &ent) != 0 || !ent) + if (readdir_r(dir, &dirData, &ent) != 0 || !ent) + { break; - if(ent->d_name[0] == '.' && - (ent->d_name[1] == '\0' || (ent->d_name[1] == '.' && ent->d_name[2] == '\0'))) + } + if (ent->d_name[0] == '.' && (ent->d_name[1] == '\0' || (ent->d_name[1] == '.' && ent->d_name[2] == '\0'))) + { continue; + } int len = strlen(ent->d_name); - char *entry = (char *)low_alloc(sizeof(char *) + len + 1); - if(!entry) + char *entry = (char *) low_alloc(sizeof(char *) + len + 1); + if (!entry) { closedir(dir); errno = ENOMEM; return; } - *(char **)entry = mFileEntries; + *(char **) entry = mFileEntries; memcpy(entry + sizeof(char *), ent->d_name, len + 1); mFileEntries = entry; } closedir(dir); } + #endif /* LOW_ESP32_LWIP_SPECIALITIES */ // ----------------------------------------------------------------------------- @@ -387,16 +397,18 @@ int data_rename(char *file_old, char *file_new, bool copy, bool overwrite); bool LowFSMisc::OnData() { - switch(mPhase) + switch (mPhase) { case LOWFSMISC_PHASE_RENAME: mError = 0; #if LOW_ESP32_LWIP_SPECIALITIES - if(data_rename(mOldName, mNewName, false, true) != 0) - mError = errno; + if(data_rename(mOldName, mNewName, false, true) != 0) + mError = errno; #else - if(rename(mOldName, mNewName) != 0) + if (rename(mOldName, mNewName) != 0) + { mError = errno; + } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ low_free(mNewName); @@ -406,22 +418,26 @@ bool LowFSMisc::OnData() case LOWFSMISC_PHASE_UNLINK: mError = 0; #if LOW_ESP32_LWIP_SPECIALITIES - if(data_unlink(mOldName, false, 0) != 0) - mError = errno; + if(data_unlink(mOldName, false, 0) != 0) + mError = errno; #else - if(unlink(mOldName) != 0) + if (unlink(mOldName) != 0) + { mError = errno; + } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ break; case LOWFSMISC_PHASE_RMDIR: mError = 0; #if LOW_ESP32_LWIP_SPECIALITIES - if(data_unlink(mOldName, false, 1) != 0) - mError = errno; + if(data_unlink(mOldName, false, 1) != 0) + mError = errno; #else - if(rmdir(mOldName) != 0) + if (rmdir(mOldName) != 0) + { mError = errno; + } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ break; @@ -433,14 +449,14 @@ bool LowFSMisc::OnData() case LOWFSMISC_PHASE_MKDIR: mError = 0; #if LOW_ESP32_LWIP_SPECIALITIES - if(data_mkdir(mOldName, mRecursive) != 0) - mError = errno; + if(data_mkdir(mOldName, mRecursive) != 0) + mError = errno; #else - if(mRecursive) + if (mRecursive) { - for(int i = 0; mOldName[i]; i++) + for (int i = 0; mOldName[i]; i++) { - if(mOldName[i] == '/') + if (mOldName[i] == '/') { mOldName[i] = '\0'; mkdir(mOldName, mMode); @@ -448,31 +464,39 @@ bool LowFSMisc::OnData() } } } - if(mkdir(mOldName, mMode) != 0) + if (mkdir(mOldName, mMode) != 0) + { mError = errno; + } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ break; case LOWFSMISC_PHASE_STAT: mError = 0; - if(stat(mOldName, &mStat) != 0) - mError = errno; + if (stat(mOldName, &mStat) != 0) + mError = errno; break; case LOWFSMISC_PHASE_ACCESS: mError = 0; - if(access(mOldName, mMode) != 0) + if (access(mOldName, mMode) != 0) + { mError = errno; + } break; } low_free(mOldName); mOldName = NULL; - if(mCallID) + if (mCallID) + { low_loop_set_callback(mLow, this); + } else + { pthread_mutex_unlock(&mMutex); + } return true; } @@ -483,7 +507,7 @@ bool LowFSMisc::OnData() bool LowFSMisc::OnLoop() { bool isAsync = mCallID != 0; - if(isAsync) + if (isAsync) { int callID = mCallID; mCallID = 0; @@ -491,80 +515,100 @@ bool LowFSMisc::OnLoop() low_push_stash(mLow, callID, true); } - if(mError) + if (mError) { - if(mPhase == LOWFSMISC_PHASE_RENAME) + if (mPhase == LOWFSMISC_PHASE_RENAME) + { low_push_error(mLow, mError, "rename"); - else if(mPhase == LOWFSMISC_PHASE_UNLINK) + } + else if (mPhase == LOWFSMISC_PHASE_UNLINK) + { low_push_error(mLow, mError, "unlink"); - else if(mPhase == LOWFSMISC_PHASE_STAT) + } + else if (mPhase == LOWFSMISC_PHASE_STAT) + { low_push_error(mLow, mError, "stat"); - else if(mPhase == LOWFSMISC_PHASE_ACCESS) + } + else if (mPhase == LOWFSMISC_PHASE_ACCESS) + { low_push_error(mLow, mError, "access"); - else if(mPhase == LOWFSMISC_PHASE_READDIR) + } + else if (mPhase == LOWFSMISC_PHASE_READDIR) + { low_push_error(mLow, mError, "readdir"); - else if(mPhase == LOWFSMISC_PHASE_MKDIR) + } + else if (mPhase == LOWFSMISC_PHASE_MKDIR) + { low_push_error(mLow, mError, "mkdir"); - else if(mPhase == LOWFSMISC_PHASE_RMDIR) + } + else if (mPhase == LOWFSMISC_PHASE_RMDIR) + { low_push_error(mLow, mError, "rmdir"); + } else + { low_push_error(mLow, mError, "stat"); + } - if(!isAsync) + if (!isAsync) + { duk_throw(mLow->duk_ctx); + } } - else if(mPhase == LOWFSMISC_PHASE_STAT) + else if (mPhase == LOWFSMISC_PHASE_STAT) { - if(isAsync) + if (isAsync) + { duk_push_null(mLow->duk_ctx); + } duk_push_object(mLow->duk_ctx); #define applyStat(name) {#name, (double)mStat.st_##name} - duk_number_list_entry numberList[] = { - applyStat(dev), - applyStat(ino), - applyStat(mode), - applyStat(nlink), - applyStat(uid), - applyStat(gid), - applyStat(rdev), - applyStat(blksize), - applyStat(blocks), - applyStat(size), - {"atimeMs", mStat.st_atime * 1000.0}, - {"mtimeMs", mStat.st_mtime * 1000.0}, - {"ctimeMs", mStat.st_ctime * 1000.0}, - {NULL, 0.0}}; + duk_number_list_entry numberList[] = {applyStat(dev), applyStat(ino), applyStat(mode), applyStat(nlink), + applyStat(uid), applyStat(gid), applyStat(rdev), applyStat(blksize), + applyStat(blocks), applyStat(size), {"atimeMs", mStat.st_atime * 1000.0}, + {"mtimeMs", mStat.st_mtime * 1000.0}, + {"ctimeMs", mStat.st_ctime * 1000.0}, {NULL, 0.0}}; duk_put_number_list(mLow->duk_ctx, -1, numberList); - if(isAsync) + if (isAsync) + { duk_call(mLow->duk_ctx, 2); + } return false; } - else if(mPhase == LOWFSMISC_PHASE_READDIR) + else if (mPhase == LOWFSMISC_PHASE_READDIR) { - if(isAsync) + if (isAsync) + { duk_push_null(mLow->duk_ctx); + } duk_push_array(mLow->duk_ctx); int i = 0; - while(mFileEntries) + while (mFileEntries) { - char *entry = *(char **)mFileEntries; + char *entry = *(char **) mFileEntries; duk_push_string(mLow->duk_ctx, mFileEntries + sizeof(char *)); duk_put_prop_index(mLow->duk_ctx, -2, i++); mFileEntries = entry; } - if(isAsync) + if (isAsync) + { duk_call(mLow->duk_ctx, 2); + } return false; } - else if(isAsync) + else if (isAsync) + { duk_push_null(mLow->duk_ctx); - if(isAsync) + } + if (isAsync) + { duk_call(mLow->duk_ctx, 1); + } return false; } diff --git a/src/LowFSMisc.h b/src/LowFSMisc.h index 7c171b6..e0d9633 100644 --- a/src/LowFSMisc.h +++ b/src/LowFSMisc.h @@ -18,54 +18,59 @@ struct low_main_t; enum { - LOWFSMISC_PHASE_RENAME, - LOWFSMISC_PHASE_UNLINK, - LOWFSMISC_PHASE_STAT, - LOWFSMISC_PHASE_ACCESS, - LOWFSMISC_PHASE_READDIR, - LOWFSMISC_PHASE_MKDIR, - LOWFSMISC_PHASE_RMDIR + LOWFSMISC_PHASE_RENAME, + LOWFSMISC_PHASE_UNLINK, + LOWFSMISC_PHASE_STAT, + LOWFSMISC_PHASE_ACCESS, + LOWFSMISC_PHASE_READDIR, + LOWFSMISC_PHASE_MKDIR, + LOWFSMISC_PHASE_RMDIR }; -class LowFSMisc - : public LowDataCallback - , public LowLoopCallback +class LowFSMisc : public LowDataCallback, public LowLoopCallback { - public: - LowFSMisc(low_main_t *low); - virtual ~LowFSMisc(); +public: + LowFSMisc(low_main_t *low); - void Rename(const char *old_name, const char *new_name); - void Unlink(const char *file_name); - void Stat(const char *file_name); + virtual ~LowFSMisc(); - void Access(const char *file_name, int mode); - void ReadDir(const char *file_name, bool withFileTypes); - void MkDir(const char *file_name, bool recursive, int mode); - void RmDir(const char *file_name); + void Rename(const char *old_name, const char *new_name); - void Run(int callIndex = 0); + void Unlink(const char *file_name); - protected: - void ReadDir(); + void Stat(const char *file_name); - virtual bool OnData(); - virtual bool OnLoop(); + void Access(const char *file_name, int mode); - private: - low_main_t *mLow; - char *mOldName; - char *mNewName; + void ReadDir(const char *file_name, bool withFileTypes); - struct stat mStat; - bool mWithFileTypes, mRecursive; - int mMode; + void MkDir(const char *file_name, bool recursive, int mode); - int mCallID; - pthread_mutex_t mMutex; + void RmDir(const char *file_name); - int mPhase, mError; - char *mFileEntries; + void Run(int callIndex = 0); + +protected: + void ReadDir(); + + virtual bool OnData(); + + virtual bool OnLoop(); + +private: + low_main_t *mLow; + char *mOldName; + char *mNewName; + + struct stat mStat; + bool mWithFileTypes, mRecursive; + int mMode; + + int mCallID; + pthread_mutex_t mMutex; + + int mPhase, mError; + char *mFileEntries; }; #endif /* __LOWFSMISC_H__ */ diff --git a/src/LowFile.cpp b/src/LowFile.cpp index 419c702..cc71a35 100644 --- a/src/LowFile.cpp +++ b/src/LowFile.cpp @@ -23,18 +23,22 @@ // LowFile::LowFile // ----------------------------------------------------------------------------- -LowFile::LowFile(low_main_t *low, const char *path, int flags, int callID) : - LowFD(low, LOWFD_TYPE_FILE), LowDataCallback(low), LowLoopCallback(low), - mLow(low), mClose(false) +LowFile::LowFile(low_main_t *low, const char *path, int flags, int callID) : LowFD(low, LOWFD_TYPE_FILE), + LowDataCallback(low), LowLoopCallback(low), + mLow(low), mClose(false) { - if(callID) + if (callID) { mCallID = low_add_stash(mLow, callID); - if(mCallID) + if (mCallID) + { mLow->run_ref++; + } } else + { mCallID = 0; + } #if LOW_ESP32_LWIP_SPECIALITIES int len = 32 + strlen(path) + strlen(low->cwd); @@ -66,11 +70,15 @@ LowFile::~LowFile() { low_data_clear_callback(mLow, this); - if(FD() >= 0) + if (FD() >= 0) + { close(FD()); - if(mPath) + } + if (mPath) + { low_free(mPath); - if(mCallID) + } + if (mCallID) { low_remove_stash(mLow, mCallID); mLow->run_ref--; @@ -83,14 +91,14 @@ LowFile::~LowFile() void LowFile::Read(int pos, unsigned char *data, int len, int callIndex) { - if(mClose) + if (mClose) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EBADF, "read"); duk_call(mLow->duk_ctx, 1); return; } - if(mPhase != LOWFILE_PHASE_READY) + if (mPhase != LOWFILE_PHASE_READY) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EALREADY, "read"); @@ -98,14 +106,18 @@ void LowFile::Read(int pos, unsigned char *data, int len, int callIndex) return; } - if(callIndex != -1) + if (callIndex != -1) { mCallID = low_add_stash(mLow, callIndex); - if(mCallID) + if (mCallID) + { mLow->run_ref++; + } } else + { mCallID = 0; + } mPos = pos; mData = data; @@ -121,14 +133,14 @@ void LowFile::Read(int pos, unsigned char *data, int len, int callIndex) void LowFile::Write(int pos, unsigned char *data, int len, int callIndex) { - if(mClose) + if (mClose) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EBADF, "write"); duk_call(mLow->duk_ctx, 1); return; } - if(mPhase != LOWFILE_PHASE_READY) + if (mPhase != LOWFILE_PHASE_READY) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EALREADY, "write"); @@ -136,14 +148,18 @@ void LowFile::Write(int pos, unsigned char *data, int len, int callIndex) return; } - if(callIndex != -1) + if (callIndex != -1) { mCallID = low_add_stash(mLow, callIndex); - if(mCallID) + if (mCallID) + { mLow->run_ref++; + } } else + { mCallID = 0; + } mPos = pos; mData = data; @@ -159,14 +175,14 @@ void LowFile::Write(int pos, unsigned char *data, int len, int callIndex) void LowFile::FStat(int callIndex) { - if(mClose) + if (mClose) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EBADF, "fstat"); duk_call(mLow->duk_ctx, 1); return; } - if(mPhase != LOWFILE_PHASE_READY) + if (mPhase != LOWFILE_PHASE_READY) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EALREADY, "fstat"); @@ -174,14 +190,18 @@ void LowFile::FStat(int callIndex) return; } - if(callIndex != -1) + if (callIndex != -1) { mCallID = low_add_stash(mLow, callIndex); - if(mCallID) + if (mCallID) + { mLow->run_ref++; + } } else + { mCallID = 0; + } mPhase = LOWFILE_PHASE_FSTAT; mDataDone = false; @@ -194,14 +214,14 @@ void LowFile::FStat(int callIndex) bool LowFile::Close(int callIndex) { - if(mClose) + if (mClose) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EBADF, "close"); duk_call(mLow->duk_ctx, 1); return true; } - if(mPhase != LOWFILE_PHASE_READY) + if (mPhase != LOWFILE_PHASE_READY) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EALREADY, "close"); @@ -216,14 +236,18 @@ bool LowFile::Close(int callIndex) AdvertiseFD(); SetFD(fd); - if(callIndex != -1) + if (callIndex != -1) { mCallID = low_add_stash(mLow, callIndex); - if(mCallID) + if (mCallID) + { mLow->run_ref++; + } } else + { mCallID = 0; + } mPhase = LOWFILE_PHASE_CLOSING; mDataDone = false; @@ -238,7 +262,7 @@ bool LowFile::Close(int callIndex) bool LowFile::OnData() { - switch(mPhase) + switch (mPhase) { case LOWFILE_PHASE_OPENING: SetFD(open(mPath, mFlags, 0666)); @@ -254,18 +278,18 @@ bool LowFile::OnData() case LOWFILE_PHASE_READING: mError = 0; - if(mPos != -1) + if (mPos != -1) { - if(lseek(FD(), mPos, SEEK_SET) != mPos) + if (lseek(FD(), mPos, SEEK_SET) != mPos) { mError = errno; mSyscall = "lseek"; } } - if(!mError) + if (!mError) { mLen = read(FD(), mData, mLen); - if(mLen < 0) + if (mLen < 0) { mError = errno; mSyscall = "read"; @@ -278,18 +302,18 @@ bool LowFile::OnData() case LOWFILE_PHASE_WRITING: mError = 0; - if(mPos != -1) + if (mPos != -1) { - if(lseek(FD(), mPos, SEEK_SET) != mPos) + if (lseek(FD(), mPos, SEEK_SET) != mPos) { mError = errno; mSyscall = "lseek"; } } - if(!mError) + if (!mError) { mLen = write(FD(), mData, mLen); - if(mLen < 0) + if (mLen < 0) { mError = errno; mSyscall = "write"; @@ -309,7 +333,7 @@ bool LowFile::OnData() break; case LOWFILE_PHASE_CLOSING: - if(FD() >= 0) + if (FD() >= 0) { mError = close(FD()) < 0 ? errno : 0; mSyscall = "close"; @@ -329,8 +353,10 @@ bool LowFile::OnData() bool LowFile::OnLoop() { - if(mClose) + if (mClose) + { return false; + } FinishPhase(); return !mClose; } @@ -341,30 +367,37 @@ bool LowFile::OnLoop() bool LowFile::FinishPhase() { - if(mPhase == LOWFILE_PHASE_READY) + if (mPhase == LOWFILE_PHASE_READY) + { return true; - if(!mDataDone) + } + if (!mDataDone) + { return false; + } int phase = mPhase; mPhase = LOWFILE_PHASE_READY; - if(phase == LOWFILE_PHASE_OPENING && !mError) + if (phase == LOWFILE_PHASE_OPENING && !mError) + { AdvertiseFD(); - if((phase == LOWFILE_PHASE_OPENING && mError) || - phase == LOWFILE_PHASE_CLOSING) + } + if ((phase == LOWFILE_PHASE_OPENING && mError) || phase == LOWFILE_PHASE_CLOSING) + { mClose = true; + } - if(mCallID) + if (mCallID) { int callID = mCallID; mCallID = 0; mLow->run_ref--; - switch(phase) + switch (phase) { case LOWFILE_PHASE_OPENING: - if(mError) + if (mError) { low_push_stash(mLow, callID, true); low_push_error(mLow, mError, mSyscall); @@ -383,7 +416,7 @@ bool LowFile::FinishPhase() case LOWFILE_PHASE_READING: case LOWFILE_PHASE_WRITING: low_push_stash(mLow, callID, true); - if(mError) + if (mError) { low_push_error(mLow, mError, mSyscall); duk_call(mLow->duk_ctx, 1); @@ -398,7 +431,7 @@ bool LowFile::FinishPhase() case LOWFILE_PHASE_FSTAT: low_push_stash(mLow, callID, true); - if(mError) + if (mError) { low_push_error(mLow, mError, mSyscall); duk_call(mLow->duk_ctx, 1); @@ -409,21 +442,12 @@ bool LowFile::FinishPhase() duk_push_object(mLow->duk_ctx); #define applyStat(name) {#name, (double)mStat.st_##name} - duk_number_list_entry numberList[] = { - applyStat(dev), - applyStat(ino), - applyStat(mode), - applyStat(nlink), - applyStat(uid), - applyStat(gid), - applyStat(rdev), - applyStat(blksize), - applyStat(blocks), - applyStat(size), - {"atimeMs", mStat.st_atime * 1000.0}, - {"mtimeMs", mStat.st_mtime * 1000.0}, - {"ctimeMs", mStat.st_ctime * 1000.0}, - {NULL, 0.0}}; + duk_number_list_entry numberList[] = {applyStat(dev), applyStat(ino), applyStat(mode), + applyStat(nlink), applyStat(uid), applyStat(gid), + applyStat(rdev), applyStat(blksize), applyStat(blocks), + applyStat(size), {"atimeMs", mStat.st_atime * 1000.0}, + {"mtimeMs", mStat.st_mtime * 1000.0}, + {"ctimeMs", mStat.st_ctime * 1000.0}, {NULL, 0.0}}; duk_put_number_list(mLow->duk_ctx, -1, numberList); duk_call(mLow->duk_ctx, 2); @@ -432,15 +456,19 @@ bool LowFile::FinishPhase() case LOWFILE_PHASE_CLOSING: low_push_stash(mLow, callID, true); - if(mError) + if (mError) + { low_push_error(mLow, mError, mSyscall); + } else + { duk_push_null(mLow->duk_ctx); + } duk_call(mLow->duk_ctx, 1); return true; } } - else if(mError) + else if (mError) { low_push_error(mLow, mError, mSyscall); duk_throw(mLow->duk_ctx); diff --git a/src/LowFile.h b/src/LowFile.h index 676e51e..01ff8d6 100644 --- a/src/LowFile.h +++ b/src/LowFile.h @@ -17,47 +17,49 @@ struct low_main_t; enum { - LOWFILE_PHASE_OPENING, - LOWFILE_PHASE_READY, - LOWFILE_PHASE_READING, - LOWFILE_PHASE_WRITING, - LOWFILE_PHASE_FSTAT, - LOWFILE_PHASE_CLOSING + LOWFILE_PHASE_OPENING, + LOWFILE_PHASE_READY, + LOWFILE_PHASE_READING, + LOWFILE_PHASE_WRITING, + LOWFILE_PHASE_FSTAT, + LOWFILE_PHASE_CLOSING }; -class LowFile - : public LowFD - , public LowDataCallback - , public LowLoopCallback +class LowFile : public LowFD, public LowDataCallback, public LowLoopCallback { - public: - LowFile(low_main_t *low, const char *path, int flags, int callIndex); - virtual ~LowFile(); - - void Read(int pos, unsigned char *data, int len, int callIndex); - void Write(int pos, unsigned char *data, int len, int callIndex); - void FStat(int callIndex); - bool Close(int callIndex); - - bool FinishPhase(); - - protected: - virtual bool OnData(); - virtual bool OnLoop(); - - private: - low_main_t *mLow; - char *mPath; - int mFlags; - - unsigned char *mData; - int mPos, mLen; - struct stat mStat; - int mCallID; - - int mPhase, mError; - const char *mSyscall; - bool mDataDone, mClose; +public: + LowFile(low_main_t *low, const char *path, int flags, int callIndex); + + virtual ~LowFile(); + + void Read(int pos, unsigned char *data, int len, int callIndex); + + void Write(int pos, unsigned char *data, int len, int callIndex); + + void FStat(int callIndex); + + bool Close(int callIndex); + + bool FinishPhase(); + +protected: + virtual bool OnData(); + + virtual bool OnLoop(); + +private: + low_main_t *mLow; + char *mPath; + int mFlags; + + unsigned char *mData; + int mPos, mLen; + struct stat mStat; + int mCallID; + + int mPhase, mError; + const char *mSyscall; + bool mDataDone, mClose; }; #endif /* __LOWFILE_H__ */ \ No newline at end of file diff --git a/src/LowHTTPDirect.cpp b/src/LowHTTPDirect.cpp index 99bdf7d..cd456c9 100644 --- a/src/LowHTTPDirect.cpp +++ b/src/LowHTTPDirect.cpp @@ -14,12 +14,13 @@ // LowHTTPDirect::LowHTTPDirect // ----------------------------------------------------------------------------- -LowHTTPDirect::LowHTTPDirect(low_main_t *low, bool isServer) : - LowLoopCallback(low), mLow(low), mIsServer(isServer), mRequestCallID(0), - mReadCallID(0), mWriteCallID(0), mBytesRead(0), mBytesWritten(0), - mParamFirst(NULL), mParamLast(NULL), mWriteBufferCount(0), mShutdown(false), - mClosed(false), mEraseNextN(false), mReadData(NULL), mRemainingRead(NULL), - mReadError(false), mWriteError(false), mHTTPError(false) +LowHTTPDirect::LowHTTPDirect(low_main_t *low, bool isServer) : LowLoopCallback(low), mLow(low), mIsServer(isServer), + mRequestCallID(0), mReadCallID(0), mWriteCallID(0), + mBytesRead(0), mBytesWritten(0), mParamFirst(NULL), + mParamLast(NULL), mWriteBufferCount(0), mShutdown(false), + mClosed(false), mEraseNextN(false), mReadData(NULL), + mRemainingRead(NULL), mReadError(false), + mWriteError(false), mHTTPError(false) { pthread_mutex_init(&mMutex, NULL); Init(); @@ -31,27 +32,37 @@ LowHTTPDirect::LowHTTPDirect(low_main_t *low, bool isServer) : LowHTTPDirect::~LowHTTPDirect() { - if(mSocket) + if (mSocket) + { mSocket->SetDirect(NULL, 0); + } - if(mRequestCallID) + if (mRequestCallID) + { low_remove_stash(mLow, mRequestCallID); - if(mReadCallID) + } + if (mReadCallID) + { low_remove_stash(mLow, mReadCallID); - if(mWriteCallID) + } + if (mWriteCallID) + { low_remove_stash(mLow, mWriteCallID); + } - while(mParamFirst) + while (mParamFirst) { LowHTTPDirect_ParamData *param = mParamFirst; mParamFirst = mParamFirst->next; low_free(param); } - for(int i = 0; i < mWriteBufferCount; i++) + for (int i = 0; i < mWriteBufferCount; i++) { - if(mWriteBufferStashID[i]) + if (mWriteBufferStashID[i]) + { low_remove_stash(mLow, mWriteBufferStashID[i]); + } } pthread_mutex_destroy(&mMutex); @@ -81,7 +92,7 @@ void LowHTTPDirect::Init() mChunkedEncoding = false; mNoBodyDefault = false; - while(mParamFirst) + while (mParamFirst) { LowHTTPDirect_ParamData *param = mParamFirst; mParamFirst = mParamFirst->next; @@ -92,12 +103,12 @@ void LowHTTPDirect::Init() mWriting = false; mWriteDone = false; - if(mReadCallID) + if (mReadCallID) { low_remove_stash(mLow, mReadCallID); mReadCallID = 0; } - if(mWriteCallID) + if (mWriteCallID) { low_remove_stash(mLow, mWriteCallID); mWriteCallID = 0; @@ -110,18 +121,20 @@ void LowHTTPDirect::Init() void LowHTTPDirect::Detach(bool pushRemainingRead) { - if(pushRemainingRead) + if (pushRemainingRead) { low_web_clear_poll(mLow, mSocket); - if(mRemainingRead) - memcpy(duk_push_fixed_buffer(mLow->duk_ctx, mRemainingReadLen), - mRemainingRead, - mRemainingReadLen); + if (mRemainingRead) + { + memcpy(duk_push_fixed_buffer(mLow->duk_ctx, mRemainingReadLen), mRemainingRead, mRemainingReadLen); + } else + { duk_push_fixed_buffer(mLow->duk_ctx, 0); + } } - if(mSocket) + if (mSocket) { mSocket->SetDirect(NULL, 0); mSocket = NULL; @@ -137,8 +150,10 @@ void LowHTTPDirect::Detach(bool pushRemainingRead) void LowHTTPDirect::SetRequestCallID(int callID) { mRequestCallID = callID; - if(mParamFirst || mClosed) + if (mParamFirst || mClosed) + { low_loop_set_callback(mLow, this); + } } // ----------------------------------------------------------------------------- @@ -147,7 +162,7 @@ void LowHTTPDirect::SetRequestCallID(int callID) void LowHTTPDirect::Read(unsigned char *data, int len, int callIndex) { - if(!mIsRequest || mReadData || !mSocket) + if (!mIsRequest || mReadData || !mSocket) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EAGAIN, "read"); @@ -160,31 +175,35 @@ void LowHTTPDirect::Read(unsigned char *data, int len, int callIndex) mReadLen = len; mReadData = data; - if(mRemainingRead && !mClosed) + if (mRemainingRead && !mClosed) { pthread_mutex_unlock(&mMutex); unsigned char *data = mRemainingRead; mRemainingRead = NULL; - if(SocketData(data, mRemainingReadLen, true)) + if (SocketData(data, mRemainingReadLen, true)) + { mSocket->TriggerDirect(LOWSOCKET_TRIGGER_READ); + } } else + { pthread_mutex_unlock(&mMutex); + } - if(mReadPos || mPhase == LOWHTTPDIRECT_PHASE_SENDING_RESPONSE || mClosed || - mReadError || mHTTPError) + if (mReadPos || mPhase == LOWHTTPDIRECT_PHASE_SENDING_RESPONSE || mClosed || mReadError || mHTTPError) { duk_dup(mLow->duk_ctx, callIndex); - if(mReadError || mHTTPError) + if (mReadError || mHTTPError) { low_push_stash(mLow, mRequestCallID, false); - if(mReadError) + if (mReadError) + { mSocket->PushError(0); + } else { - duk_push_error_object( - mLow->duk_ctx, DUK_ERR_ERROR, "HTTP data not valid"); + duk_push_error_object(mLow->duk_ctx, DUK_ERR_ERROR, "HTTP data not valid"); duk_push_string(mLow->duk_ctx, "ERR_HTTP_PARSER"); duk_put_prop_string(mLow->duk_ctx, -2, "code"); } @@ -206,22 +225,24 @@ void LowHTTPDirect::Read(unsigned char *data, int len, int callIndex) duk_push_int(mLow->duk_ctx, read); - if(!mReadPos) + if (!mReadPos) { duk_push_array(mLow->duk_ctx); int arr_ind = 0; - while(mParamFirst) + while (mParamFirst) { pthread_mutex_lock(&mMutex); LowHTTPDirect_ParamData *param = mParamFirst; mParamFirst = mParamFirst->next; - if(!mParamFirst) + if (!mParamFirst) + { mParamLast = NULL; + } pthread_mutex_unlock(&mMutex); int pos = 0; - while(param->data[pos]) + while (param->data[pos]) { int len = param->data[pos]; char next = param->data[pos + 1 + len]; @@ -237,37 +258,40 @@ void LowHTTPDirect::Read(unsigned char *data, int len, int callIndex) low_free(param); } - if(mIsServer) + if (mIsServer) + { duk_call(mLow->duk_ctx, 4); + } else { Detach(); - duk_push_boolean(mLow->duk_ctx, - !mClosed && mWriteDone && - !mWriteBufferCount); + duk_push_boolean(mLow->duk_ctx, !mClosed && mWriteDone && !mWriteBufferCount); duk_call(mLow->duk_ctx, 5); } } else + { duk_call(mLow->duk_ctx, 3); + } } } else + { mReadCallID = low_add_stash(mLow, callIndex); + } } // ----------------------------------------------------------------------------- // LowHTTPDirect::WriteHeaders // ----------------------------------------------------------------------------- -void LowHTTPDirect::WriteHeaders(const char *txt, - int index, - int len, - bool isChunked) +void LowHTTPDirect::WriteHeaders(const char *txt, int index, int len, bool isChunked) { - if((mIsServer && !mIsRequest) || mWriting) + if ((mIsServer && !mIsRequest) || mWriting) + { return; + } pthread_mutex_lock(&mMutex); mWriting = true; @@ -275,11 +299,12 @@ void LowHTTPDirect::WriteHeaders(const char *txt, mWriteLen = len; mWriteChunkedEncoding = isChunked; - mWriteBuffers[0].iov_base = (unsigned char *)txt; + mWriteBuffers[0].iov_base = (unsigned char *) txt; mWriteBuffers[0].iov_len = strlen(txt); - if(isChunked) - mWriteBuffers[0].iov_len -= - 2; // get rid of last \r\n, will be added with chunks + if (isChunked) + { + mWriteBuffers[0].iov_len -= 2; + } // get rid of last \r\n, will be added with chunks mWriteBufferStashID[0] = low_add_stash(mLow, index); mWriteBufferCount = 1; @@ -291,13 +316,9 @@ void LowHTTPDirect::WriteHeaders(const char *txt, // LowHTTPDirect::Write // ----------------------------------------------------------------------------- -void LowHTTPDirect::Write(unsigned char *data, - int len, - int bufferIndex, - int callIndex) +void LowHTTPDirect::Write(unsigned char *data, int len, int bufferIndex, int callIndex) { - if((mIsServer && !mIsRequest) || !mWriting || mWriteBufferCount > 1 || - mWriteCallID || mWriteDone || !mSocket) + if ((mIsServer && !mIsRequest) || !mWriting || mWriteBufferCount > 1 || mWriteCallID || mWriteDone || !mSocket) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EAGAIN, "write"); @@ -306,15 +327,14 @@ void LowHTTPDirect::Write(unsigned char *data, } pthread_mutex_lock(&mMutex); - if(len == 0) + if (len == 0) { mWriteDone = true; - if(mWriteChunkedEncoding) + if (mWriteChunkedEncoding) { sprintf(mWriteChunkedHeaderLine, "\r\n0\r\n\r\n"); mWriteBuffers[mWriteBufferCount].iov_base = mWriteChunkedHeaderLine; - mWriteBuffers[mWriteBufferCount].iov_len = - strlen(mWriteChunkedHeaderLine); + mWriteBuffers[mWriteBufferCount].iov_len = strlen(mWriteChunkedHeaderLine); mWriteBufferStashID[mWriteBufferCount] = 0; mWriteBufferCount++; } @@ -323,30 +343,28 @@ void LowHTTPDirect::Write(unsigned char *data, { mWritePos += len; - if(mWriteChunkedEncoding) + if (mWriteChunkedEncoding) { sprintf(mWriteChunkedHeaderLine, "\r\n%x\r\n", len); mWriteBuffers[mWriteBufferCount].iov_base = mWriteChunkedHeaderLine; - mWriteBuffers[mWriteBufferCount].iov_len = - strlen(mWriteChunkedHeaderLine); + mWriteBuffers[mWriteBufferCount].iov_len = strlen(mWriteChunkedHeaderLine); mWriteBufferStashID[mWriteBufferCount] = 0; mWriteBufferCount++; } mWriteBuffers[mWriteBufferCount].iov_base = data; mWriteBuffers[mWriteBufferCount].iov_len = len; - mWriteBufferStashID[mWriteBufferCount] = - low_add_stash(mLow, bufferIndex); + mWriteBufferStashID[mWriteBufferCount] = low_add_stash(mLow, bufferIndex); mWriteBufferCount++; } DoWrite(); pthread_mutex_unlock(&mMutex); - if(!mWriteBufferCount || mWriteError) + if (!mWriteBufferCount || mWriteError) { duk_dup(mLow->duk_ctx, callIndex); - if(mWriteError) + if (mWriteError) { mSocket->PushError(1); mWriteError = false; @@ -362,24 +380,25 @@ void LowHTTPDirect::Write(unsigned char *data, duk_call(mLow->duk_ctx, 2); } - if(!mWriteBufferCount && - mWriteDone) // we need to recheck b/c of duk_call + if (!mWriteBufferCount && mWriteDone) // we need to recheck b/c of duk_call { - if(!mIsServer) + if (!mIsServer) { - if(!mShutdown && !mWriteChunkedEncoding && - (mWriteLen < 0 || mWritePos != mWriteLen)) + if (!mShutdown && !mWriteChunkedEncoding && (mWriteLen < 0 || mWritePos != mWriteLen)) { mSocket->Shutdown(); mShutdown = true; } } - else if((!mWriteChunkedEncoding && - (mWriteLen < 0 || mWritePos != mWriteLen)) || - mPhase != LOWHTTPDIRECT_PHASE_SENDING_RESPONSE) + else if ((!mWriteChunkedEncoding && (mWriteLen < 0 || mWritePos != mWriteLen)) || + mPhase != LOWHTTPDIRECT_PHASE_SENDING_RESPONSE) + { mSocket->Close(); + } else + { Init(); + } } } else @@ -395,18 +414,20 @@ void LowHTTPDirect::Write(unsigned char *data, void LowHTTPDirect::DoWrite() { - while(mWriteBufferCount) + while (mWriteBufferCount) { int size = mSocket->writev(mWriteBuffers, mWriteBufferCount); - if(size < 0) + if (size < 0) { - if(errno != EAGAIN) + if (errno != EAGAIN) + { mWriteError = true; + } return; } mBytesWritten += size; - while(mWriteBufferCount && size >= mWriteBuffers[0].iov_len) + while (mWriteBufferCount && size >= mWriteBuffers[0].iov_len) { size -= mWriteBuffers[0].iov_len; low_remove_stash(mLow, mWriteBufferStashID[0]); @@ -422,10 +443,9 @@ void LowHTTPDirect::DoWrite() mWriteBufferStashID[2] = 0; mWriteBufferCount--; } - if(size) + if (size) { - mWriteBuffers[0].iov_base = - ((unsigned char *)mWriteBuffers[0].iov_base) + size; + mWriteBuffers[0].iov_base = ((unsigned char *) mWriteBuffers[0].iov_base) + size; mWriteBuffers[0].iov_len -= size; } } @@ -437,34 +457,40 @@ void LowHTTPDirect::DoWrite() bool LowHTTPDirect::OnLoop() { - if(!mSocket) + if (!mSocket) + { return false; - if(!mRequestCallID) + } + if (!mRequestCallID) + { return true; + } - if(!mIsRequest) + if (!mIsRequest) { - if(mClosed || mReadError || mHTTPError) + if (mClosed || mReadError || mHTTPError) { low_push_stash(mLow, mRequestCallID, false); - if(mReadError) + if (mReadError) + { mSocket->PushError(0); - else if(mHTTPError) + } + else if (mHTTPError) { - duk_push_error_object( - mLow->duk_ctx, DUK_ERR_ERROR, "HTTP data not valid"); + duk_push_error_object(mLow->duk_ctx, DUK_ERR_ERROR, "HTTP data not valid"); duk_push_string(mLow->duk_ctx, "ERR_HTTP_PARSER"); duk_put_prop_string(mLow->duk_ctx, -2, "code"); } else + { low_push_error(mLow, ECONNRESET, "read"); + } mReadError = mHTTPError = false; Detach(); duk_call(mLow->duk_ctx, 1); } - if(mParamFirst && mParamFirst->type == LOWHTTPDIRECT_PARAMDATA_HEADER && - mAtTrailer) + if (mParamFirst && mParamFirst->type == LOWHTTPDIRECT_PARAMDATA_HEADER && mAtTrailer) { low_push_stash(mLow, mRequestCallID, false); duk_push_null(mLow->duk_ctx); @@ -472,20 +498,21 @@ bool LowHTTPDirect::OnLoop() duk_push_array(mLow->duk_ctx); int arr_ind = 0; - while(mParamFirst && - mParamFirst->type == LOWHTTPDIRECT_PARAMDATA_HEADER) + while (mParamFirst && mParamFirst->type == LOWHTTPDIRECT_PARAMDATA_HEADER) { pthread_mutex_lock(&mMutex); LowHTTPDirect_ParamData *param = mParamFirst; mParamFirst = mParamFirst->next; - if(!mParamFirst) + if (!mParamFirst) + { mParamLast = NULL; + } pthread_mutex_unlock(&mMutex); int pos = 0; - while(param->data[pos]) + while (param->data[pos]) { - int len = (unsigned int)(unsigned char)param->data[pos]; + int len = (unsigned int) (unsigned char) param->data[pos]; char next = param->data[pos + 1 + len]; param->data[pos + 1 + len] = 0; @@ -510,8 +537,7 @@ bool LowHTTPDirect::OnLoop() } } - if(mReadCallID && - (mReadPos || mPhase == LOWHTTPDIRECT_PHASE_SENDING_RESPONSE || mClosed)) + if (mReadCallID && (mReadPos || mPhase == LOWHTTPDIRECT_PHASE_SENDING_RESPONSE || mClosed)) { pthread_mutex_lock(&mMutex); @@ -519,15 +545,16 @@ bool LowHTTPDirect::OnLoop() mReadCallID = 0; low_push_stash(mLow, callID, true); - if(mReadError || mHTTPError) + if (mReadError || mHTTPError) { low_push_stash(mLow, mRequestCallID, false); - if(mReadError) + if (mReadError) + { mSocket->PushError(0); + } else { - duk_push_error_object( - mLow->duk_ctx, DUK_ERR_ERROR, "HTTP data not valid"); + duk_push_error_object(mLow->duk_ctx, DUK_ERR_ERROR, "HTTP data not valid"); duk_push_string(mLow->duk_ctx, "ERR_HTTP_PARSER"); duk_put_prop_string(mLow->duk_ctx, -2, "code"); } @@ -551,22 +578,24 @@ bool LowHTTPDirect::OnLoop() pthread_mutex_unlock(&mLow->ref_mutex); duk_push_int(mLow->duk_ctx, read); - if(!mReadPos) + if (!mReadPos) { duk_push_array(mLow->duk_ctx); int arr_ind = 0; - while(mParamFirst) + while (mParamFirst) { pthread_mutex_lock(&mMutex); LowHTTPDirect_ParamData *param = mParamFirst; mParamFirst = mParamFirst->next; - if(!mParamFirst) + if (!mParamFirst) + { mParamLast = NULL; + } pthread_mutex_unlock(&mMutex); int pos = 0; - while(param->data[pos]) + while (param->data[pos]) { int len = param->data[pos]; char next = param->data[pos + 1 + len]; @@ -582,31 +611,33 @@ bool LowHTTPDirect::OnLoop() low_free(param); } - if(mIsServer) + if (mIsServer) + { duk_call(mLow->duk_ctx, 4); + } else { Detach(); - duk_push_boolean(mLow->duk_ctx, - !mClosed && mWriteDone && - !mWriteBufferCount); + duk_push_boolean(mLow->duk_ctx, !mClosed && mWriteDone && !mWriteBufferCount); duk_call(mLow->duk_ctx, 5); } } else + { duk_call(mLow->duk_ctx, 3); + } } } - if(!mWriteBufferCount || mWriteError) + if (!mWriteBufferCount || mWriteError) { - if(mWriteCallID) + if (mWriteCallID) { int callID = mWriteCallID; mWriteCallID = 0; low_push_stash(mLow, callID, true); - if(mWriteError) + if (mWriteError) { mSocket->PushError(1); mWriteError = false; @@ -622,24 +653,25 @@ bool LowHTTPDirect::OnLoop() duk_call(mLow->duk_ctx, 2); } } - if(!mWriteBufferCount && - mWriteDone) // we need to recheck b/c of duk_call + if (!mWriteBufferCount && mWriteDone) // we need to recheck b/c of duk_call { - if(!mIsServer) + if (!mIsServer) { - if(!mShutdown && !mWriteChunkedEncoding && - (mWriteLen < 0 || mWritePos != mWriteLen)) + if (!mShutdown && !mWriteChunkedEncoding && (mWriteLen < 0 || mWritePos != mWriteLen)) { mSocket->Shutdown(); mShutdown = true; } } - else if((!mWriteChunkedEncoding && - (mWriteLen < 0 || mWritePos != mWriteLen)) || - mPhase != LOWHTTPDIRECT_PHASE_SENDING_RESPONSE) + else if ((!mWriteChunkedEncoding && (mWriteLen < 0 || mWritePos != mWriteLen)) || + mPhase != LOWHTTPDIRECT_PHASE_SENDING_RESPONSE) + { mSocket->Close(); + } else + { Init(); + } } } @@ -661,61 +693,65 @@ bool LowHTTPDirect::OnSocketData(unsigned char *data, int len) // ----------------------------------------------------------------------------- #if !LOW_HAS_STRCASESTR + char *strcasestr(const char *s, const char *find); + #endif /* !LOW_HAS_STRCASESTR */ bool LowHTTPDirect::SocketData(unsigned char *data, int len, bool inLoop) { bool setCallback = false; - if(len == 0 || mClosed) + if (len == 0 || mClosed) + { goto done; - if(len < 0) + } + if (len < 0) { mReadError = true; goto done; } - while(len--) + while (len--) { unsigned char c = *data++; - if(mEraseNextN && c == '\n') + if (mEraseNextN && c == '\n') { mEraseNextN = false; continue; } mEraseNextN = mPhase != LOWHTTPDIRECT_PHASE_BODY && c == '\r'; - if(mPhase == LOWHTTPDIRECT_PHASE_SENDING_RESPONSE) + if (mPhase == LOWHTTPDIRECT_PHASE_SENDING_RESPONSE) + { goto err; + } LowHTTPDirect_ParamData *param = mParamLast; - if(mPhase != LOWHTTPDIRECT_PHASE_BODY && - mPhase != LOWHTTPDIRECT_PHASE_CHUNK_HEADER && - (!param || mParamPos + 2 >= sizeof(param->data))) + if (mPhase != LOWHTTPDIRECT_PHASE_BODY && mPhase != LOWHTTPDIRECT_PHASE_CHUNK_HEADER && + (!param || mParamPos + 2 >= sizeof(param->data))) { - LowHTTPDirect_ParamData *newParam = - (LowHTTPDirect_ParamData *)low_alloc( - sizeof(LowHTTPDirect_ParamData)); - if(!newParam) + LowHTTPDirect_ParamData *newParam = (LowHTTPDirect_ParamData *) low_alloc(sizeof(LowHTTPDirect_ParamData)); + if (!newParam) { mSocket->SetError(false, ENOMEM, false); goto done; } newParam->next = NULL; - newParam->type = mAtTrailer ? LOWHTTPDIRECT_PARAMDATA_TRAILER - : LOWHTTPDIRECT_PARAMDATA_HEADER; + newParam->type = mAtTrailer ? LOWHTTPDIRECT_PARAMDATA_TRAILER : LOWHTTPDIRECT_PARAMDATA_HEADER; pthread_mutex_lock(&mMutex); - if(param) + if (param) { - if(mParamStart == 1) + if (mParamStart == 1) + { goto err; + } param->next = newParam; - if(mParamStart != mParamPos) - memcpy(newParam->data + 1, - param->data + mParamStart, - mParamPos - mParamStart); + if (mParamStart != mParamPos) + { + memcpy(newParam->data + 1, param->data + mParamStart, mParamPos - mParamStart); + } param->data[mParamStart - 1] = '\0'; mParamPos -= mParamStart - 1; mParamPosNonSpace -= mParamStart - 1; @@ -732,22 +768,26 @@ bool LowHTTPDirect::SocketData(unsigned char *data, int len, bool inLoop) } bool isSpace = c == ' ' || c == '\t'; - if(mPhase == LOWHTTPDIRECT_PHASE_CHUNK_HEADER) + if (mPhase == LOWHTTPDIRECT_PHASE_CHUNK_HEADER) { - if(mParamStart == sizeof(mChunkedHeaderLine)) + if (mParamStart == sizeof(mChunkedHeaderLine)) + { goto err; + } - if(c == '\r' || c == '\n') + if (c == '\r' || c == '\n') { - if(mParamStart) + if (mParamStart) { mChunkedHeaderLine[mParamStart++] = '\0'; int i; - if(sscanf(mChunkedHeaderLine, "%x", &i) == 1) + if (sscanf(mChunkedHeaderLine, "%x", &i) == 1) { - if(i == 0) + if (i == 0) + { mPhase = LOWHTTPDIRECT_PHASE_HEADER_KEY; + } else { mContentLen += i; @@ -755,31 +795,39 @@ bool LowHTTPDirect::SocketData(unsigned char *data, int len, bool inLoop) } } else + { goto err; + } } } else + { mChunkedHeaderLine[mParamStart++] = c; + } } - else if(mPhase == LOWHTTPDIRECT_PHASE_BODY) + else if (mPhase == LOWHTTPDIRECT_PHASE_BODY) { len++; data--; // we need more than 1 char int size = len; - if(mContentLen >= 0 && size > mContentLen - mDataLen) + if (mContentLen >= 0 && size > mContentLen - mDataLen) + { size = mContentLen - mDataLen; + } pthread_mutex_lock(&mMutex); - if(!mReadData || mReadPos == mReadLen) + if (!mReadData || mReadPos == mReadLen) { mRemainingReadLen = len; mRemainingRead = data; pthread_mutex_unlock(&mMutex); break; } - if(size > mReadLen - mReadPos) + if (size > mReadLen - mReadPos) + { size = mReadLen - mReadPos; + } memcpy(mReadData + mReadPos, data, size); mReadPos += size; @@ -789,180 +837,194 @@ bool LowHTTPDirect::SocketData(unsigned char *data, int len, bool inLoop) data += size; len -= size; - if(mContentLen >= 0 && mDataLen == mContentLen) + if (mContentLen >= 0 && mDataLen == mContentLen) { - if(mChunkedEncoding) + if (mChunkedEncoding) { mPhase = LOWHTTPDIRECT_PHASE_CHUNK_HEADER; mParamStart = 0; } else + { mPhase = LOWHTTPDIRECT_PHASE_SENDING_RESPONSE; + } } setCallback = true; } - else if(mParamStart == mParamPos && - (isSpace || ((c == '\r' || c == '\n') && - mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE1))) + else if (mParamStart == mParamPos && + (isSpace || ((c == '\r' || c == '\n') && mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE1))) + { continue; + } else { - if(mEraseNextN) + if (mEraseNextN) + { c = '\n'; + } bool done = false; - if(mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE1 && isSpace) + if (mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE1 && isSpace) { mPhase = LOWHTTPDIRECT_PHASE_FIRSTLINE2; - if(!mIsServer) + if (!mIsServer) { - if(mParamPosNonSpace - mParamStart < 5 // x/1.0 - || param->data[mParamPosNonSpace - 4] != '/' || - param->data[mParamPosNonSpace - 2] != '.') + if (mParamPosNonSpace - mParamStart < 5 // x/1.0 + || param->data[mParamPosNonSpace - 4] != '/' || param->data[mParamPosNonSpace - 2] != '.') + { goto err; + } param->data[mParamStart - 1] = 3; - param->data[mParamStart] = - param->data[mParamPosNonSpace - 3]; + param->data[mParamStart] = param->data[mParamPosNonSpace - 3]; param->data[mParamStart + 1] = '.'; - param->data[mParamStart + 2] = - param->data[mParamPosNonSpace - 1]; - mParamPos = mParamStart = mParamPosNonSpace = - mParamStart + 4; + param->data[mParamStart + 2] = param->data[mParamPosNonSpace - 1]; + mParamPos = mParamStart = mParamPosNonSpace = mParamStart + 4; continue; } else { param->data[mParamPosNonSpace] = '\0'; - mNoBodyDefault = - strcmp(param->data + mParamStart, "OPTIONS") == 0 || - strcmp(param->data + mParamStart, "GET") == 0 || - strcmp(param->data + mParamStart, "HEAD") == 0 || - strcmp(param->data + mParamStart, "UNLOCK") == 0 || - strcmp(param->data + mParamStart, "MKCOL") == 0 || - strcmp(param->data + mParamStart, "COPY") == 0 || - strcmp(param->data + mParamStart, "MOVE") == 0 || - strcmp(param->data + mParamStart, "DELETE") == 0 || - strcmp(param->data + mParamStart, "CONNECT") == 0; + mNoBodyDefault = strcmp(param->data + mParamStart, "OPTIONS") == 0 || + strcmp(param->data + mParamStart, "GET") == 0 || + strcmp(param->data + mParamStart, "HEAD") == 0 || + strcmp(param->data + mParamStart, "UNLOCK") == 0 || + strcmp(param->data + mParamStart, "MKCOL") == 0 || + strcmp(param->data + mParamStart, "COPY") == 0 || + strcmp(param->data + mParamStart, "MOVE") == 0 || + strcmp(param->data + mParamStart, "DELETE") == 0 || + strcmp(param->data + mParamStart, "CONNECT") == 0; done = true; } } - else if(mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE2 && isSpace) + else if (mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE2 && isSpace) { mPhase = LOWHTTPDIRECT_PHASE_FIRSTLINE3; done = true; } - else if(mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE3 && c == '\n') + else if (mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE3 && c == '\n') { mPhase = LOWHTTPDIRECT_PHASE_HEADER_KEY; - if(mIsServer) + if (mIsServer) { - if(mParamPosNonSpace - mParamStart < 5 // x/1.0 - || param->data[mParamPosNonSpace - 4] != '/' || - param->data[mParamPosNonSpace - 2] != '.') + if (mParamPosNonSpace - mParamStart < 5 // x/1.0 + || param->data[mParamPosNonSpace - 4] != '/' || param->data[mParamPosNonSpace - 2] != '.') + { goto err; + } param->data[mParamStart - 1] = 3; - param->data[mParamStart] = - param->data[mParamPosNonSpace - 3]; + param->data[mParamStart] = param->data[mParamPosNonSpace - 3]; param->data[mParamStart + 1] = '.'; - param->data[mParamStart + 2] = - param->data[mParamPosNonSpace - 1]; - mParamPos = mParamStart = mParamPosNonSpace = - mParamStart + 4; + param->data[mParamStart + 2] = param->data[mParamPosNonSpace - 1]; + mParamPos = mParamStart = mParamPosNonSpace = mParamStart + 4; continue; } else + { done = true; + } } - else if(mPhase == LOWHTTPDIRECT_PHASE_HEADER_VALUE && c == '\n') + else if (mPhase == LOWHTTPDIRECT_PHASE_HEADER_VALUE && c == '\n') { - if(mIsContentLengthHeader) + if (mIsContentLengthHeader) { param->data[mParamPosNonSpace] = '\0'; mContentLen = atoi(param->data + mParamStart); } - else if(mIsTransferEncodingHeader) + else if (mIsTransferEncodingHeader) { param->data[mParamPosNonSpace] = '\0'; - mChunkedEncoding = - strcasestr(param->data + mParamStart, "chunked") != NULL; + mChunkedEncoding = strcasestr(param->data + mParamStart, "chunked") != NULL; } mPhase = LOWHTTPDIRECT_PHASE_HEADER_KEY; done = true; } - else if(mPhase == LOWHTTPDIRECT_PHASE_HEADER_KEY && c == ':') + else if (mPhase == LOWHTTPDIRECT_PHASE_HEADER_KEY && c == ':') { param->data[mParamPosNonSpace] = '\0'; - mIsContentLengthHeader = - strcmp(param->data + mParamStart, "content-length") == 0; + mIsContentLengthHeader = strcmp(param->data + mParamStart, "content-length") == 0; mIsTransferEncodingHeader = - !mIsContentLengthHeader && - strcmp(param->data + mParamStart, "transfer-encoding") == 0; + !mIsContentLengthHeader && strcmp(param->data + mParamStart, "transfer-encoding") == 0; mPhase = LOWHTTPDIRECT_PHASE_HEADER_VALUE; done = true; } - else if(mPhase == LOWHTTPDIRECT_PHASE_HEADER_KEY && c == '\n') + else if (mPhase == LOWHTTPDIRECT_PHASE_HEADER_KEY && c == '\n') { - if(mParamStart == mParamPos) + if (mParamStart == mParamPos) { param->data[mParamStart - 1] = '\0'; - if(mAtTrailer) + if (mAtTrailer) + { mPhase = LOWHTTPDIRECT_PHASE_SENDING_RESPONSE; + } else { mAtTrailer = true; - if(mContentLen == -1 && !mChunkedEncoding && - mNoBodyDefault) + if (mContentLen == -1 && !mChunkedEncoding && mNoBodyDefault) + { mContentLen = 0; - if(mChunkedEncoding) + } + if (mChunkedEncoding) { mPhase = LOWHTTPDIRECT_PHASE_CHUNK_HEADER; mParamStart = 0; mContentLen = 0; } - else if(mContentLen != 0) + else if (mContentLen != 0) + { mPhase = LOWHTTPDIRECT_PHASE_BODY; + } else + { mPhase = LOWHTTPDIRECT_PHASE_SENDING_RESPONSE; + } } setCallback = true; } else { // Header without value - param->data[mParamStart - 1] = - mParamPosNonSpace - mParamStart; + param->data[mParamStart - 1] = mParamPosNonSpace - mParamStart; param->data[mParamPosNonSpace] = 0; mParamPos = mParamStart = mParamPosNonSpace + 2; } continue; } - if(done) + if (done) { - if(mParamPosNonSpace - mParamStart > 255) + if (mParamPosNonSpace - mParamStart > 255) + { mParamPosNonSpace = mParamStart + 255; + } param->data[mParamStart - 1] = mParamPosNonSpace - mParamStart; - mParamPos = mParamStart = mParamPosNonSpace = - mParamPosNonSpace + 1; + mParamPos = mParamStart = mParamPosNonSpace = mParamPosNonSpace + 1; } else { - if(mPhase == LOWHTTPDIRECT_PHASE_HEADER_KEY) + if (mPhase == LOWHTTPDIRECT_PHASE_HEADER_KEY) + { param->data[mParamPos++] = tolower(c); - else if(mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE1 || - (mIsServer && mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE3)) + } + else if (mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE1 || + (mIsServer && mPhase == LOWHTTPDIRECT_PHASE_FIRSTLINE3)) + { param->data[mParamPos++] = toupper(c); + } else + { param->data[mParamPos++] = c; + } - if(!isSpace) + if (!isSpace) + { mParamPosNonSpace = mParamPos; + } } } } @@ -970,16 +1032,20 @@ bool LowHTTPDirect::SocketData(unsigned char *data, int len, bool inLoop) pthread_mutex_lock(&mLow->ref_mutex); mBytesRead += len; pthread_mutex_unlock(&mLow->ref_mutex); - if(mRequestCallID && setCallback && !inLoop) + if (mRequestCallID && setCallback && !inLoop) + { low_loop_set_callback(mLow, this); + } return !mRemainingRead; err: mHTTPError = true; done: mClosed = true; - if(mRequestCallID) + if (mRequestCallID) + { low_loop_set_callback(mLow, this); + } return false; } @@ -992,8 +1058,10 @@ bool LowHTTPDirect::OnSocketWrite() { pthread_mutex_lock(&mMutex); DoWrite(); - if(mWriteCallID && (!mWriteBufferCount || mWriteError)) + if (mWriteCallID && (!mWriteBufferCount || mWriteError)) + { low_loop_set_callback(mLow, this); + } bool res = mWriteBufferCount != 0; pthread_mutex_unlock(&mMutex); diff --git a/src/LowHTTPDirect.h b/src/LowHTTPDirect.h index 8c0b66e..8db2dd5 100644 --- a/src/LowHTTPDirect.h +++ b/src/LowHTTPDirect.h @@ -11,109 +11,116 @@ #include #include "low_config.h" + #if LOW_ESP32_LWIP_SPECIALITIES #include #else + #include + #endif /* LOW_ESP32_LWIP_SPECIALITIES */ using namespace std; enum LowHTTPDirect_Phase { - LOWHTTPDIRECT_PHASE_FIRSTLINE1, - LOWHTTPDIRECT_PHASE_FIRSTLINE2, - LOWHTTPDIRECT_PHASE_FIRSTLINE3, - LOWHTTPDIRECT_PHASE_HEADER_KEY, - LOWHTTPDIRECT_PHASE_HEADER_VALUE, - LOWHTTPDIRECT_PHASE_CHUNK_HEADER, - LOWHTTPDIRECT_PHASE_BODY, - LOWHTTPDIRECT_PHASE_SENDING_RESPONSE + LOWHTTPDIRECT_PHASE_FIRSTLINE1, + LOWHTTPDIRECT_PHASE_FIRSTLINE2, + LOWHTTPDIRECT_PHASE_FIRSTLINE3, + LOWHTTPDIRECT_PHASE_HEADER_KEY, + LOWHTTPDIRECT_PHASE_HEADER_VALUE, + LOWHTTPDIRECT_PHASE_CHUNK_HEADER, + LOWHTTPDIRECT_PHASE_BODY, + LOWHTTPDIRECT_PHASE_SENDING_RESPONSE }; enum LowHTTPDirect_ParamDataType { - LOWHTTPDIRECT_PARAMDATA_HEADER = 0, - LOWHTTPDIRECT_PARAMDATA_TRAILER + LOWHTTPDIRECT_PARAMDATA_HEADER = 0, LOWHTTPDIRECT_PARAMDATA_TRAILER }; struct LowHTTPDirect_ParamData { - LowHTTPDirect_ParamData *next; - LowHTTPDirect_ParamDataType type; - int size; - char data[10240]; + LowHTTPDirect_ParamData *next; + LowHTTPDirect_ParamDataType type; + int size; + char data[10240]; }; class LowSocket; -class LowHTTPDirect - : public LowSocketDirect - , public LowLoopCallback + +class LowHTTPDirect : public LowSocketDirect, public LowLoopCallback { - public: - LowHTTPDirect(low_main_t *low, bool isServer); - virtual ~LowHTTPDirect(); +public: + LowHTTPDirect(low_main_t *low, bool isServer); + + virtual ~LowHTTPDirect(); + + virtual void SetSocket(LowSocket *socket); + + void Detach(bool pushRemainingRead = false); + + void SetRequestCallID(int callID); + + void Read(unsigned char *data, int len, int callIndex); + + void WriteHeaders(const char *txt, int index, int len, bool isChunked); - virtual void SetSocket(LowSocket *socket); - void Detach(bool pushRemainingRead = false); + void Write(unsigned char *data, int len, int bufferIndex, int callIndex); - void SetRequestCallID(int callID); - void Read(unsigned char *data, int len, int callIndex); +protected: + void Init(); - void WriteHeaders(const char *txt, int index, int len, bool isChunked); - void Write(unsigned char *data, int len, int bufferIndex, int callIndex); + virtual bool OnLoop(); - protected: - void Init(); + virtual bool OnSocketData(unsigned char *data, int len); - virtual bool OnLoop(); + bool SocketData(unsigned char *data, int len, bool inLoop); - virtual bool OnSocketData(unsigned char *data, int len); - bool SocketData(unsigned char *data, int len, bool inLoop); + void DoWrite(); - void DoWrite(); - virtual bool OnSocketWrite(); + virtual bool OnSocketWrite(); - private: - low_main_t *mLow; - bool mIsServer, mDetached; +private: + low_main_t *mLow; + bool mIsServer, mDetached; - LowSocket *mSocket; - int mRequestCallID, mReadCallID, mWriteCallID; + LowSocket *mSocket; + int mRequestCallID, mReadCallID, mWriteCallID; - pthread_mutex_t mMutex; - LowHTTPDirect_Phase mPhase; - bool mIsRequest; - int mBytesRead; - int mBytesWritten; + pthread_mutex_t mMutex; + LowHTTPDirect_Phase mPhase; + bool mIsRequest; + int mBytesRead; + int mBytesWritten; - bool mShutdown, mClosed, mEraseNextN, mAtTrailer; + bool mShutdown, mClosed, mEraseNextN, mAtTrailer; - int mContentLength; - bool mNoBodyDefault, mChunkedEncoding; + int mContentLength; + bool mNoBodyDefault, mChunkedEncoding; - int mContentLen, mDataLen; + int mContentLen, mDataLen; - LowHTTPDirect_ParamData *mParamFirst, *mParamLast; - unsigned char *mParamCurrent; - int mParamStart, mParamPos, mParamPosNonSpace; + LowHTTPDirect_ParamData *mParamFirst, *mParamLast; + unsigned char *mParamCurrent; + int mParamStart, mParamPos, mParamPosNonSpace; - char mChunkedHeaderLine[10]; - bool mIsContentLengthHeader, mIsTransferEncodingHeader; + char mChunkedHeaderLine[10]; + bool mIsContentLengthHeader, mIsTransferEncodingHeader; - unsigned char *mRemainingRead; - int mRemainingReadLen; + unsigned char *mRemainingRead; + int mRemainingReadLen; - unsigned char *mReadData; - int mReadPos, mReadLen; + unsigned char *mReadData; + int mReadPos, mReadLen; - char mWriteChunkedHeaderLine[10]; - struct iovec mWriteBuffers[3]; - int mWriteBufferStashID[3]; - int mWritePos, mWriteLen, mWriteBufferCount; - bool mWriting, mWriteDone, mWriteChunkedEncoding; + char mWriteChunkedHeaderLine[10]; + struct iovec mWriteBuffers[3]; + int mWriteBufferStashID[3]; + int mWritePos, mWriteLen, mWriteBufferCount; + bool mWriting, mWriteDone, mWriteChunkedEncoding; - bool mReadError, mWriteError, mHTTPError; + bool mReadError, mWriteError, mHTTPError; }; #endif /* __LOWHTTPDIRECT_H__ */ \ No newline at end of file diff --git a/src/LowLoopCallback.h b/src/LowLoopCallback.h index 3f421ce..cf38ac3 100644 --- a/src/LowLoopCallback.h +++ b/src/LowLoopCallback.h @@ -9,33 +9,39 @@ class LowLoopCallback { - friend bool low_loop_run(low_main_t *low); - friend bool low_reset(low_main_t *low); - friend duk_ret_t low_loop_call_callback_safe(duk_context *ctx, void *udata); - friend void low_loop_set_callback(low_main_t *low, - LowLoopCallback *callback); - friend void low_loop_clear_callback(low_main_t *low, - LowLoopCallback *callback); - friend duk_ret_t low_fs_open_sync(duk_context *ctx); - friend duk_ret_t low_fs_close_sync(duk_context *ctx); - friend duk_ret_t low_fs_waitdone(duk_context *ctx); - - public: - LowLoopCallback(low_main_t *low) - : mLow(low), mNext(nullptr), mLoopClearOnReset(true) - { - } - virtual ~LowLoopCallback() { low_loop_clear_callback(mLow, this); } - - protected: - virtual bool OnLoop() = 0; - - private: - low_main_t *mLow; - LowLoopCallback *mNext; - - protected: - bool mLoopClearOnReset; + friend bool low_loop_run(low_main_t *low); + + friend bool low_reset(low_main_t *low); + + friend duk_ret_t low_loop_call_callback_safe(duk_context *ctx, void *udata); + + friend void low_loop_set_callback(low_main_t *low, LowLoopCallback *callback); + + friend void low_loop_clear_callback(low_main_t *low, LowLoopCallback *callback); + + friend duk_ret_t low_fs_open_sync(duk_context *ctx); + + friend duk_ret_t low_fs_close_sync(duk_context *ctx); + + friend duk_ret_t low_fs_waitdone(duk_context *ctx); + +public: + LowLoopCallback(low_main_t *low) : mLow(low), mNext(nullptr), mLoopClearOnReset(true) + { + } + + virtual ~LowLoopCallback() + { low_loop_clear_callback(mLow, this); } + +protected: + virtual bool OnLoop() = 0; + +private: + low_main_t *mLow; + LowLoopCallback *mNext; + +protected: + bool mLoopClearOnReset; }; #endif /* __LOWLOOPCALLBACK_H__ */ diff --git a/src/LowServerSocket.cpp b/src/LowServerSocket.cpp index d758477..ee301ea 100644 --- a/src/LowServerSocket.cpp +++ b/src/LowServerSocket.cpp @@ -27,13 +27,18 @@ // LowServerSocket::LowServerSocket // ----------------------------------------------------------------------------- -LowServerSocket::LowServerSocket(low_main_t *low, bool isHTTP, - LowTLSContext *secureContext) - : LowFD(low, LOWFD_TYPE_SERVER), mLow(low), mIsHTTP(isHTTP), - mAcceptCallID(0), mSecureContext(secureContext) +LowServerSocket::LowServerSocket(low_main_t *low, bool isHTTP, LowTLSContext *secureContext) : LowFD(low, + LOWFD_TYPE_SERVER), + mLow(low), + mIsHTTP(isHTTP), + mAcceptCallID(0), + mSecureContext( + secureContext) { if (mSecureContext) + { mSecureContext->AddRef(); + } } // ----------------------------------------------------------------------------- @@ -45,20 +50,25 @@ LowServerSocket::~LowServerSocket() low_web_clear_poll(mLow, this); if (FD() >= 0) + { close(FD()); + } if (mAcceptCallID) + { low_remove_stash(mLow, mAcceptCallID); + } if (mSecureContext) + { mSecureContext->DecRef(); + } } // ----------------------------------------------------------------------------- // LowServerSocket::Listen // ----------------------------------------------------------------------------- -bool LowServerSocket::Listen(struct sockaddr *addr, int addrLen, int callIndex, - int &err, const char *&syscall) +bool LowServerSocket::Listen(struct sockaddr *addr, int addrLen, int callIndex, int &err, const char *&syscall) { if (FD() >= 0) { @@ -76,8 +86,7 @@ bool LowServerSocket::Listen(struct sockaddr *addr, int addrLen, int callIndex, } u_long mode = 1; - if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&mode, sizeof(mode)) < - 0) + if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &mode, sizeof(mode)) < 0) { err = errno; syscall = "setsockopt"; @@ -112,8 +121,11 @@ bool LowServerSocket::Listen(struct sockaddr *addr, int addrLen, int callIndex, } // Get port, if we called bind with 0 - if ((addr->sa_family == AF_INET && !((struct sockaddr_in *)addr)->sin_port) || (addr->sa_family == AF_INET6 && !((struct sockaddr_in6 *)addr)->sin6_port)) - getsockname(fd, addr, (socklen_t *)&addrLen); + if ((addr->sa_family == AF_INET && !((struct sockaddr_in *) addr)->sin_port) || + (addr->sa_family == AF_INET6 && !((struct sockaddr_in6 *) addr)->sin6_port)) + { + getsockname(fd, addr, (socklen_t * ) & addrLen); + } SetFD(fd); AdvertiseFD(); @@ -136,8 +148,7 @@ void LowServerSocket::Read(int pos, unsigned char *data, int len, int callIndex) // LowServerSocket::Write // ----------------------------------------------------------------------------- -void LowServerSocket::Write(int pos, unsigned char *data, int len, - int callIndex) +void LowServerSocket::Write(int pos, unsigned char *data, int len, int callIndex) { duk_reference_error(mLow->duk_ctx, "write not supported on server"); } @@ -146,7 +157,8 @@ void LowServerSocket::Write(int pos, unsigned char *data, int len, // LowServerSocket::Close // ----------------------------------------------------------------------------- -bool LowServerSocket::Close(int callIndex) { return false; } +bool LowServerSocket::Close(int callIndex) +{ return false; } // ----------------------------------------------------------------------------- // LowServerSocket::OnEvents @@ -157,7 +169,7 @@ bool LowServerSocket::OnEvents(short events) LowHTTPDirect *direct = NULL; if (mIsHTTP) { - direct = new (low_new) LowHTTPDirect(mLow, true); + direct = new(low_new) LowHTTPDirect(mLow, true); if (!direct) { // error @@ -173,24 +185,28 @@ bool LowServerSocket::OnEvents(short events) sockaddr_in6 remoteAddr; socklen_t remoteAddrLen = sizeof(remoteAddr); - fd = accept(FD(), (sockaddr *)&remoteAddr, &remoteAddrLen); + fd = accept(FD(), (sockaddr * ) & remoteAddr, &remoteAddrLen); if (fd >= 0) - socket = new (low_new) - LowSocket(mLow, fd, (sockaddr *)&remoteAddr, mAcceptCallID, - direct, 0, mSecureContext); + { + socket = new(low_new) + LowSocket(mLow, fd, (sockaddr * ) & remoteAddr, mAcceptCallID, direct, 0, mSecureContext); + } } else { fd = accept(FD(), NULL, NULL); // no address if UNIX if (fd >= 0) - socket = new (low_new) LowSocket(mLow, fd, NULL, mAcceptCallID, - direct, 0, mSecureContext); + { + socket = new(low_new) LowSocket(mLow, fd, NULL, mAcceptCallID, direct, 0, mSecureContext); + } } if (!socket) { // error if (fd >= 0) + { close(fd); + } delete direct; } diff --git a/src/LowServerSocket.h b/src/LowServerSocket.h index 07d40c6..bef45a3 100644 --- a/src/LowServerSocket.h +++ b/src/LowServerSocket.h @@ -11,27 +11,29 @@ struct low_main_t; class LowServerSocket : public LowFD { - public: - LowServerSocket(low_main_t *low, bool isHTTP, LowTLSContext *secureContext); - virtual ~LowServerSocket(); +public: + LowServerSocket(low_main_t *low, bool isHTTP, LowTLSContext *secureContext); - bool Listen(struct sockaddr *addr, int addrLen, int callIndex, int &err, - const char *&syscall); + virtual ~LowServerSocket(); - void Read(int pos, unsigned char *data, int len, int callIndex); - void Write(int pos, unsigned char *data, int len, int callIndex); - bool Close(int callIndex); + bool Listen(struct sockaddr *addr, int addrLen, int callIndex, int &err, const char *&syscall); - protected: - virtual bool OnEvents(short events); + void Read(int pos, unsigned char *data, int len, int callIndex); - private: - low_main_t *mLow; - bool mIsHTTP; + void Write(int pos, unsigned char *data, int len, int callIndex); - int mFamily, mAcceptCallID; + bool Close(int callIndex); - LowTLSContext *mSecureContext; +protected: + virtual bool OnEvents(short events); + +private: + low_main_t *mLow; + bool mIsHTTP; + + int mFamily, mAcceptCallID; + + LowTLSContext *mSecureContext; }; #endif /* __LOWSERVERSOCKET_H__ */ \ No newline at end of file diff --git a/src/LowSignalHandler.cpp b/src/LowSignalHandler.cpp index 338c90c..c08c0bd 100644 --- a/src/LowSignalHandler.cpp +++ b/src/LowSignalHandler.cpp @@ -13,8 +13,7 @@ // LowSignalHandler::LowSignalHandler // ----------------------------------------------------------------------------- -LowSignalHandler::LowSignalHandler(low_main_t *low, int signal) - : LowLoopCallback(low), mLow(low), mSignal(signal) +LowSignalHandler::LowSignalHandler(low_main_t *low, int signal) : LowLoopCallback(low), mLow(low), mSignal(signal) { low_loop_set_callback(low, this); } @@ -27,38 +26,37 @@ bool LowSignalHandler::OnLoop() { const char *name; - switch(mSignal) + switch (mSignal) { - case SIGUSR1: - name = "SIGUSR1"; - break; - case SIGUSR2: - name = "SIGUSR2"; - break; - case SIGPIPE: - name = "SIGPIPE"; - break; - case SIGWINCH: - name = "SIGWINCH"; - break; - case SIGTERM: - name = "SIGTERM"; - break; - case SIGINT: - name = "SIGINT"; - break; - case SIGHUP: - name = "SIGHUP"; - break; - default: - return false; + case SIGUSR1: + name = "SIGUSR1"; + break; + case SIGUSR2: + name = "SIGUSR2"; + break; + case SIGPIPE: + name = "SIGPIPE"; + break; + case SIGWINCH: + name = "SIGWINCH"; + break; + case SIGTERM: + name = "SIGTERM"; + break; + case SIGINT: + name = "SIGINT"; + break; + case SIGHUP: + name = "SIGHUP"; + break; + default: + return false; } low_push_stash(mLow, mLow->signal_call_id, false); duk_push_string(mLow->duk_ctx, name); duk_call(mLow->duk_ctx, 1); - if(!duk_require_boolean(mLow->duk_ctx, -1) && - (mSignal == SIGTERM || mSignal == SIGINT || mSignal == SIGHUP)) + if (!duk_require_boolean(mLow->duk_ctx, -1) && (mSignal == SIGTERM || mSignal == SIGINT || mSignal == SIGHUP)) { #if LOW_HAS_SYS_SIGNALS // Go back to default handler @@ -72,7 +70,7 @@ bool LowSignalHandler::OnLoop() // Exit raise(mSignal); #else - while(true) + while (true) { } #endif /* LOW_HAS_SIGNALS */ diff --git a/src/LowSignalHandler.h b/src/LowSignalHandler.h index 0d926e7..e0dccc7 100644 --- a/src/LowSignalHandler.h +++ b/src/LowSignalHandler.h @@ -9,15 +9,15 @@ class LowSignalHandler : public LowLoopCallback { - public: - LowSignalHandler(low_main_t *low, int signal); +public: + LowSignalHandler(low_main_t *low, int signal); - protected: - virtual bool OnLoop(); +protected: + virtual bool OnLoop(); - private: - low_main_t *mLow; - int mSignal; +private: + low_main_t *mLow; + int mSignal; }; #endif /* __LOWSIGNALHANDLER_H__ */ \ No newline at end of file diff --git a/src/LowSocket.cpp b/src/LowSocket.cpp index f0e59bc..52e92fb 100644 --- a/src/LowSocket.cpp +++ b/src/LowSocket.cpp @@ -22,8 +22,10 @@ #include #define ioctl lwip_ioctl #else + #include #include + #endif /* LOW_ESP32_LWIP_SPECIALITIES */ @@ -31,14 +33,13 @@ // LowSocket::LowSocket // ----------------------------------------------------------------------------- -LowSocket::LowSocket(low_main_t *low, int fd) : - LowFD(low, LOWFD_TYPE_SOCKET, fd), LowLoopCallback(low), mLow(low), - mType(LOWSOCKET_TYPE_STDINOUT), mAcceptConnectCallID(0), - mAcceptConnectError(false), mReadCallID(0), mWriteCallID(0), - mConnected(true), mClosed(false), mDestroyed(false), mCloseCallID(0), - mReadData(NULL), mWriteData(NULL), mDirect(nullptr), - mDirectReadEnabled(false), mDirectWriteEnabled(false), mTLSContext(NULL), - mSSL(NULL) +LowSocket::LowSocket(low_main_t *low, int fd) : LowFD(low, LOWFD_TYPE_SOCKET, fd), LowLoopCallback(low), mLow(low), + mType(LOWSOCKET_TYPE_STDINOUT), mAcceptConnectCallID(0), + mAcceptConnectError(false), mReadCallID(0), mWriteCallID(0), + mConnected(true), mClosed(false), mDestroyed(false), mCloseCallID(0), + mReadData(NULL), mWriteData(NULL), mDirect(nullptr), + mDirectReadEnabled(false), mDirectWriteEnabled(false), + mTLSContext(NULL), mSSL(NULL) { AdvertiseFD(); InitSocket(NULL); @@ -48,79 +49,93 @@ LowSocket::LowSocket(low_main_t *low, int fd) : // LowSocket::LowSocket // ----------------------------------------------------------------------------- -LowSocket::LowSocket(low_main_t *low, - int fd, - struct sockaddr *remoteAddr, - int acceptCallID, - LowSocketDirect *direct, - int directType, - LowTLSContext *tlsContext, - bool clearOnReset) : - LowFD(low, LOWFD_TYPE_SOCKET, fd), - LowLoopCallback(low), mLow(low), mType(LOWSOCKET_TYPE_ACCEPTED), - mAcceptConnectCallID(acceptCallID), mAcceptConnectError(false), - mReadCallID(0), mWriteCallID(0), mConnected(false), mClosed(false), - mDestroyed(false), mCloseCallID(0), mReadData(NULL), mWriteData(NULL), - mDirect(direct), mDirectType(directType), - mDirectReadEnabled(direct != NULL), mDirectWriteEnabled(direct != NULL), - mTLSContext(tlsContext), mSSL(NULL) +LowSocket::LowSocket(low_main_t *low, int fd, struct sockaddr *remoteAddr, int acceptCallID, LowSocketDirect *direct, + int directType, LowTLSContext *tlsContext, bool clearOnReset) : LowFD(low, LOWFD_TYPE_SOCKET, fd), + LowLoopCallback(low), mLow(low), + mType(LOWSOCKET_TYPE_ACCEPTED), + mAcceptConnectCallID(acceptCallID), + mAcceptConnectError(false), + mReadCallID(0), mWriteCallID(0), + mConnected(false), mClosed(false), + mDestroyed(false), mCloseCallID(0), + mReadData(NULL), mWriteData(NULL), + mDirect(direct), + mDirectType(directType), + mDirectReadEnabled(direct != NULL), + mDirectWriteEnabled( + direct != NULL), + mTLSContext(tlsContext), mSSL(NULL) { mFDClearOnReset = clearOnReset; mLoopClearOnReset = clearOnReset; - if(mDirect) + if (mDirect) + { mDirect->SetSocket(this); + } - if(!InitSocket(remoteAddr)) + if (!InitSocket(remoteAddr)) { - if(mAcceptConnectCallID) + if (mAcceptConnectCallID) + { low_loop_set_callback(mLow, this); // to output error + } else + { low_web_set_poll_events(mLow, this, POLLOUT); + } mTLSContext = NULL; return; } - else if(mTLSContext) + else if (mTLSContext) + { low_web_set_poll_events(mLow, this, POLLOUT); + } else { mConnected = true; - if(mAcceptConnectCallID) + if (mAcceptConnectCallID) + { low_loop_set_callback(mLow, this); + } - if(mDirect) + if (mDirect) + { low_web_set_poll_events(mLow, this, POLLIN | POLLOUT); + } } - if(mTLSContext) + if (mTLSContext) + { mTLSContext->AddRef(); + } } // ----------------------------------------------------------------------------- // LowSocket::LowSocket // ----------------------------------------------------------------------------- -LowSocket::LowSocket(low_main_t *low, - LowSocketDirect *direct, - int directType, - LowTLSContext *tlsContext, - bool clearOnReset) : - LowFD(low, LOWFD_TYPE_SOCKET), - LowLoopCallback(low), mLow(low), mType(LOWSOCKET_TYPE_CONNECTED), - mAcceptConnectCallID(0), mAcceptConnectError(false), mReadCallID(0), - mWriteCallID(0), mConnected(false), mClosed(false), mDestroyed(false), - mCloseCallID(0), mReadData(NULL), mWriteData(NULL), mDirect(direct), - mDirectType(directType), mDirectReadEnabled(direct != NULL), - mDirectWriteEnabled(direct != NULL), mTLSContext(tlsContext), mSSL(NULL) +LowSocket::LowSocket(low_main_t *low, LowSocketDirect *direct, int directType, LowTLSContext *tlsContext, + bool clearOnReset) : LowFD(low, LOWFD_TYPE_SOCKET), LowLoopCallback(low), mLow(low), + mType(LOWSOCKET_TYPE_CONNECTED), mAcceptConnectCallID(0), + mAcceptConnectError(false), mReadCallID(0), mWriteCallID(0), + mConnected(false), mClosed(false), mDestroyed(false), mCloseCallID(0), + mReadData(NULL), mWriteData(NULL), mDirect(direct), mDirectType(directType), + mDirectReadEnabled(direct != NULL), mDirectWriteEnabled(direct != NULL), + mTLSContext(tlsContext), mSSL(NULL) { mFDClearOnReset = clearOnReset; mLoopClearOnReset = clearOnReset; - if(mDirect) + if (mDirect) + { mDirect->SetSocket(this); - if(mTLSContext) + } + if (mTLSContext) + { mTLSContext->AddRef(); + } } // ----------------------------------------------------------------------------- @@ -131,32 +146,40 @@ LowSocket::~LowSocket() { low_web_clear_poll(mLow, this); - if(mDirect) + if (mDirect) { delete mDirect; low_free(mReadData); } - if(mAcceptConnectCallID) + if (mAcceptConnectCallID) { - if(mType == LOWSOCKET_TYPE_CONNECTED) + if (mType == LOWSOCKET_TYPE_CONNECTED) + { low_remove_stash(mLow, mAcceptConnectCallID); + } } - if(mReadCallID) + if (mReadCallID) + { low_remove_stash(mLow, mReadCallID); - if(mWriteCallID) + } + if (mWriteCallID) + { low_remove_stash(mLow, mWriteCallID); - if(FD() >= 0 && mType != LOWSOCKET_TYPE_STDINOUT) + } + if (FD() >= 0 && mType != LOWSOCKET_TYPE_STDINOUT) + { close(FD()); + } SetFD(-1); - if(mSSL) + if (mSSL) { mbedtls_ssl_free(mSSL); low_free(mSSL); } - if(mTLSContext) + if (mTLSContext) { mTLSContext->DecRef(); } @@ -168,29 +191,26 @@ LowSocket::~LowSocket() bool LowSocket::InitSocket(struct sockaddr *remoteAddr) { - if(remoteAddr && remoteAddr->sa_family == AF_INET) + if (remoteAddr && remoteAddr->sa_family == AF_INET) { struct sockaddr_in *addr; unsigned char *ip; mNodeFamily = 4; - addr = (struct sockaddr_in *)remoteAddr; - ip = (unsigned char *)&addr->sin_addr.s_addr; + addr = (struct sockaddr_in *) remoteAddr; + ip = (unsigned char *) &addr->sin_addr.s_addr; sprintf(mRemoteHost, "%u.%u.%u.%u", ip[0], ip[1], ip[2], ip[3]); mRemotePort = ntohs(addr->sin_port); } - else if(remoteAddr && remoteAddr->sa_family == AF_INET6) + else if (remoteAddr && remoteAddr->sa_family == AF_INET6) { struct sockaddr_in6 *addr; mNodeFamily = 6; - addr = (struct sockaddr_in6 *)remoteAddr; - if(inet_ntop(AF_INET6, - addr->sin6_addr.s6_addr, - mRemoteHost, - sizeof(mRemoteHost)) == NULL) + addr = (struct sockaddr_in6 *) remoteAddr; + if (inet_ntop(AF_INET6, addr->sin6_addr.s6_addr, mRemoteHost, sizeof(mRemoteHost)) == NULL) { mAcceptConnectErrno = errno; mAcceptConnectErrnoSSL = false; @@ -200,10 +220,12 @@ bool LowSocket::InitSocket(struct sockaddr *remoteAddr) mRemotePort = ntohs(addr->sin6_port); } else - mNodeFamily = 0; // UNIX + { + mNodeFamily = 0; + } // UNIX u_long mode = 1; - if(ioctl(FD(), FIONBIO, &mode) < 0) + if (ioctl(FD(), FIONBIO, &mode) < 0) { mAcceptConnectErrno = errno; mAcceptConnectErrnoSSL = false; @@ -212,10 +234,10 @@ bool LowSocket::InitSocket(struct sockaddr *remoteAddr) return false; } - if(mTLSContext) + if (mTLSContext) { - mSSL = (mbedtls_ssl_context *)low_alloc(sizeof(mbedtls_ssl_context)); - if(!mSSL) + mSSL = (mbedtls_ssl_context *) low_alloc(sizeof(mbedtls_ssl_context)); + if (!mSSL) { mAcceptConnectErrno = ENOMEM; mAcceptConnectErrnoSSL = false; @@ -227,7 +249,7 @@ bool LowSocket::InitSocket(struct sockaddr *remoteAddr) mbedtls_ssl_init(mSSL); int ret; - if((ret = mbedtls_ssl_setup(mSSL, &mTLSContext->GetSSLConfig())) != 0) + if ((ret = mbedtls_ssl_setup(mSSL, &mTLSContext->GetSSLConfig())) != 0) { mAcceptConnectErrno = ret; mAcceptConnectErrnoSSL = true; @@ -236,8 +258,7 @@ bool LowSocket::InitSocket(struct sockaddr *remoteAddr) return false; } - mbedtls_ssl_set_bio( - mSSL, &FD(), mbedtls_net_send, mbedtls_net_recv, NULL); + mbedtls_ssl_set_bio(mSSL, &FD(), mbedtls_net_send, mbedtls_net_recv, NULL); } return true; @@ -247,13 +268,9 @@ bool LowSocket::InitSocket(struct sockaddr *remoteAddr) // LowSocket::Connect // ----------------------------------------------------------------------------- -bool LowSocket::Connect(struct sockaddr *remoteAddr, - int remoteAddrLen, - int callIndex, - int &err, - const char *&syscall) +bool LowSocket::Connect(struct sockaddr *remoteAddr, int remoteAddrLen, int callIndex, int &err, const char *&syscall) { - if(mType != LOWSOCKET_TYPE_CONNECTED || FD() >= 0) + if (mType != LOWSOCKET_TYPE_CONNECTED || FD() >= 0) { err = mConnected ? EISCONN : EALREADY; syscall = "connect"; @@ -261,17 +278,17 @@ bool LowSocket::Connect(struct sockaddr *remoteAddr, } SetFD(socket(remoteAddr->sa_family, SOCK_STREAM, 0)); - if(FD() < 0) + if (FD() < 0) { err = errno; syscall = "socket"; return false; } - if(InitSocket(remoteAddr)) + if (InitSocket(remoteAddr)) { - if(connect(FD(), remoteAddr, remoteAddrLen) < 0) + if (connect(FD(), remoteAddr, remoteAddrLen) < 0) { - if(errno != EINPROGRESS) + if (errno != EINPROGRESS) { mAcceptConnectErrno = errno; mAcceptConnectErrnoSSL = false; @@ -279,11 +296,13 @@ bool LowSocket::Connect(struct sockaddr *remoteAddr, mAcceptConnectSyscall = "connect"; } } - else if(!mTLSContext) + else if (!mTLSContext) + { mConnected = true; + } } - if(mAcceptConnectError) + if (mAcceptConnectError) { close(FD()); SetFD(-1); @@ -294,17 +313,20 @@ bool LowSocket::Connect(struct sockaddr *remoteAddr, } else { - if(mConnected) + if (mConnected) { - if(callIndex == -1) + if (callIndex == -1) + { return true; + } else + { return CallAcceptConnect(callIndex, false); + } } else { - mAcceptConnectCallID = - callIndex != -1 ? low_add_stash(mLow, callIndex) : 0; + mAcceptConnectCallID = callIndex != -1 ? low_add_stash(mLow, callIndex) : 0; low_web_set_poll_events(mLow, this, POLLOUT); return true; @@ -326,7 +348,7 @@ void LowSocket::Read(int pos, unsigned char *data, int len, int callIndex) } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(mDirect || mReadData) + if (mDirect || mReadData) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EAGAIN, "read"); @@ -341,17 +363,18 @@ void LowSocket::Read(int pos, unsigned char *data, int len, int callIndex) // If TLS context is used, always use other thread to read bool tryNow = !mTLSContext && mConnected; len = mClosed ? 0 : (tryNow ? DoRead() : -1); - if(len >= 0 || - (tryNow && len == -1 && (mReadErrno != EAGAIN || mReadErrnoSSL))) + if (len >= 0 || (tryNow && len == -1 && (mReadErrno != EAGAIN || mReadErrnoSSL))) { - if(len == 0) + if (len == 0) + { mClosed = true; + } int err = errno; mReadData = NULL; duk_dup(mLow->duk_ctx, callIndex); - if(len >= 0) + if (len >= 0) { duk_push_null(mLow->duk_ctx); duk_push_int(mLow->duk_ctx, len); @@ -367,12 +390,8 @@ void LowSocket::Read(int pos, unsigned char *data, int len, int callIndex) { mReadCallID = low_add_stash(mLow, callIndex); - short events = - mClosed ? 0 - : (POLLIN | (!mConnected || (mWriteData && !mWritePos) || - mDirectWriteEnabled - ? POLLOUT - : 0)); + short events = mClosed ? 0 : (POLLIN | + (!mConnected || (mWriteData && !mWritePos) || mDirectWriteEnabled ? POLLOUT : 0)); low_web_set_poll_events(mLow, this, events); } } @@ -400,7 +419,7 @@ void LowSocket::Write(int pos, unsigned char *data, int len, int callIndex) } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(mDirect || mWriteData) + if (mDirect || mWriteData) { duk_dup(mLow->duk_ctx, callIndex); low_push_error(mLow, EAGAIN, "write"); @@ -415,14 +434,13 @@ void LowSocket::Write(int pos, unsigned char *data, int len, int callIndex) // If TLS context is used, always use other thread to read bool tryNow = !mTLSContext && mConnected; len = mClosed ? 0 : (tryNow ? DoWrite() : -1); - if(len >= 0 || - (tryNow && len == -1 && (mWriteErrno != EAGAIN || mWriteErrnoSSL))) + if (len >= 0 || (tryNow && len == -1 && (mWriteErrno != EAGAIN || mWriteErrnoSSL))) { int err = errno; mWriteData = NULL; duk_dup(mLow->duk_ctx, callIndex); - if(len > 0) + if (len > 0) { duk_push_null(mLow->duk_ctx); duk_push_int(mLow->duk_ctx, len); @@ -438,9 +456,7 @@ void LowSocket::Write(int pos, unsigned char *data, int len, int callIndex) { mWriteCallID = low_add_stash(mLow, callIndex); - short events = - ((mReadData && !mReadPos) || mDirectReadEnabled ? POLLIN : 0) | - POLLOUT; + short events = ((mReadData && !mReadPos) || mDirectReadEnabled ? POLLIN : 0) | POLLOUT; low_web_set_poll_events(mLow, this, events); } } @@ -452,12 +468,12 @@ void LowSocket::Write(int pos, unsigned char *data, int len, int callIndex) void LowSocket::Shutdown(int callIndex) { duk_dup(mLow->duk_ctx, callIndex); - if(!mConnected) + if (!mConnected) { low_push_error(mLow, ENOTCONN, "shutdown"); duk_call(mLow->duk_ctx, 1); } - else if(Shutdown() < 0) + else if (Shutdown() < 0) { int err = errno; duk_dup(mLow->duk_ctx, callIndex); @@ -477,13 +493,17 @@ void LowSocket::Shutdown(int callIndex) int LowSocket::Shutdown() { - if(mTLSContext) + if (mTLSContext) { - if(mSSL) - return mbedtls_ssl_close_notify(mSSL); // todo: errnos are wrong + if (mSSL) + { + return mbedtls_ssl_close_notify(mSSL); + } // todo: errnos are wrong } else + { return shutdown(FD(), SHUT_WR); + } } // ----------------------------------------------------------------------------- @@ -492,19 +512,27 @@ int LowSocket::Shutdown() bool LowSocket::Close(int callIndex) { - if(mDestroyed) + if (mDestroyed) + { return true; + } - if(callIndex != -1) + if (callIndex != -1) + { mCloseCallID = low_add_stash(mLow, callIndex); + } mDestroyed = true; - if(mCloseCallID) + if (mCloseCallID) + { low_loop_set_callback(mLow, this); - // for direct + // for direct + } else + { low_web_mark_delete(mLow, this); + } return true; } @@ -514,22 +542,24 @@ bool LowSocket::Close(int callIndex) void LowSocket::KeepAlive(bool enable, int secs) { - if(FD() < 0) + if (FD() < 0) + { return; + } int opt = enable; - if(setsockopt(FD(), SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(int)) < 0) + if (setsockopt(FD(), SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(int)) < 0) { low_push_error(mLow, errno, "setsockopt"); duk_throw(mLow->duk_ctx); } - if(secs) + if (secs) { #ifdef __APPLE__ if(setsockopt(FD(), IPPROTO_TCP, TCP_KEEPALIVE, &secs, sizeof(int)) < 0) #else - if(setsockopt(FD(), IPPROTO_TCP, TCP_KEEPIDLE, &secs, sizeof(int)) < 0) + if (setsockopt(FD(), IPPROTO_TCP, TCP_KEEPIDLE, &secs, sizeof(int)) < 0) #endif /* #ifdef __APPLE__ */ { low_push_error(mLow, errno, "setsockopt"); @@ -545,7 +575,7 @@ void LowSocket::KeepAlive(bool enable, int secs) void LowSocket::NoDelay(bool enable) { int opt = enable; - if(setsockopt(FD(), IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(int)) < 0) + if (setsockopt(FD(), IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(int)) < 0) { low_push_error(mLow, errno, "setsockopt"); duk_throw(mLow->duk_ctx); @@ -558,33 +588,37 @@ void LowSocket::NoDelay(bool enable) bool LowSocket::SetDirect(LowSocketDirect *direct, int type, bool fromWebThread) { - if(direct && (mDirect || !mConnected || mReadData || mWriteData)) + if (direct && (mDirect || !mConnected || mReadData || mWriteData)) + { return false; - if(!direct && !mDirect) + } + if (!direct && !mDirect) + { return false; + } - if(!direct && mDirect) + if (!direct && mDirect) { - if(!fromWebThread) + if (!fromWebThread) + { low_web_clear_poll(mLow, this); + } low_free(mReadData); mReadData = NULL; } mDirect = direct; mDirectType = type; - if(mDirect) + if (mDirect) { mDirectReadEnabled = true; mDirect->SetSocket(this); - if(!mDestroyed) - low_web_set_poll_events( - mLow, - this, - mClosed ? 0 - : (POLLIN | (mTLSContext ? POLLOUT : 0) | - (!mConnected || mDirectWriteEnabled ? POLLOUT : 0))); + if (!mDestroyed) + { + low_web_set_poll_events(mLow, this, mClosed ? 0 : (POLLIN | (mTLSContext ? POLLOUT : 0) | + (!mConnected || mDirectWriteEnabled ? POLLOUT : 0))); + } } return true; @@ -606,19 +640,22 @@ LowSocketDirect *LowSocket::GetDirect(int &type) void LowSocket::TriggerDirect(int trigger) { - if(mDestroyed) + if (mDestroyed) + { return; + } - if(trigger & LOWSOCKET_TRIGGER_READ) + if (trigger & LOWSOCKET_TRIGGER_READ) + { mDirectReadEnabled = true; - if(trigger & LOWSOCKET_TRIGGER_WRITE) + } + if (trigger & LOWSOCKET_TRIGGER_WRITE) + { mDirectWriteEnabled = true; + } - short events = - mClosed - ? 0 - : (mDirectReadEnabled ? (POLLIN | (mTLSContext ? POLLOUT : 0)) : 0) | - (!mConnected || mDirectWriteEnabled ? POLLOUT : 0); + short events = mClosed ? 0 : (mDirectReadEnabled ? (POLLIN | (mTLSContext ? POLLOUT : 0)) : 0) | + (!mConnected || mDirectWriteEnabled ? POLLOUT : 0); low_web_set_poll_events(mLow, this, events); } @@ -628,31 +665,32 @@ void LowSocket::TriggerDirect(int trigger) bool LowSocket::OnEvents(short events) { - if((mDestroyed || mAcceptConnectError) && !mCloseCallID) + if ((mDestroyed || mAcceptConnectError) && !mCloseCallID) + { return false; - if(mClosed) + } + if (mClosed) { low_web_set_poll_events(mLow, this, 0); return true; } - while(mTLSContext && mSSL->state != MBEDTLS_SSL_HANDSHAKE_OVER && - (events & (POLLIN | POLLOUT))) + while (mTLSContext && mSSL->state != MBEDTLS_SSL_HANDSHAKE_OVER && (events & (POLLIN | POLLOUT))) { int ret = mbedtls_ssl_handshake_step(mSSL); - if(mSSL->state == MBEDTLS_SSL_HANDSHAKE_OVER) + if (mSSL->state == MBEDTLS_SSL_HANDSHAKE_OVER) { mDirectReadEnabled = mDirect; mDirectWriteEnabled = mDirect; } - else if(ret) + else if (ret) { - if(ret == MBEDTLS_ERR_SSL_WANT_READ) + if (ret == MBEDTLS_ERR_SSL_WANT_READ) { mDirectWriteEnabled = false; mDirectReadEnabled = true; } - else if(ret == MBEDTLS_ERR_SSL_WANT_WRITE) + else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) { mDirectReadEnabled = false; mDirectWriteEnabled = true; @@ -662,7 +700,7 @@ bool LowSocket::OnEvents(short events) mDirectReadEnabled = false; mDirectWriteEnabled = false; - if(mAcceptConnectCallID) + if (mAcceptConnectCallID) { mAcceptConnectErrno = ret; mAcceptConnectErrnoSSL = true; @@ -671,28 +709,31 @@ bool LowSocket::OnEvents(short events) low_loop_set_callback(mLow, this); } else + { return false; + } low_web_set_poll_events(mLow, this, 0); return true; } - short events = (mDirectReadEnabled ? POLLIN : 0) | - (mDirectWriteEnabled ? POLLOUT : 0); + short events = (mDirectReadEnabled ? POLLIN : 0) | (mDirectWriteEnabled ? POLLOUT : 0); low_web_set_poll_events(mLow, this, events); return true; } } - if(!mConnected) + if (!mConnected) { int error; socklen_t len = sizeof(error); - if(getsockopt(FD(), SOL_SOCKET, SO_ERROR, &error, &len) < 0) + if (getsockopt(FD(), SOL_SOCKET, SO_ERROR, &error, &len) < 0) + { error = errno; - if(error) + } + if (error) { - if(mAcceptConnectCallID) + if (mAcceptConnectCallID) { mAcceptConnectErrno = error; mAcceptConnectErrnoSSL = false; @@ -702,49 +743,58 @@ bool LowSocket::OnEvents(short events) low_loop_set_callback(mLow, this); } else + { return false; + } return true; } - if(mDirect) + if (mDirect) + { mDirect->OnSocketConnected(); + } mConnected = true; - if(mAcceptConnectCallID) + if (mAcceptConnectCallID) + { low_loop_set_callback(mLow, this); + } } - if(!mTLSContext || mSSL->state == MBEDTLS_SSL_HANDSHAKE_OVER) + if (!mTLSContext || mSSL->state == MBEDTLS_SSL_HANDSHAKE_OVER) { - if(mDirect) + if (mDirect) { - if(((events & (POLLIN | POLLHUP | POLLERR)) || mTLSContext) && - mDirectReadEnabled) + if (((events & (POLLIN | POLLHUP | POLLERR)) || mTLSContext) && mDirectReadEnabled) { - if(!mReadData) + if (!mReadData) { - mReadData = (unsigned char *)low_alloc(1024); + mReadData = (unsigned char *) low_alloc(1024); mReadLen = 1024; } - if(mReadData) + if (mReadData) { mDirectReadEnabled = false; // no race conditions - while(true) // required with SSL b/c Read might not always - // be retriggered if SSL still has data + while (true) // required with SSL b/c Read might not always + // be retriggered if SSL still has data { int len = DoRead(); - if(len < 0 && mReadErrno == EAGAIN && !mReadErrnoSSL) + if (len < 0 && mReadErrno == EAGAIN && !mReadErrnoSSL) { mDirectReadEnabled = true; break; } - if(len == 0) + if (len == 0) + { mClosed = true; - if(!mDirect->OnSocketData(mReadData, len)) + } + if (!mDirect->OnSocketData(mReadData, len)) + { break; + } - if(!mTLSContext) + if (!mTLSContext) { mDirectReadEnabled = true; break; @@ -752,38 +802,39 @@ bool LowSocket::OnEvents(short events) } } } - if((events & POLLOUT) && mDirectWriteEnabled) + if ((events & POLLOUT) && mDirectWriteEnabled) { mDirectWriteEnabled = false; // no race conditions - if(mDirect->OnSocketWrite()) + if (mDirect->OnSocketWrite()) + { mDirectWriteEnabled = true; + } } - short events = mClosed ? 0 - : (mDirectReadEnabled ? POLLIN : 0) | - (mDirectWriteEnabled ? POLLOUT : 0); + short events = mClosed ? 0 : (mDirectReadEnabled ? POLLIN : 0) | (mDirectWriteEnabled ? POLLOUT : 0); low_web_set_poll_events(mLow, this, events); } else { bool change = false; - if((events & (POLLIN | POLLHUP | POLLERR)) && mReadData && - !mReadPos) + if ((events & (POLLIN | POLLHUP | POLLERR)) && mReadData && !mReadPos) { int len = DoRead(); - if(len == 0) + if (len == 0) + { mClosed = true; + } - if(len >= 0 || mReadErrno != EAGAIN || mReadErrnoSSL) + if (len >= 0 || mReadErrno != EAGAIN || mReadErrnoSSL) { mReadPos = len; change = true; } } - if((events & POLLOUT) && mWriteData && !mWritePos) + if ((events & POLLOUT) && mWriteData && !mWritePos) { int len = DoWrite(); - if(len >= 0 || mReadErrno != EAGAIN || mReadErrnoSSL) + if (len >= 0 || mReadErrno != EAGAIN || mReadErrnoSSL) { mWritePos = len; change = true; @@ -791,8 +842,10 @@ bool LowSocket::OnEvents(short events) } low_web_set_poll_events(mLow, this, 0); - if(change) + if (change) + { low_loop_set_callback(mLow, this); + } } } @@ -805,9 +858,9 @@ bool LowSocket::OnEvents(short events) bool LowSocket::OnLoop() { - if(mDestroyed) + if (mDestroyed) { - if(mCloseCallID) + if (mCloseCallID) { low_push_stash(mLow, mCloseCallID, true); duk_push_null(mLow->duk_ctx); @@ -816,11 +869,11 @@ bool LowSocket::OnLoop() return false; } - if(mAcceptConnectCallID) + if (mAcceptConnectCallID) { - if(!CallAcceptConnect(mAcceptConnectCallID, true)) + if (!CallAcceptConnect(mAcceptConnectCallID, true)) { - if(mCloseCallID) + if (mCloseCallID) { low_push_stash(mLow, mCloseCallID, true); duk_push_null(mLow->duk_ctx); @@ -829,9 +882,9 @@ bool LowSocket::OnLoop() return false; } } - else if(mAcceptConnectError) + else if (mAcceptConnectError) { - if(mCloseCallID) + if (mCloseCallID) { low_push_stash(mLow, mCloseCallID, true); duk_push_null(mLow->duk_ctx); @@ -840,10 +893,12 @@ bool LowSocket::OnLoop() return false; } - if(mDirect || !mConnected) + if (mDirect || !mConnected) + { return true; + } - if(mReadData && (mClosed || mReadPos)) + if (mReadData && (mClosed || mReadPos)) { mReadData = NULL; @@ -851,7 +906,7 @@ bool LowSocket::OnLoop() mReadCallID = 0; low_push_stash(mLow, callID, true); - if(mReadPos >= 0) + if (mReadPos >= 0) { duk_push_null(mLow->duk_ctx); duk_push_int(mLow->duk_ctx, mReadPos); @@ -863,7 +918,7 @@ bool LowSocket::OnLoop() duk_call(mLow->duk_ctx, 1); } } - if(mWriteData && mWritePos) + if (mWriteData && mWritePos) { mWriteData = NULL; @@ -871,7 +926,7 @@ bool LowSocket::OnLoop() mWriteCallID = 0; low_push_stash(mLow, callID, true); - if(mWritePos > 0) + if (mWritePos > 0) { duk_push_null(mLow->duk_ctx); duk_push_int(mLow->duk_ctx, mWritePos); @@ -884,8 +939,7 @@ bool LowSocket::OnLoop() } } - short events = - mClosed ? 0 : (mReadData ? POLLIN : 0) | (mWriteData ? POLLOUT : 0); + short events = mClosed ? 0 : (mReadData ? POLLIN : 0) | (mWriteData ? POLLOUT : 0); low_web_set_poll_events(mLow, this, events); return true; } @@ -901,20 +955,20 @@ bool LowSocket::CallAcceptConnect(int callIndex, bool onStash) mAcceptConnectCallID = 0; - if(!mAcceptConnectError && mNodeFamily) + if (!mAcceptConnectError && mNodeFamily) { - if(mNodeFamily == 4) + if (mNodeFamily == 4) { sockaddr_in localAddr; socklen_t localAddrLen = sizeof(localAddr); - if(getsockname(FD(), (sockaddr *)&localAddr, &localAddrLen) < 0) + if (getsockname(FD(), (sockaddr * ) & localAddr, &localAddrLen) < 0) { mAcceptConnectErrno = errno; mAcceptConnectErrnoSSL = false; mAcceptConnectError = true; mAcceptConnectSyscall = "getsockname"; } - unsigned char *ip = (unsigned char *)&localAddr.sin_addr.s_addr; + unsigned char *ip = (unsigned char *) &localAddr.sin_addr.s_addr; sprintf(localHost, "%u.%u.%u.%u", ip[0], ip[1], ip[2], ip[3]); localPort = ntohs(localAddr.sin_port); } @@ -922,11 +976,8 @@ bool LowSocket::CallAcceptConnect(int callIndex, bool onStash) { sockaddr_in6 localAddr; socklen_t localAddrLen = sizeof(localAddr); - if(getsockname(FD(), (sockaddr *)&localAddr, &localAddrLen) < 0 || - inet_ntop(AF_INET6, - localAddr.sin6_addr.s6_addr, - localHost, - sizeof(localHost)) == NULL) + if (getsockname(FD(), (sockaddr * ) & localAddr, &localAddrLen) < 0 || + inet_ntop(AF_INET6, localAddr.sin6_addr.s6_addr, localHost, sizeof(localHost)) == NULL) { mAcceptConnectErrno = errno; mAcceptConnectErrnoSSL = false; @@ -937,29 +988,37 @@ bool LowSocket::CallAcceptConnect(int callIndex, bool onStash) } } - if(mAcceptConnectError) + if (mAcceptConnectError) { - if(onStash) + if (onStash) + { low_push_stash(mLow, callIndex, mType == LOWSOCKET_TYPE_CONNECTED); + } else + { duk_dup(mLow->duk_ctx, callIndex); + } PushError(2); duk_call(mLow->duk_ctx, 1); return false; } - else if(mConnected) + else if (mConnected) { AdvertiseFD(); - if(onStash) + if (onStash) + { low_push_stash(mLow, callIndex, mType == LOWSOCKET_TYPE_CONNECTED); + } else + { duk_dup(mLow->duk_ctx, callIndex); + } duk_push_null(mLow->duk_ctx); duk_push_int(mLow->duk_ctx, FD()); duk_push_int(mLow->duk_ctx, mNodeFamily); - if(mNodeFamily) + if (mNodeFamily) { duk_push_string(mLow->duk_ctx, localHost); duk_push_int(mLow->duk_ctx, localPort); @@ -968,7 +1027,9 @@ bool LowSocket::CallAcceptConnect(int callIndex, bool onStash) duk_call(mLow->duk_ctx, 7); } else + { duk_call(mLow->duk_ctx, 3); + } } return true; @@ -981,22 +1042,23 @@ bool LowSocket::CallAcceptConnect(int callIndex, bool onStash) int LowSocket::DoRead() { int len = 0; - while(len != mReadLen) + while (len != mReadLen) { - int size = mTLSContext - ? mbedtls_ssl_read(mSSL, mReadData + len, mReadLen - len) -#if LOW_ESP32_LWIP_SPECIALITIES - : lwip_read(FD(), mReadData + len, mReadLen - len); -#else - : read(FD(), mReadData + len, mReadLen - len); + int size = mTLSContext ? mbedtls_ssl_read(mSSL, mReadData + len, mReadLen - len) + #if LOW_ESP32_LWIP_SPECIALITIES + : lwip_read(FD(), mReadData + len, mReadLen - len); + #else + : read(FD(), mReadData + len, mReadLen - len); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(size < 0) + if (size < 0) { - if(mTLSContext) + if (mTLSContext) { - if(size == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) + if (size == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) + { return len; - if(size == MBEDTLS_ERR_SSL_WANT_READ) + } + if (size == MBEDTLS_ERR_SSL_WANT_READ) { mReadErrno = EAGAIN; mReadErrnoSSL = false; @@ -1014,10 +1076,14 @@ int LowSocket::DoRead() } return len ? len : -1; } - else if(size == 0) + else if (size == 0) + { return len; + } else + { len += size; + } } return len; } @@ -1029,21 +1095,19 @@ int LowSocket::DoRead() int LowSocket::DoWrite() { int len = 0; - while(len != mWriteLen) + while (len != mWriteLen) { - int size = - mTLSContext - ? mbedtls_ssl_write(mSSL, mWriteData + len, mWriteLen - len) -#if LOW_ESP32_LWIP_SPECIALITIES - : ::lwip_write(FD(), mWriteData + len, mWriteLen - len); -#else - : ::write(FD(), mWriteData + len, mWriteLen - len); + int size = mTLSContext ? mbedtls_ssl_write(mSSL, mWriteData + len, mWriteLen - len) + #if LOW_ESP32_LWIP_SPECIALITIES + : ::lwip_write(FD(), mWriteData + len, mWriteLen - len); + #else + : ::write(FD(), mWriteData + len, mWriteLen - len); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(size < 0) + if (size < 0) { - if(mTLSContext) + if (mTLSContext) { - if(size == MBEDTLS_ERR_SSL_WANT_WRITE) + if (size == MBEDTLS_ERR_SSL_WANT_WRITE) { mWriteErrno = EAGAIN; mWriteErrnoSSL = false; @@ -1061,10 +1125,14 @@ int LowSocket::DoWrite() } return len ? len : -1; } - else if(size == 0) + else if (size == 0) + { return len; + } else + { len += size; + } } return len; } @@ -1076,16 +1144,18 @@ int LowSocket::DoWrite() int LowSocket::write(const unsigned char *data, int len) { - if(!len) + if (!len) + { return 0; + } int size; - if(mTLSContext) + if (mTLSContext) { size = mbedtls_ssl_write(mSSL, data, len); - if(size < 0) + if (size < 0) { - if(size == MBEDTLS_ERR_SSL_WANT_WRITE) + if (size == MBEDTLS_ERR_SSL_WANT_WRITE) { errno = EAGAIN; // because we are checking this in LowHTTPDirect mWriteErrno = EAGAIN; @@ -1107,7 +1177,7 @@ int LowSocket::write(const unsigned char *data, int len) #else size = ::write(FD(), data, len); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(size < 0) + if (size < 0) { mWriteErrno = errno; mWriteErrnoSSL = true; @@ -1123,17 +1193,18 @@ int LowSocket::write(const unsigned char *data, int len) int LowSocket::writev(const struct iovec *iov, int iovcnt) { - if(!iovcnt) + if (!iovcnt) + { return 0; + } int size; - if(mTLSContext) + if (mTLSContext) { - size = - mbedtls_ssl_write(mSSL, (unsigned char *)iov->iov_base, iov->iov_len); - if(size < 0) + size = mbedtls_ssl_write(mSSL, (unsigned char *) iov->iov_base, iov->iov_len); + if (size < 0) { - if(size == MBEDTLS_ERR_SSL_WANT_WRITE) + if (size == MBEDTLS_ERR_SSL_WANT_WRITE) { errno = EAGAIN; // because we are checking this in LowHTTPDirect mWriteErrno = EAGAIN; @@ -1156,7 +1227,7 @@ int LowSocket::writev(const struct iovec *iov, int iovcnt) size = ::writev(FD(), iov, iovcnt); #endif /* #if LOW_ESP32_LWIP_SPECIALITIES */ - if(size < 0) + if (size < 0) { mWriteErrno = errno; mWriteErrnoSSL = true; @@ -1171,7 +1242,7 @@ int LowSocket::writev(const struct iovec *iov, int iovcnt) void LowSocket::SetError(bool write, int error, bool ssl) { - if(write) + if (write) { mWriteErrno = error; mWriteErrnoSSL = ssl; @@ -1193,7 +1264,7 @@ void LowSocket::PushError(int call) bool ssl; const char *syscall; - switch(call) + switch (call) { case 0: error = mReadErrno; @@ -1214,7 +1285,7 @@ void LowSocket::PushError(int call) break; } - if(error && ssl) + if (error && ssl) { char code[32], message[256]; mbedtls_strerror(error, message, sizeof(message)); @@ -1230,5 +1301,7 @@ void LowSocket::PushError(int call) duk_put_prop_string(mLow->duk_ctx, -2, "syscall"); } else + { low_push_error(mLow, error, syscall); + } } diff --git a/src/LowSocket.h b/src/LowSocket.h index 4c015a5..d75d2ff 100644 --- a/src/LowSocket.h +++ b/src/LowSocket.h @@ -15,9 +15,7 @@ enum LowSocketType { - LOWSOCKET_TYPE_STDINOUT, - LOWSOCKET_TYPE_ACCEPTED, - LOWSOCKET_TYPE_CONNECTED + LOWSOCKET_TYPE_STDINOUT, LOWSOCKET_TYPE_ACCEPTED, LOWSOCKET_TYPE_CONNECTED }; const int LOWSOCKET_TRIGGER_READ = 1; @@ -26,93 +24,88 @@ const int LOWSOCKET_TRIGGER_WRITE = 2; struct low_main_t; class LowSocketDirect; -class LowSocket - : public LowFD - , public LowLoopCallback + +class LowSocket : public LowFD, public LowLoopCallback { - public: - LowSocket(low_main_t *low, int fd); // LOWSOCKET_TYPE_STDINOUT - LowSocket(low_main_t *low, - int fd, - struct sockaddr *remoteAddr, - int acceptCallID, - LowSocketDirect *direct, - int directType, - LowTLSContext *tlsContext, - bool clearOnReset = true); // LOWSOCKET_TYPE_ACCEPTED - LowSocket(low_main_t *low, - LowSocketDirect *direct, - int directType, - LowTLSContext *tlsContext, - bool clearOnReset = true); // LOWSOCKET_TYPE_CONNECTED - virtual ~LowSocket(); - - bool Connect(struct sockaddr *remoteAddr, - int remoteAddrLen, - int callIndex, - int &err, - const char *&syscall); - - void Read(int pos, unsigned char *data, int len, int callIndex); - void Write(int pos, unsigned char *data, int len, int callIndex); - void Shutdown(int callIndex); // JS version - int Shutdown(); - bool Close(int callIndex = -1); - - void KeepAlive(bool enable, int secs); - void NoDelay(bool enable); - - bool SetDirect(LowSocketDirect *direct, - int type, - bool fromWebThread = false); - LowSocketDirect *GetDirect(int &type); - void TriggerDirect(int trigger); - - // for direct - int write(const unsigned char *data, int len); - int writev(const struct iovec *iov, int iovcnt); - - void SetError(bool write, int error, bool ssl); - void PushError(int call); - - bool IsConnected() { return mConnected; } - - protected: - virtual bool OnEvents(short events); - virtual bool OnLoop(); - - bool InitSocket(struct sockaddr *remoteAddr); - bool CallAcceptConnect(int callIndex, bool onStash); - - int DoRead(); - int DoWrite(); - - private: - low_main_t *mLow; - LowSocketType mType; - short mLastEvents; - - int mNodeFamily; - char mRemoteHost[INET6_ADDRSTRLEN]; - int mRemotePort; - - int mAcceptConnectCallID, mAcceptConnectErrno, mCloseCallID; - bool mAcceptConnectError, mAcceptConnectErrnoSSL, mConnected, mClosed, - mDestroyed; - const char *mAcceptConnectSyscall; - - unsigned char *mReadData, *mWriteData; - int mReadLen, mReadCallID, mReadPos, mReadErrno; - int mWriteLen, mWriteCallID, mWritePos, mWriteErrno; - bool mReadErrnoSSL, mWriteErrnoSSL; - - LowSocketDirect *mDirect; - int mDirectType; - bool mDirectReadEnabled, mDirectWriteEnabled; - - LowTLSContext *mTLSContext; - mbedtls_ssl_context *mSSL; - bool mSSLWantRead, mSSLWantWrite; +public: + LowSocket(low_main_t *low, int fd); // LOWSOCKET_TYPE_STDINOUT + LowSocket(low_main_t *low, int fd, struct sockaddr *remoteAddr, int acceptCallID, LowSocketDirect *direct, + int directType, LowTLSContext *tlsContext, bool clearOnReset = true); // LOWSOCKET_TYPE_ACCEPTED + LowSocket(low_main_t *low, LowSocketDirect *direct, int directType, LowTLSContext *tlsContext, + bool clearOnReset = true); // LOWSOCKET_TYPE_CONNECTED + virtual ~LowSocket(); + + bool Connect(struct sockaddr *remoteAddr, int remoteAddrLen, int callIndex, int &err, const char *&syscall); + + void Read(int pos, unsigned char *data, int len, int callIndex); + + void Write(int pos, unsigned char *data, int len, int callIndex); + + void Shutdown(int callIndex); // JS version + int Shutdown(); + + bool Close(int callIndex = -1); + + void KeepAlive(bool enable, int secs); + + void NoDelay(bool enable); + + bool SetDirect(LowSocketDirect *direct, int type, bool fromWebThread = false); + + LowSocketDirect *GetDirect(int &type); + + void TriggerDirect(int trigger); + + // for direct + int write(const unsigned char *data, int len); + + int writev(const struct iovec *iov, int iovcnt); + + void SetError(bool write, int error, bool ssl); + + void PushError(int call); + + bool IsConnected() + { return mConnected; } + +protected: + virtual bool OnEvents(short events); + + virtual bool OnLoop(); + + bool InitSocket(struct sockaddr *remoteAddr); + + bool CallAcceptConnect(int callIndex, bool onStash); + + int DoRead(); + + int DoWrite(); + +private: + low_main_t *mLow; + LowSocketType mType; + short mLastEvents; + + int mNodeFamily; + char mRemoteHost[INET6_ADDRSTRLEN]; + int mRemotePort; + + int mAcceptConnectCallID, mAcceptConnectErrno, mCloseCallID; + bool mAcceptConnectError, mAcceptConnectErrnoSSL, mConnected, mClosed, mDestroyed; + const char *mAcceptConnectSyscall; + + unsigned char *mReadData, *mWriteData; + int mReadLen, mReadCallID, mReadPos, mReadErrno; + int mWriteLen, mWriteCallID, mWritePos, mWriteErrno; + bool mReadErrnoSSL, mWriteErrnoSSL; + + LowSocketDirect *mDirect; + int mDirectType; + bool mDirectReadEnabled, mDirectWriteEnabled; + + LowTLSContext *mTLSContext; + mbedtls_ssl_context *mSSL; + bool mSSLWantRead, mSSLWantWrite; }; #endif /* __LOWSOCKET_H__ */ \ No newline at end of file diff --git a/src/LowSocketDirect.h b/src/LowSocketDirect.h index c019107..7f7b873 100644 --- a/src/LowSocketDirect.h +++ b/src/LowSocketDirect.h @@ -6,18 +6,23 @@ #define __LOWSOCKETDIRECT_H__ class LowSocket; + class LowSocketDirect { - friend class LowSocket; + friend class LowSocket; protected: - virtual ~LowSocketDirect() {} + virtual ~LowSocketDirect() + {} + + virtual void SetSocket(LowSocket *socket) = 0; + + virtual void OnSocketConnected() + {} - virtual void SetSocket(LowSocket *socket) = 0; + virtual bool OnSocketData(unsigned char *data, int len) = 0; - virtual void OnSocketConnected() {} - virtual bool OnSocketData(unsigned char *data, int len) = 0; - virtual bool OnSocketWrite() = 0; + virtual bool OnSocketWrite() = 0; }; #endif /* __LOWSOCKETDIRECT_H__ */ \ No newline at end of file diff --git a/src/LowTLSContext.cpp b/src/LowTLSContext.cpp index 92b419a..3cfd291 100644 --- a/src/LowTLSContext.cpp +++ b/src/LowTLSContext.cpp @@ -13,16 +13,15 @@ // LowTLSContext::LowTLSContext // ----------------------------------------------------------------------------- -static void my_debug(void *ctx, int level, const char *file, int line, - const char *str) +static void my_debug(void *ctx, int level, const char *file, int line, const char *str) { const char *p, *basename; - (void)ctx; + (void) ctx; /* Extract basename from file */ - for(p = basename = file; *p != '\0'; p++) + for (p = basename = file; *p != '\0'; p++) { - if(*p == '/' || *p == '\\') + if (*p == '/' || *p == '\\') { basename = p + 1; } @@ -31,25 +30,24 @@ static void my_debug(void *ctx, int level, const char *file, int line, printf("%s:%04d: |%d| %s", basename, line, level, str); } -LowTLSContext::LowTLSContext(low_main_t *low, const char *cert, int certLen, - const char *key, int keyLen, const char *ca, - int caLen, bool isServer) - : mLow(low), mIsOK(false), mHasCert(false), mHasCA(false), mRef(1), - mIndex(-1) +LowTLSContext::LowTLSContext(low_main_t *low, const char *cert, int certLen, const char *key, int keyLen, + const char *ca, int caLen, bool isServer) : mLow(low), mIsOK(false), mHasCert(false), + mHasCA(false), mRef(1), mIndex(-1) { int ret; - if(!cert || !key) + if (!cert || !key) + { cert = key = NULL; + } mbedtls_ssl_config_init(&conf); mbedtls_entropy_init(&entropy); mbedtls_ctr_drbg_init(&ctr_drbg); - ret = mbedtls_ssl_config_defaults( - &conf, isServer ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT, - MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT); - if(ret != 0) + ret = mbedtls_ssl_config_defaults(&conf, isServer ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT, + MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT); + if (ret != 0) { printf(" failed ! mbedtls_ssl_config_defaults returned %d", ret); return; @@ -59,9 +57,8 @@ LowTLSContext::LowTLSContext(low_main_t *low, const char *cert, int certLen, // mbedtls_debug_set_threshold(1); const char *pers = "low.js"; - ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, - (const unsigned char *)pers, strlen(pers)); - if(ret != 0) + ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *) pers, strlen(pers)); + if (ret != 0) { printf(" failed ! mbedtls_ctr_drbg_seed returned %d", ret); return; @@ -69,38 +66,37 @@ LowTLSContext::LowTLSContext(low_main_t *low, const char *cert, int certLen, mbedtls_ssl_conf_rng(&conf, mbedtls_ctr_drbg_random, &ctr_drbg); - if(cert || ca) + if (cert || ca) + { mbedtls_x509_crt_init(&srvcert); - if(cert) + } + if (cert) { mHasCert = true; mbedtls_pk_init(&pkey); - ret = mbedtls_x509_crt_parse(&srvcert, (unsigned char *)cert, certLen); - if(ret != 0) + ret = mbedtls_x509_crt_parse(&srvcert, (unsigned char *) cert, certLen); + if (ret != 0) { - printf(" failed ! mbedtls_x509_crt_parse for cert returned %d", - ret); + printf(" failed ! mbedtls_x509_crt_parse for cert returned %d", ret); return; } - ret = - mbedtls_pk_parse_key(&pkey, (unsigned char *)key, keyLen, NULL, 0); - if(ret != 0) + ret = mbedtls_pk_parse_key(&pkey, (unsigned char *) key, keyLen, NULL, 0); + if (ret != 0) { printf(" failed ! mbedtls_pk_parse_key returned %d", ret); return; } } - if(ca) + if (ca) { mHasCA = true; - ret = mbedtls_x509_crt_parse(&srvcert, (unsigned char *)ca, caLen); - if(ret != 0) + ret = mbedtls_x509_crt_parse(&srvcert, (unsigned char *) ca, caLen); + if (ret != 0) { - printf(" failed ! mbedtls_x509_crt_parse for ca returned %d", - ret); + printf(" failed ! mbedtls_x509_crt_parse for ca returned %d", ret); return; } @@ -112,10 +108,10 @@ LowTLSContext::LowTLSContext(low_main_t *low, const char *cert, int certLen, mbedtls_ssl_conf_authmode(&conf, MBEDTLS_SSL_VERIFY_NONE); } - if(cert) + if (cert) { ret = mbedtls_ssl_conf_own_cert(&conf, &srvcert, &pkey); - if(ret != 0) + if (ret != 0) { printf(" failed ! mbedtls_ssl_conf_own_cert returned %d", ret); return; @@ -131,19 +127,24 @@ LowTLSContext::LowTLSContext(low_main_t *low, const char *cert, int certLen, LowTLSContext::~LowTLSContext() { - if(mIndex >= 0) + if (mIndex >= 0) { - if(mIndex >= mLow->tlsContexts.size() || - mLow->tlsContexts[mIndex] != this) + if (mIndex >= mLow->tlsContexts.size() || mLow->tlsContexts[mIndex] != this) + { printf("assertion error at lowtlscontext\n"); + } mLow->tlsContexts[mIndex] = NULL; } - if(mHasCA || mHasCert) + if (mHasCA || mHasCert) + { mbedtls_x509_crt_free(&srvcert); - if(mHasCert) + } + if (mHasCert) + { mbedtls_pk_free(&pkey); + } mbedtls_ssl_config_free(&conf); mbedtls_ctr_drbg_free(&ctr_drbg); mbedtls_entropy_free(&entropy); @@ -167,13 +168,15 @@ void LowTLSContext::AddRef() void LowTLSContext::DecRef() { pthread_mutex_lock(&mLow->ref_mutex); - if(!--mRef) + if (!--mRef) { pthread_mutex_unlock(&mLow->ref_mutex); delete this; return; } - if(mRef < 0) + if (mRef < 0) + { printf("assertion error 2 at lowtlscontext\n"); + } pthread_mutex_unlock(&mLow->ref_mutex); } \ No newline at end of file diff --git a/src/LowTLSContext.h b/src/LowTLSContext.h index 7a835a2..c282b54 100644 --- a/src/LowTLSContext.h +++ b/src/LowTLSContext.h @@ -1,4 +1,3 @@ - // ----------------------------------------------------------------------------- // LowTLSContext.h // ----------------------------------------------------------------------------- @@ -20,37 +19,37 @@ using namespace std; class LowTLSContext { - public: - LowTLSContext(low_main_t *low, - const char *cert = NULL, - int certLen = 0, - const char *key = NULL, - int keyLen = 0, - const char *ca = NULL, - int caLen = 0, - bool isServer = false); - ~LowTLSContext(); - - bool IsOK() { return mIsOK; } - - void SetIndex(int index) { mIndex = index; } - void AddRef(); - void DecRef(); - - mbedtls_ssl_config &GetSSLConfig() { return conf; } - - private: - low_main_t *mLow; - int mRef; - int mIndex; - - mbedtls_entropy_context entropy; - mbedtls_ctr_drbg_context ctr_drbg; - mbedtls_ssl_config conf; - mbedtls_x509_crt srvcert; - mbedtls_pk_context pkey; - - bool mIsOK, mHasCert, mHasCA; +public: + LowTLSContext(low_main_t *low, const char *cert = NULL, int certLen = 0, const char *key = NULL, int keyLen = 0, + const char *ca = NULL, int caLen = 0, bool isServer = false); + + ~LowTLSContext(); + + bool IsOK() + { return mIsOK; } + + void SetIndex(int index) + { mIndex = index; } + + void AddRef(); + + void DecRef(); + + mbedtls_ssl_config &GetSSLConfig() + { return conf; } + +private: + low_main_t *mLow; + int mRef; + int mIndex; + + mbedtls_entropy_context entropy; + mbedtls_ctr_drbg_context ctr_drbg; + mbedtls_ssl_config conf; + mbedtls_x509_crt srvcert; + mbedtls_pk_context pkey; + + bool mIsOK, mHasCert, mHasCA; }; #endif /* __LOWTLSCONTEXT_H__ */ \ No newline at end of file diff --git a/src/low_alloc.cpp b/src/low_alloc.cpp index 238817f..6bcdd65 100644 --- a/src/low_alloc.cpp +++ b/src/low_alloc.cpp @@ -25,14 +25,18 @@ void *operator new(size_t size, low_new_ident ident) noexcept char *low_strdup(const char *str) { int len = str ? strlen(str) : 0; - char *dup = (char *)low_alloc(len + 1); + char *dup = (char *) low_alloc(len + 1); - if(dup) + if (dup) { - if(len) + if (len) + { memcpy(dup, str, len + 1); + } else + { *dup = '\0'; + } } return dup; diff --git a/src/low_alloc.h b/src/low_alloc.h index cd778bf..8cb69a5 100644 --- a/src/low_alloc.h +++ b/src/low_alloc.h @@ -30,12 +30,17 @@ extern "C" extern "C" { #endif /* __cplusplus */ - void *low_alloc(size_t size); - void *low_calloc(size_t num, size_t size); - void *low_realloc(void *ptr, size_t size); - void low_free(void *ptr); - char *low_strdup(const char *str); +void *low_alloc(size_t size); + +void *low_calloc(size_t num, size_t size); + +void *low_realloc(void *ptr, size_t size); + +void low_free(void *ptr); + +char *low_strdup(const char *str); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/src/low_crypto.cpp b/src/low_crypto.cpp index 83b33db..e520e90 100644 --- a/src/low_crypto.cpp +++ b/src/low_crypto.cpp @@ -19,42 +19,51 @@ duk_ret_t low_crypto_create_hash(duk_context *ctx) const char *type = duk_require_string(ctx, 1); int len = strlen(type); - char *typeUpper = (char *)low_alloc(len + 1); - if(!typeUpper) + char *typeUpper = (char *) low_alloc(len + 1); + if (!typeUpper) + { duk_generic_error(low->duk_ctx, "memory full"); - for(int i = 0; i < len; i++) - typeUpper[i] = toupper((unsigned)type[i]); + } + for (int i = 0; i < len; i++) + { + typeUpper[i] = toupper((unsigned) type[i]); + } typeUpper[len] = 0; const mbedtls_md_info_t *info = mbedtls_md_info_from_string(typeUpper); low_free(typeUpper); - if(!info) - duk_reference_error( - low->duk_ctx, "unsupported hashing algorithm %s!", type); + if (!info) + { + duk_reference_error(low->duk_ctx, "unsupported hashing algorithm %s!", type); + } unsigned char *key = NULL; duk_size_t key_len; - if(!duk_is_undefined(ctx, 2)) + if (!duk_is_undefined(ctx, 2)) { - key = (unsigned char *)duk_get_buffer_data(ctx, 2, &key_len); - if(!key) + key = (unsigned char *) duk_get_buffer_data(ctx, 2, &key_len); + if (!key) { - key = (unsigned char *)duk_require_string(ctx, 2); - key_len = strlen((char *)key); + key = (unsigned char *) duk_require_string(ctx, 2); + key_len = strlen((char *) key); } } LowCryptoHash *hash = new(low_new) LowCryptoHash(low, info, key, key_len); int index; - for(index = 0; index < low->cryptoHashes.size(); index++) - if(!low->cryptoHashes[index]) + for (index = 0; index < low->cryptoHashes.size(); index++) + { + if (!low->cryptoHashes[index]) { low->cryptoHashes[index] = hash; break; } - if(index == low->cryptoHashes.size()) + } + if (index == low->cryptoHashes.size()) + { low->cryptoHashes.push_back(hash); + } hash->SetIndex(index); duk_push_int(low->duk_ctx, index); @@ -73,8 +82,10 @@ duk_ret_t low_crypto_hash_finalizer(duk_context *ctx) low_main_t *low = duk_get_low_context(ctx); int index = duk_require_int(ctx, 0); - if(index < 0 || index >= low->cryptoHashes.size()) + if (index < 0 || index >= low->cryptoHashes.size()) + { duk_reference_error(ctx, "crypto hash not found"); + } delete low->cryptoHashes[index]; return 0; @@ -90,13 +101,15 @@ duk_ret_t low_crypto_hash_update(duk_context *ctx) low_main_t *low = duk_get_low_context(ctx); int index = duk_require_int(ctx, 0); - if(index < 0 || index >= low->cryptoHashes.size()) + if (index < 0 || index >= low->cryptoHashes.size()) + { duk_reference_error(ctx, "crypto hash not found"); + } duk_size_t len; auto buffer = duk_require_buffer_data(ctx, 1, &len); - low->cryptoHashes[index]->Update((unsigned char *)buffer, len); + low->cryptoHashes[index]->Update((unsigned char *) buffer, len); return 0; } @@ -110,13 +123,15 @@ duk_ret_t low_crypto_hash_digest(duk_context *ctx) low_main_t *low = duk_get_low_context(ctx); int index = duk_require_int(ctx, 0); - if(index < 0 || index >= low->cryptoHashes.size()) + if (index < 0 || index >= low->cryptoHashes.size()) + { duk_reference_error(ctx, "crypto hash not found"); + } int len = low->cryptoHashes[index]->OutputSize(); auto buffer = duk_push_fixed_buffer(ctx, len); - low->cryptoHashes[index]->Digest((unsigned char *)buffer, len); + low->cryptoHashes[index]->Digest((unsigned char *) buffer, len); duk_push_buffer_object(ctx, -1, 0, len, DUK_BUFOBJ_NODEJS_BUFFER); return 1; diff --git a/src/low_crypto.h b/src/low_crypto.h index 0a8a836..e9d14a0 100644 --- a/src/low_crypto.h +++ b/src/low_crypto.h @@ -8,9 +8,11 @@ #include "duktape.h" duk_ret_t low_crypto_create_hash(duk_context *ctx); + duk_ret_t low_crypto_hash_finalizer(duk_context *ctx); duk_ret_t low_crypto_hash_update(duk_context *ctx); + duk_ret_t low_crypto_hash_digest(duk_context *ctx); #endif /* __LOW_CRYPTO_H__ */ \ No newline at end of file diff --git a/src/low_data_thread.cpp b/src/low_data_thread.cpp index c526dd0..3dee4d6 100644 --- a/src/low_data_thread.cpp +++ b/src/low_data_thread.cpp @@ -13,64 +13,71 @@ void *low_data_thread_main(void *arg) { - low_main_t *low = (low_main_t *)arg; + low_main_t *low = (low_main_t *) arg; #if LOW_ESP32_LWIP_SPECIALITIES while(true) { #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - pthread_mutex_lock(&low->data_thread_mutex); - while(true) + pthread_mutex_lock(&low->data_thread_mutex); + while (true) + { +start: + if (low->destroying) + { + break; + } + + for (int priority = 0; priority < 2; priority++) { - start: - if(low->destroying) - break; + if (low->data_callback_first[priority] && !low->destroying) + { + LowDataCallback *callback = low->data_callback_first[priority]; - for(int priority = 0; priority < 2; priority++) - if(low->data_callback_first[priority] && !low->destroying) + low->data_callback_first[priority] = callback->mNext; + if (!low->data_callback_first[priority]) { - LowDataCallback *callback = - low->data_callback_first[priority]; + low->data_callback_last[priority] = NULL; + } + callback->mNext = NULL; - low->data_callback_first[priority] = callback->mNext; - if(!low->data_callback_first[priority]) - low->data_callback_last[priority] = NULL; - callback->mNext = NULL; + pthread_mutex_unlock(&low->data_thread_mutex); + if (!callback->OnData()) + { + pthread_mutex_lock(&low->data_thread_mutex); + low->data_thread_done = true; + pthread_cond_broadcast(&low->data_thread_done_cond); pthread_mutex_unlock(&low->data_thread_mutex); - if(!callback->OnData()) - { - pthread_mutex_lock(&low->data_thread_mutex); - low->data_thread_done = true; - pthread_cond_broadcast(&low->data_thread_done_cond); - pthread_mutex_unlock(&low->data_thread_mutex); - - delete callback; - } - - pthread_mutex_lock(&low->data_thread_mutex); - low->data_thread_done = false; - goto start; + delete callback; } - if(low->destroying) - break; - - low->data_thread_done = true; - pthread_cond_broadcast(&low->data_thread_done_cond); - pthread_cond_wait(&low->data_thread_cond, &low->data_thread_mutex); - low->data_thread_done = false; + pthread_mutex_lock(&low->data_thread_mutex); + low->data_thread_done = false; + goto start; + } + } + if (low->destroying) + { + break; } + low->data_thread_done = true; pthread_cond_broadcast(&low->data_thread_done_cond); -#if LOW_ESP32_LWIP_SPECIALITIES - while(low->destroying) - pthread_cond_wait(&low->data_thread_cond, &low->data_thread_mutex); - pthread_mutex_unlock(&low->data_thread_mutex); + pthread_cond_wait(&low->data_thread_cond, &low->data_thread_mutex); + low->data_thread_done = false; } + low->data_thread_done = true; + pthread_cond_broadcast(&low->data_thread_done_cond); + +#if LOW_ESP32_LWIP_SPECIALITIES + while(low->destroying) + pthread_cond_wait(&low->data_thread_cond, &low->data_thread_mutex); + pthread_mutex_unlock(&low->data_thread_mutex); +} #endif /* LOW_ESP32_LWIP_SPECIALITIES */ pthread_mutex_unlock(&low->data_thread_mutex); @@ -81,21 +88,23 @@ void *low_data_thread_main(void *arg) // low_data_set_callback // ----------------------------------------------------------------------------- -void low_data_set_callback(low_main_t *low, LowDataCallback *callback, - int priority) +void low_data_set_callback(low_main_t *low, LowDataCallback *callback, int priority) { pthread_mutex_lock(&low->data_thread_mutex); - if(callback->mNext || low->data_callback_last[0] == callback || - low->data_callback_last[1] == callback) + if (callback->mNext || low->data_callback_last[0] == callback || low->data_callback_last[1] == callback) { pthread_mutex_unlock(&low->data_thread_mutex); return; } - if(low->data_callback_last[priority]) + if (low->data_callback_last[priority]) + { low->data_callback_last[priority]->mNext = callback; + } else + { low->data_callback_first[priority] = callback; + } low->data_callback_last[priority] = callback; pthread_cond_broadcast(&low->data_thread_cond); @@ -109,43 +118,54 @@ void low_data_set_callback(low_main_t *low, LowDataCallback *callback, void low_data_clear_callback(low_main_t *low, LowDataCallback *callback) { pthread_mutex_lock(&low->data_thread_mutex); - if(low->data_callback_first[0] == callback) + if (low->data_callback_first[0] == callback) { LowDataCallback *elem = low->data_callback_first[0]; low->data_callback_first[0] = elem->mNext; - if(!low->data_callback_first[0]) + if (!low->data_callback_first[0]) + { low->data_callback_last[0] = NULL; + } } - else if(low->data_callback_first[1] == callback) + else if (low->data_callback_first[1] == callback) { LowDataCallback *elem = low->data_callback_first[1]; low->data_callback_first[1] = elem->mNext; - if(!low->data_callback_first[1]) + if (!low->data_callback_first[1]) + { low->data_callback_last[1] = NULL; + } } - else if(callback->mNext || low->data_callback_last[0] == callback || - low->data_callback_last[1] == callback) + else if (callback->mNext || low->data_callback_last[0] == callback || low->data_callback_last[1] == callback) { - for(int priority = 0; priority < 2; priority++) + for (int priority = 0; priority < 2; priority++) { LowDataCallback *elem = low->data_callback_first[priority]; - while(elem && elem->mNext != callback) + while (elem && elem->mNext != callback) + { elem = elem->mNext; - if(!elem) + } + if (!elem) + { continue; + } - if(low->data_callback_last[priority] == callback) + if (low->data_callback_last[priority] == callback) { low->data_callback_last[priority] = elem; elem->mNext = NULL; } else + { elem->mNext = callback->mNext; + } } } callback->mNext = NULL; - while(!low->data_thread_done) + while (!low->data_thread_done) + { pthread_cond_wait(&low->data_thread_done_cond, &low->data_thread_mutex); + } pthread_mutex_unlock(&low->data_thread_mutex); } diff --git a/src/low_data_thread.h b/src/low_data_thread.h index bec1ab4..cdbf563 100644 --- a/src/low_data_thread.h +++ b/src/low_data_thread.h @@ -7,17 +7,17 @@ enum { - LOW_DATA_THREAD_PRIORITY_READ = 0, - LOW_DATA_THREAD_PRIORITY_MODIFY + LOW_DATA_THREAD_PRIORITY_READ = 0, LOW_DATA_THREAD_PRIORITY_MODIFY }; struct low_main_t; + class LowDataCallback; void *low_data_thread_main(void *arg); -void low_data_set_callback(low_main_t *low, LowDataCallback *callback, - int priority); +void low_data_set_callback(low_main_t *low, LowDataCallback *callback, int priority); + void low_data_clear_callback(low_main_t *low, LowDataCallback *callback); #endif /* __LOW_DATA_THREAD_H__ */ \ No newline at end of file diff --git a/src/low_dns.cpp b/src/low_dns.cpp index 4abceb9..3cc0c7d 100644 --- a/src/low_dns.cpp +++ b/src/low_dns.cpp @@ -10,6 +10,7 @@ #include "low_system.h" #include "low_config.h" + #if LOW_INCLUDE_CARES_RESOLVER #include "LowDNSResolver.h" #endif /* LOW_INCLUDE_CARES_RESOLVER */ @@ -29,7 +30,7 @@ duk_ret_t low_dns_lookup(duk_context *ctx) int family = duk_require_int(ctx, 1); int hints = duk_require_int(ctx, 2); - switch(family) + switch (family) { case 4: family = AF_INET; @@ -47,8 +48,10 @@ duk_ret_t low_dns_lookup(duk_context *ctx) hints = (hints & 1) ? AI_ADDRCONFIG : 0 | (hints & 2) ? AI_V4MAPPED : 0; LowDNSWorker *worker = new(low_new) LowDNSWorker(duk_get_low_context(ctx)); - if(!worker->Lookup(address, family, hints, 3)) + if (!worker->Lookup(address, family, hints, 3)) + { delete worker; + } return 0; } @@ -63,8 +66,10 @@ duk_ret_t low_dns_lookup_service(duk_context *ctx) int port = duk_require_int(ctx, 1); LowDNSWorker *worker = new(low_new) LowDNSWorker(duk_get_low_context(ctx)); - if(!worker->LookupService(address, port, 2)) + if (!worker->LookupService(address, port, 2)) + { delete worker; + } return 0; } @@ -91,9 +96,8 @@ duk_ret_t low_dns_new_resolver(duk_context *ctx) duk_push_c_function(ctx, low_dns_resolver_finalizer, 1); duk_set_finalizer(ctx, 0); #else - duk_reference_error(ctx, - "low.js was compiled without c-ares. Recompile or " - "use dns.lookup instead."); + duk_reference_error(ctx, "low.js was compiled without c-ares. Recompile or " + "use dns.lookup instead."); #endif /* LOW_INCLUDE_CARES_RESOLVER */ return 1; @@ -116,9 +120,8 @@ duk_ret_t low_dns_resolver_cancel(duk_context *ctx) low->resolvers[index]->Cancel(); pthread_mutex_unlock(&low->resolvers_mutex); #else - duk_reference_error(ctx, - "low.js was compiled without c-ares. Recompile or " - "use dns.lookup instead."); + duk_reference_error(ctx, "low.js was compiled without c-ares. Recompile or " + "use dns.lookup instead."); #endif /* LOW_INCLUDE_CARES_RESOLVER */ return 0; } @@ -210,9 +213,8 @@ duk_ret_t low_dns_resolver_get_servers(duk_context *ctx) } ares_free_data(list); #else - duk_reference_error(ctx, - "low.js was compiled without c-ares. Recompile or " - "use dns.lookup instead."); + duk_reference_error(ctx, "low.js was compiled without c-ares. Recompile or " + "use dns.lookup instead."); #endif /* LOW_INCLUDE_CARES_RESOLVER */ return 1; } @@ -290,9 +292,8 @@ duk_ret_t low_dns_resolver_set_servers(duk_context *ctx) duk_throw(ctx); } #else - duk_reference_error(ctx, - "low.js was compiled without c-ares. Recompile or " - "use dns.lookup instead."); + duk_reference_error(ctx, "low.js was compiled without c-ares. Recompile or " + "use dns.lookup instead."); #endif /* LOW_INCLUDE_CARES_RESOLVER */ return 0; } @@ -332,9 +333,8 @@ duk_ret_t low_dns_resolver_resolve(duk_context *ctx) query->Resolve(hostname, type, ttl, 0, 4); pthread_mutex_unlock(&low->resolvers_mutex); #else - duk_reference_error(ctx, - "low.js was compiled without c-ares. Recompile or " - "use dns.lookup instead."); + duk_reference_error(ctx, "low.js was compiled without c-ares. Recompile or " + "use dns.lookup instead."); #endif /* LOW_INCLUDE_CARES_RESOLVER */ return 0; } @@ -379,9 +379,8 @@ duk_ret_t low_dns_resolver_gethostbyaddr(duk_context *ctx) return 0; } #else - duk_reference_error(ctx, - "low.js was compiled without c-ares. Recompile or " - "use dns.lookup instead."); + duk_reference_error(ctx, "low.js was compiled without c-ares. Recompile or " + "use dns.lookup instead."); #endif /* LOW_INCLUDE_CARES_RESOLVER */ return 0; } diff --git a/src/low_dns.h b/src/low_dns.h index 8a6a13f..08ebac9 100644 --- a/src/low_dns.h +++ b/src/low_dns.h @@ -8,13 +8,19 @@ #include "duktape.h" duk_ret_t low_dns_lookup(duk_context *ctx); + duk_ret_t low_dns_lookup_service(duk_context *ctx); duk_ret_t low_dns_new_resolver(duk_context *ctx); + duk_ret_t low_dns_resolver_cancel(duk_context *ctx); + duk_ret_t low_dns_resolver_get_servers(duk_context *ctx); + duk_ret_t low_dns_resolver_set_servers(duk_context *ctx); + duk_ret_t low_dns_resolver_resolve(duk_context *ctx); + duk_ret_t low_dns_resolver_gethostbyaddr(duk_context *ctx); duk_ret_t low_dns_resolver_finalizer(duk_context *ctx); diff --git a/src/low_fs.cpp b/src/low_fs.cpp index 5675739..a127c2b 100644 --- a/src/low_fs.cpp +++ b/src/low_fs.cpp @@ -23,18 +23,24 @@ duk_ret_t low_fs_open(duk_context *ctx) const char *path = duk_require_string(ctx, 0); int iflags = 0; - if(duk_is_string(ctx, 1)) + if (duk_is_string(ctx, 1)) { // TODO: handle x, s const char *flags = duk_require_string(ctx, 1); - if(flags[0] == 'a') + if (flags[0] == 'a') + { iflags = O_WRONLY | O_APPEND | O_CREAT; - if(flags[0] == 'r') + } + if (flags[0] == 'r') + { iflags = O_RDONLY; - if(flags[0] == 'w') + } + if (flags[0] == 'w') + { iflags = O_WRONLY | O_CREAT | O_TRUNC; + } - for(int i = 1; flags[i]; i++) + for (int i = 1; flags[i]; i++) { #if LOW_ESP32_LWIP_SPECIALITIES if(flags[0] == 'r' && flags[i] == 'c') @@ -42,27 +48,33 @@ duk_ret_t low_fs_open(duk_context *ctx) if(flags[0] == 'w' && flags[i] == 'c') iflags |= O_COMPRESS; #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(flags[i] == '+') + if (flags[i] == '+') + { iflags = (iflags & ~(O_RDONLY | O_WRONLY)) | O_RDWR; + } } } else + { iflags = duk_require_int(ctx, 1); + } #if LOW_ESP32_LWIP_SPECIALITIES if(iflags & ~(O_RDONLY | O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC | O_COMPRESS | O_COMPRESSED)) duk_range_error(ctx, "flags not supported"); #else - if(iflags & ~(O_RDONLY | O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC | - O_CLOEXEC)) + if (iflags & ~(O_RDONLY | O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC | O_CLOEXEC)) + { duk_range_error(ctx, "flags not supported"); + } iflags |= O_CLOEXEC; // on spawn, close file #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - LowFile *file = - new(low_new) LowFile(low, path, iflags, duk_is_undefined(ctx, 3) ? 2 : 3); - if(!file) + LowFile *file = new(low_new) LowFile(low, path, iflags, duk_is_undefined(ctx, 3) ? 2 : 3); + if (!file) + { duk_generic_error(ctx, "out of memory"); + } return 0; } @@ -77,18 +89,24 @@ duk_ret_t low_fs_open_sync(duk_context *ctx) const char *path = duk_require_string(ctx, 0); int iflags = 0; - if(duk_is_string(ctx, 1)) + if (duk_is_string(ctx, 1)) { // TODO: handle x, s const char *flags = duk_require_string(ctx, 1); - if(flags[0] == 'a') + if (flags[0] == 'a') + { iflags = O_WRONLY | O_APPEND | O_CREAT; - if(flags[0] == 'r') + } + if (flags[0] == 'r') + { iflags = O_RDONLY; - if(flags[0] == 'w') + } + if (flags[0] == 'w') + { iflags = O_WRONLY | O_CREAT | O_TRUNC; + } - for(int i = 1; flags[i]; i++) + for (int i = 1; flags[i]; i++) { #if LOW_ESP32_LWIP_SPECIALITIES if(flags[0] == 'r' && flags[i] == 'c') @@ -96,34 +114,43 @@ duk_ret_t low_fs_open_sync(duk_context *ctx) if(flags[0] == 'w' && flags[i] == 'c') iflags |= O_COMPRESS; #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(flags[i] == '+') + if (flags[i] == '+') + { iflags = (iflags & ~(O_RDONLY | O_WRONLY)) | O_RDWR; + } } } else + { iflags = duk_require_int(ctx, 1); + } #if LOW_ESP32_LWIP_SPECIALITIES if(iflags & ~(O_RDONLY | O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC | O_COMPRESS | O_COMPRESSED)) duk_range_error(ctx, "flags not supported"); #else - if(iflags & ~(O_RDONLY | O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC | - O_CLOEXEC)) + if (iflags & ~(O_RDONLY | O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC | O_CLOEXEC)) + { duk_range_error(ctx, "flags not supported"); + } iflags |= O_CLOEXEC; // on spawn, close file #endif /* LOW_ESP32_LWIP_SPECIALITIES */ LowFile *file = new(low_new) LowFile(low, path, iflags, 0); - if(!file) + if (!file) + { duk_generic_error(ctx, "out of memory"); + } - while(true) + while (true) { - if(file->FinishPhase()) + if (file->FinishPhase()) + { break; + } pthread_mutex_lock(&low->loop_thread_mutex); - if(!file->LowLoopCallback::mNext && low->loop_callback_last != file) + if (!file->LowLoopCallback::mNext && low->loop_callback_last != file) { duk_debugger_cooperate(low->duk_ctx); pthread_cond_wait(&low->loop_thread_cond, &low->loop_thread_mutex); @@ -145,11 +172,13 @@ duk_ret_t low_fs_close(duk_context *ctx) int fd = duk_require_int(ctx, 0); auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { duk_reference_error(ctx, "file descriptor not found"); + } LowFD *file = iter->second; - if(!file->Close(1)) + if (!file->Close(1)) { delete file; @@ -170,25 +199,31 @@ duk_ret_t low_fs_close_sync(duk_context *ctx) int fd = duk_require_int(ctx, 0); auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { duk_reference_error(ctx, "file descriptor not found"); - if(iter->second->FDType() != LOWFD_TYPE_FILE) + } + if (iter->second->FDType() != LOWFD_TYPE_FILE) + { duk_reference_error(ctx, "file descriptor is not a file"); - LowFile *file = (LowFile *)iter->second; + } + LowFile *file = (LowFile *) iter->second; - if(!file->Close(-1)) + if (!file->Close(-1)) { delete file; return 0; } - while(true) + while (true) { - if(file->FinishPhase()) + if (file->FinishPhase()) + { return 0; + } pthread_mutex_lock(&low->loop_thread_mutex); - if(!file->LowLoopCallback::mNext && low->loop_callback_last != file) + if (!file->LowLoopCallback::mNext && low->loop_callback_last != file) { duk_debugger_cooperate(low->duk_ctx); pthread_cond_wait(&low->loop_thread_cond, &low->loop_thread_mutex); @@ -209,18 +244,21 @@ duk_ret_t low_fs_read(duk_context *ctx) int fd = duk_require_int(ctx, 0); duk_size_t buf_len; - unsigned char *buf = - (unsigned char *)duk_require_buffer_data(ctx, 1, &buf_len); + unsigned char *buf = (unsigned char *) duk_require_buffer_data(ctx, 1, &buf_len); int offset = duk_require_int(ctx, 2); int length = duk_require_int(ctx, 3); int position = duk_get_int_default(ctx, 4, -1); - if(offset < 0 || length < 0 || offset + length > buf_len) + if (offset < 0 || length < 0 || offset + length > buf_len) + { duk_range_error(ctx, "offset/length outside of buffer"); + } auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { duk_reference_error(ctx, "file descriptor not found"); + } LowFD *file = iter->second; file->Read(position, buf + offset, length, 5); @@ -237,18 +275,21 @@ duk_ret_t low_fs_write(duk_context *ctx) int fd = duk_require_int(ctx, 0); duk_size_t buf_len; - unsigned char *buf = - (unsigned char *)duk_require_buffer_data(ctx, 1, &buf_len); + unsigned char *buf = (unsigned char *) duk_require_buffer_data(ctx, 1, &buf_len); int offset = duk_require_int(ctx, 2); int length = duk_require_int(ctx, 3); int position = duk_get_int_default(ctx, 4, -1); - if(offset < 0 || length < 0 || offset + length > buf_len) + if (offset < 0 || length < 0 || offset + length > buf_len) + { duk_range_error(ctx, "offset/length outside of buffer"); + } auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { duk_reference_error(ctx, "file descriptor not found"); + } LowFD *file = iter->second; file->Write(position, buf + offset, length, 5); @@ -265,11 +306,15 @@ duk_ret_t low_fs_fstat(duk_context *ctx) int fd = duk_require_int(ctx, 0); auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { duk_reference_error(ctx, "file descriptor not found"); - if(iter->second->FDType() != LOWFD_TYPE_FILE) + } + if (iter->second->FDType() != LOWFD_TYPE_FILE) + { duk_reference_error(ctx, "file descriptor is not a file"); - LowFile *file = (LowFile *)iter->second; + } + LowFile *file = (LowFile *) iter->second; file->FStat(1); return 0; @@ -285,20 +330,26 @@ duk_ret_t low_fs_waitdone(duk_context *ctx) int fd = duk_require_int(ctx, 0); auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { return 0; + } - if(iter->second->FDType() != LOWFD_TYPE_FILE) + if (iter->second->FDType() != LOWFD_TYPE_FILE) + { duk_reference_error(ctx, "file descriptor is not a file"); - LowFile *file = (LowFile *)iter->second; + } + LowFile *file = (LowFile *) iter->second; - while(true) + while (true) { - if(file->FinishPhase()) + if (file->FinishPhase()) + { return 0; + } pthread_mutex_lock(&low->loop_thread_mutex); - if(!file->LowLoopCallback::mNext && low->loop_callback_last != file) + if (!file->LowLoopCallback::mNext && low->loop_callback_last != file) { duk_debugger_cooperate(low->duk_ctx); pthread_cond_wait(&low->loop_thread_cond, &low->loop_thread_mutex); @@ -319,11 +370,15 @@ duk_ret_t low_fs_file_pos(duk_context *ctx) int fd = duk_require_int(ctx, 0); auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { duk_reference_error(ctx, "file descriptor not found"); - if(iter->second->FDType() != LOWFD_TYPE_FILE) + } + if (iter->second->FDType() != LOWFD_TYPE_FILE) + { duk_reference_error(ctx, "file descriptor is not a file"); - LowFile *file = (LowFile *)iter->second; + } + LowFile *file = (LowFile *) iter->second; duk_push_int(ctx, lseek(file->FD(), 0, SEEK_CUR)); return 1; @@ -333,11 +388,7 @@ duk_ret_t low_fs_file_pos(duk_context *ctx) // low_fs_resolve // ----------------------------------------------------------------------------- -bool low_fs_resolve(char *res, - int res_len, - const char *base, - const char *add, - const char *add_node_modules_at) +bool low_fs_resolve(char *res, int res_len, const char *base, const char *add, const char *add_node_modules_at) { char *start, *path; @@ -351,97 +402,130 @@ bool low_fs_resolve(char *res, path = res + 1; #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(add[0] != '/') + if (add[0] != '/') { - for(const char *str = base; *str && str != add_node_modules_at; str++) + for (const char *str = base; *str && str != add_node_modules_at; str++) { - if(path != start) + if (path != start) { - if(path[-1] == '/' && str[0] == '/') + if (path[-1] == '/' && str[0] == '/') + { continue; - else if(path[-1] == '/' && str[0] == '.' && - (!str[1] || str[1] == '/')) + } + else if (path[-1] == '/' && str[0] == '.' && (!str[1] || str[1] == '/')) { str++; - if(!*str) + if (!*str) + { break; + } continue; } - else if(path[-1] == '/' && str[0] == '.' && str[1] == '.' && - (!str[2] || str[2] == '/') && - !(path - start > 2 && path[-2] == '.' && - path[-3] == '.' && - (path - start == 3 || path[-4] == '/'))) + else if (path[-1] == '/' && str[0] == '.' && str[1] == '.' && (!str[2] || str[2] == '/') && + !(path - start > 2 && path[-2] == '.' && path[-3] == '.' && + (path - start == 3 || path[-4] == '/'))) { path--; - while(path != start && path[-1] != '/') + while (path != start && path[-1] != '/') + { path--; - if(path == start) + } + if (path == start) + { return false; + } str += 2; - if(!*str) + if (!*str) + { break; + } } else + { *path++ = *str; + } } else + { *path++ = *str; + } - if(path - res == res_len) + if (path - res == res_len) + { return false; + } } - while(path != start && path[-1] != '/') + while (path != start && path[-1] != '/') + { path--; - if(path == start) + } + if (path == start) + { return false; + } } - if(add_node_modules_at) + if (add_node_modules_at) { - if(path + 13 - res >= res_len) + if (path + 13 - res >= res_len) + { return false; + } memcpy(path, "node_modules/", 13); path += 13; } - for(const char *str = add; *str; str++) + for (const char *str = add; *str; str++) { - if(path != start) + if (path != start) { - if(path[-1] == '/' && str[0] == '/') + if (path[-1] == '/' && str[0] == '/') + { continue; - else if(path[-1] == '/' && str[0] == '.' && - (!str[1] || str[1] == '/')) + } + else if (path[-1] == '/' && str[0] == '.' && (!str[1] || str[1] == '/')) { str++; - if(!*str) + if (!*str) + { break; + } continue; } - else if(path[-1] == '/' && str[0] == '.' && str[1] == '.' && - (!str[2] || str[2] == '/') && - !(path - start > 2 && path[-2] == '.' && path[-3] == '.' && - (path - start == 3 || path[-4] == '/'))) + else if (path[-1] == '/' && str[0] == '.' && str[1] == '.' && (!str[2] || str[2] == '/') && + !(path - start > 2 && path[-2] == '.' && path[-3] == '.' && + (path - start == 3 || path[-4] == '/'))) { path--; - while(path != start && path[-1] != '/') + while (path != start && path[-1] != '/') + { path--; - if(path == start) + } + if (path == start) + { return false; + } str += 2; - if(!*str) + if (!*str) + { break; + } } else + { *path++ = *str; + } } else + { *path++ = *str; + } - if(path - res == res_len) + if (path - res == res_len) + { return false; + } } *path = '\0'; diff --git a/src/low_fs.h b/src/low_fs.h index aae527f..2b33de1 100644 --- a/src/low_fs.h +++ b/src/low_fs.h @@ -8,22 +8,23 @@ #include "duktape.h" duk_ret_t low_fs_open(duk_context *ctx); + duk_ret_t low_fs_open_sync(duk_context *ctx); duk_ret_t low_fs_close(duk_context *ctx); + duk_ret_t low_fs_close_sync(duk_context *ctx); duk_ret_t low_fs_read(duk_context *ctx); + duk_ret_t low_fs_write(duk_context *ctx); + duk_ret_t low_fs_fstat(duk_context *ctx); duk_ret_t low_fs_waitdone(duk_context *ctx); + duk_ret_t low_fs_file_pos(duk_context *ctx); -bool low_fs_resolve(char *res, - int res_len, - const char *base, - const char *add, - const char *add_node_modules_at = NULL); +bool low_fs_resolve(char *res, int res_len, const char *base, const char *add, const char *add_node_modules_at = NULL); #endif /* __LOW_FS_H__ */ \ No newline at end of file diff --git a/src/low_fs_misc.cpp b/src/low_fs_misc.cpp index 1090fe6..466b1ea 100644 --- a/src/low_fs_misc.cpp +++ b/src/low_fs_misc.cpp @@ -28,8 +28,10 @@ duk_ret_t low_fs_rename(duk_context *ctx) const char *new_name = duk_require_string(ctx, 1); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } fl->Rename(old_name, new_name); fl->Run(2); @@ -46,8 +48,10 @@ duk_ret_t low_fs_unlink(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } fl->Unlink(file_name); fl->Run(1); @@ -64,8 +68,10 @@ duk_ret_t low_fs_stat(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } fl->Stat(file_name); fl->Run(1); @@ -83,11 +89,13 @@ duk_ret_t low_fs_access(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } int mode, callIndex; - if(duk_is_undefined(ctx, 2)) + if (duk_is_undefined(ctx, 2)) { mode = F_OK; callIndex = 1; @@ -114,21 +122,27 @@ duk_ret_t low_fs_readdir(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } bool withFileTypes = false; int callIndex; - if(duk_is_undefined(ctx, 2)) + if (duk_is_undefined(ctx, 2)) + { callIndex = 1; - else if(duk_is_object(ctx, 1)) + } + else if (duk_is_object(ctx, 1)) { withFileTypes = duk_get_prop_string(ctx, 1, "withFileTypes") && duk_require_boolean(ctx, -1); callIndex = 2; } else + { callIndex = 2; + } fl->ReadDir(file_name, withFileTypes); fl->Run(callIndex); @@ -146,24 +160,32 @@ duk_ret_t low_fs_mkdir(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } bool recursive = false; int mode = 0777; int callIndex; - if(duk_is_undefined(ctx, 2)) + if (duk_is_undefined(ctx, 2)) + { callIndex = 1; - else if(duk_is_object(ctx, 1)) + } + else if (duk_is_object(ctx, 1)) { recursive = duk_get_prop_string(ctx, 1, "recursive") && duk_require_boolean(ctx, -1); - if(duk_get_prop_string(ctx, 1, "mode")) + if (duk_get_prop_string(ctx, 1, "mode")) + { mode = duk_require_int(ctx, -1); + } callIndex = 2; } else + { callIndex = 2; + } fl->MkDir(file_name, recursive, mode); fl->Run(callIndex); @@ -181,14 +203,20 @@ duk_ret_t low_fs_rmdir(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } int callIndex; - if(duk_is_undefined(ctx, 2)) + if (duk_is_undefined(ctx, 2)) + { callIndex = 1; + } else + { callIndex = 2; + } fl->RmDir(file_name); fl->Run(callIndex); @@ -207,8 +235,10 @@ duk_ret_t low_fs_rename_sync(duk_context *ctx) const char *new_name = duk_require_string(ctx, 1); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } fl->Rename(old_name, new_name); fl->Run(); @@ -225,8 +255,10 @@ duk_ret_t low_fs_unlink_sync(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } fl->Unlink(file_name); fl->Run(); @@ -244,8 +276,10 @@ duk_ret_t low_fs_stat_sync(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } fl->Stat(file_name); fl->Run(); @@ -263,14 +297,20 @@ duk_ret_t low_fs_access_sync(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } int mode; - if(duk_is_undefined(ctx, 2)) + if (duk_is_undefined(ctx, 2)) + { mode = F_OK; + } else + { mode = duk_require_int(ctx, 1); + } fl->Access(file_name, mode); fl->Run(); @@ -288,16 +328,22 @@ duk_ret_t low_fs_readdir_sync(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } bool withFileTypes; int callIndex; - if(!duk_is_undefined(ctx, 2)) + if (!duk_is_undefined(ctx, 2)) + { withFileTypes = false; - else if(duk_is_object(ctx, 1)) + } + else if (duk_is_object(ctx, 1)) + { withFileTypes = duk_get_prop_string(ctx, 1, "withFileTypes") && duk_require_boolean(ctx, -1); + } fl->ReadDir(file_name, withFileTypes); fl->Run(); @@ -315,19 +361,23 @@ duk_ret_t low_fs_mkdir_sync(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } bool recursive = false; int mode = 0777; - if(duk_is_undefined(ctx, 2)) - ; - else if(duk_is_object(ctx, 1)) + if (duk_is_undefined(ctx, 2)) + {} + else if (duk_is_object(ctx, 1)) { recursive = duk_get_prop_string(ctx, 1, "recursive") && duk_require_boolean(ctx, -1); - if(duk_get_prop_string(ctx, 1, "mode")) + if (duk_get_prop_string(ctx, 1, "mode")) + { mode = duk_require_int(ctx, -1); + } } fl->MkDir(file_name, recursive, mode); @@ -346,8 +396,10 @@ duk_ret_t low_fs_rmdir_sync(duk_context *ctx) const char *file_name = duk_require_string(ctx, 0); LowFSMisc *fl = new(low_new) LowFSMisc(low); - if(!fl) + if (!fl) + { duk_generic_error(ctx, "out of memory"); + } fl->RmDir(file_name); fl->Run(); diff --git a/src/low_fs_misc.h b/src/low_fs_misc.h index 34abd7a..1aa8db2 100644 --- a/src/low_fs_misc.h +++ b/src/low_fs_misc.h @@ -8,19 +8,31 @@ #include "duktape.h" duk_ret_t low_fs_rename(duk_context *ctx); + duk_ret_t low_fs_unlink(duk_context *ctx); + duk_ret_t low_fs_stat(duk_context *ctx); + duk_ret_t low_fs_access(duk_context *ctx); + duk_ret_t low_fs_readdir(duk_context *ctx); + duk_ret_t low_fs_mkdir(duk_context *ctx); + duk_ret_t low_fs_rmdir(duk_context *ctx); duk_ret_t low_fs_rename_sync(duk_context *ctx); + duk_ret_t low_fs_unlink_sync(duk_context *ctx); + duk_ret_t low_fs_stat_sync(duk_context *ctx); + duk_ret_t low_fs_access_sync(duk_context *ctx); + duk_ret_t low_fs_readdir_sync(duk_context *ctx); + duk_ret_t low_fs_mkdir_sync(duk_context *ctx); + duk_ret_t low_fs_rmdir_sync(duk_context *ctx); #endif /* __LOW_FS_MISC_H__ */ diff --git a/src/low_http.cpp b/src/low_http.cpp index 9a4a05b..29754cb 100644 --- a/src/low_http.cpp +++ b/src/low_http.cpp @@ -23,25 +23,29 @@ duk_ret_t low_http_get_request(duk_context *ctx) int socketFD = duk_require_int(ctx, 0); auto iter = low->fds.find(socketFD); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { return 0; + } - if(iter->second->FDType() != LOWFD_TYPE_SOCKET) + if (iter->second->FDType() != LOWFD_TYPE_SOCKET) + { duk_reference_error(ctx, "file descriptor is not a socket"); - LowSocket *socket = (LowSocket *)iter->second; + } + LowSocket *socket = (LowSocket *) iter->second; int directType; - LowHTTPDirect *direct = (LowHTTPDirect *)socket->GetDirect(directType); - if(direct && directType == 0) + LowHTTPDirect *direct = (LowHTTPDirect *) socket->GetDirect(directType); + if (direct && directType == 0) { // Server version direct->SetRequestCallID(low_add_stash(low, 1)); } - else if(!direct) + else if (!direct) { // Client version direct = new(low_new) LowHTTPDirect(low, false); - if(!direct) + if (!direct) { duk_dup(ctx, 1); low_push_error(low, ENOMEM, "malloc"); @@ -49,14 +53,16 @@ duk_ret_t low_http_get_request(duk_context *ctx) return 0; } - if(!socket->SetDirect(direct, 0)) - duk_reference_error( - ctx, "file descriptor not available for direct object"); + if (!socket->SetDirect(direct, 0)) + { + duk_reference_error(ctx, "file descriptor not available for direct object"); + } direct->SetRequestCallID(low_add_stash(low, 1)); } else - duk_reference_error( - ctx, "file descriptor is already acquired by direct object"); + { + duk_reference_error(ctx, "file descriptor is already acquired by direct object"); + } return 0; } @@ -71,17 +77,23 @@ duk_ret_t low_http_detach(duk_context *ctx) int socketFD = duk_require_int(ctx, 0); auto iter = low->fds.find(socketFD); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { return 0; + } - if(iter->second->FDType() != LOWFD_TYPE_SOCKET) + if (iter->second->FDType() != LOWFD_TYPE_SOCKET) + { duk_reference_error(ctx, "file descriptor is not a socket"); - LowSocket *socket = (LowSocket *)iter->second; + } + LowSocket *socket = (LowSocket *) iter->second; int directType; - LowHTTPDirect *direct = (LowHTTPDirect *)socket->GetDirect(directType); - if(!direct || directType != 0) + LowHTTPDirect *direct = (LowHTTPDirect *) socket->GetDirect(directType); + if (!direct || directType != 0) + { duk_reference_error(ctx, "file descriptor is not an HTTP stream"); + } direct->Detach(true); return 1; @@ -97,21 +109,26 @@ duk_ret_t low_http_read(duk_context *ctx) int socketFD = duk_require_int(ctx, 0); duk_size_t buf_len; - unsigned char *buf = - (unsigned char *)duk_require_buffer_data(ctx, 1, &buf_len); + unsigned char *buf = (unsigned char *) duk_require_buffer_data(ctx, 1, &buf_len); auto iter = low->fds.find(socketFD); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { return 0; + } - if(iter->second->FDType() != LOWFD_TYPE_SOCKET) + if (iter->second->FDType() != LOWFD_TYPE_SOCKET) + { duk_reference_error(ctx, "file descriptor is not a socket"); - LowSocket *socket = (LowSocket *)iter->second; + } + LowSocket *socket = (LowSocket *) iter->second; int directType; - LowHTTPDirect *http = (LowHTTPDirect *)socket->GetDirect(directType); - if(!http || directType != 0) + LowHTTPDirect *http = (LowHTTPDirect *) socket->GetDirect(directType); + if (!http || directType != 0) + { duk_reference_error(ctx, "file descriptor is not an HTTP stream"); + } http->Read(buf, buf_len, 2); return 0; @@ -127,23 +144,26 @@ duk_ret_t low_http_write(duk_context *ctx) int socketFD = duk_require_int(ctx, 0); duk_size_t buf_len = 0; - unsigned char *buf = - duk_is_null(ctx, 1) - ? NULL - : (unsigned char *)duk_require_buffer_data(ctx, 1, &buf_len); + unsigned char *buf = duk_is_null(ctx, 1) ? NULL : (unsigned char *) duk_require_buffer_data(ctx, 1, &buf_len); auto iter = low->fds.find(socketFD); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { return 0; + } - if(iter->second->FDType() != LOWFD_TYPE_SOCKET) + if (iter->second->FDType() != LOWFD_TYPE_SOCKET) + { duk_reference_error(ctx, "file descriptor is not a socket"); - LowSocket *socket = (LowSocket *)iter->second; + } + LowSocket *socket = (LowSocket *) iter->second; int directType; - LowHTTPDirect *http = (LowHTTPDirect *)socket->GetDirect(directType); - if(!http || directType != 0) + LowHTTPDirect *http = (LowHTTPDirect *) socket->GetDirect(directType); + if (!http || directType != 0) + { duk_reference_error(ctx, "file descriptor is not an HTTP stream"); + } http->Write(buf, buf_len, 1, 2); return 0; @@ -163,17 +183,23 @@ duk_ret_t low_http_write_head(duk_context *ctx) bool isChunked = duk_require_boolean(ctx, 3); auto iter = low->fds.find(socketFD); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { return 0; + } - if(iter->second->FDType() != LOWFD_TYPE_SOCKET) + if (iter->second->FDType() != LOWFD_TYPE_SOCKET) + { duk_reference_error(ctx, "file descriptor is not a socket"); - LowSocket *socket = (LowSocket *)iter->second; + } + LowSocket *socket = (LowSocket *) iter->second; int directType; - LowHTTPDirect *http = (LowHTTPDirect *)socket->GetDirect(directType); - if(!http || directType != 0) + LowHTTPDirect *http = (LowHTTPDirect *) socket->GetDirect(directType); + if (!http || directType != 0) + { duk_reference_error(ctx, "file descriptor is not an HTTP stream"); + } http->WriteHeaders(headers, 1, len, isChunked); return 0; diff --git a/src/low_http.h b/src/low_http.h index 5b15e10..a9ba7fb 100644 --- a/src/low_http.h +++ b/src/low_http.h @@ -1,4 +1,3 @@ - // ----------------------------------------------------------------------------- // low_http.h // ----------------------------------------------------------------------------- @@ -9,11 +8,13 @@ #include "duktape.h" duk_ret_t low_http_get_request(duk_context *ctx); + duk_ret_t low_http_detach(duk_context *ctx); duk_ret_t low_http_read(duk_context *ctx); duk_ret_t low_http_write(duk_context *ctx); + duk_ret_t low_http_write_head(duk_context *ctx); #endif /* __LOW_HTTP_H__ */ \ No newline at end of file diff --git a/src/low_loop.cpp b/src/low_loop.cpp index ff65302..40257c4 100644 --- a/src/low_loop.cpp +++ b/src/low_loop.cpp @@ -21,19 +21,21 @@ void user_cpu_load(bool active); bool low_loop_run(low_main_t *low) { - while(!low->duk_flag_stop && (low->run_ref || low->loop_callback_first)) + while (!low->duk_flag_stop && (low->run_ref || low->loop_callback_first)) { int millisecs = -1; - if(low->chore_times.size()) + if (low->chore_times.size()) { int tick_count = low_tick_count(); auto iter = low->chore_times.lower_bound(low->last_chore_time); - if(iter == low->chore_times.end()) + if (iter == low->chore_times.end()) + { iter = low->chore_times.begin(); + } millisecs = iter->first - tick_count; - if(millisecs <= 0) + if (millisecs <= 0) { low->last_chore_time = iter->first; @@ -42,29 +44,32 @@ bool low_loop_run(low_main_t *low) auto iterData = low->chores.find(index); bool erase = iterData->second.oneshot; - if(erase) + if (erase) { - if(iterData->second.ref) + if (iterData->second.ref) + { low->run_ref--; + } low->chores.erase(iterData); } else { iterData->second.stamp += iterData->second.interval; - if(iterData->second.stamp - tick_count < 0) + if (iterData->second.stamp - tick_count < 0) + { iterData->second.stamp = tick_count; + } - low->chore_times.insert( - pair(iterData->second.stamp, index)); + low->chore_times.insert(pair(iterData->second.stamp, index)); } int args[2] = {index, erase}; - if(duk_safe_call( - low->duk_ctx, low_loop_call_chore_safe, args, 0, 1) != - DUK_EXEC_SUCCESS) + if (duk_safe_call(low->duk_ctx, low_loop_call_chore_safe, args, 0, 1) != DUK_EXEC_SUCCESS) { - if(!low->duk_flag_stop) // flag stop also produces error + if (!low->duk_flag_stop) + { // flag stop also produces error low_duk_print_error(low->duk_ctx); + } duk_pop(low->duk_ctx); return low->duk_flag_stop; @@ -75,14 +80,14 @@ bool low_loop_run(low_main_t *low) } pthread_mutex_lock(&low->loop_thread_mutex); - if(!low->loop_callback_first) + if (!low->loop_callback_first) { duk_debugger_cooperate(low->duk_ctx); #if LOW_ESP32_LWIP_SPECIALITIES user_cpu_load(false); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(millisecs >= 0) + if (millisecs >= 0) { /* // TODO under os x @@ -105,54 +110,58 @@ bool low_loop_run(low_main_t *low) #endif /* LOW_ESP32_LWIP_SPECIALITIES */ ts.tv_sec += secs; ts.tv_nsec += (millisecs - secs * 1000) * 1000000; - if(ts.tv_nsec >= 1000000000) + if (ts.tv_nsec >= 1000000000) { ts.tv_sec++; ts.tv_nsec -= 1000000000; } - pthread_cond_timedwait( - &low->loop_thread_cond, &low->loop_thread_mutex, &ts); + pthread_cond_timedwait(&low->loop_thread_cond, &low->loop_thread_mutex, &ts); } else - pthread_cond_wait(&low->loop_thread_cond, - &low->loop_thread_mutex); + { + pthread_cond_wait(&low->loop_thread_cond, &low->loop_thread_mutex); + } #if LOW_ESP32_LWIP_SPECIALITIES user_cpu_load(true); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ } - if(low->loop_callback_first) + if (low->loop_callback_first) { - while(true) + while (true) { LowLoopCallback *callback = low->loop_callback_first; low->loop_callback_first = callback->mNext; - if(!low->loop_callback_first) + if (!low->loop_callback_first) + { low->loop_callback_last = NULL; + } callback->mNext = NULL; pthread_mutex_unlock(&low->loop_thread_mutex); - if(duk_safe_call(low->duk_ctx, - low_loop_call_callback_safe, - callback, - 0, - 1) != DUK_EXEC_SUCCESS) + if (duk_safe_call(low->duk_ctx, low_loop_call_callback_safe, callback, 0, 1) != DUK_EXEC_SUCCESS) { - if(!low->duk_flag_stop) // flag stop also produces error + if (!low->duk_flag_stop) + { // flag stop also produces error low_duk_print_error(low->duk_ctx); + } duk_pop(low->duk_ctx); return low->duk_flag_stop; } duk_pop(low->duk_ctx); - if(!low->loop_callback_first) + if (!low->loop_callback_first) + { break; + } pthread_mutex_lock(&low->loop_thread_mutex); } } else + { pthread_mutex_unlock(&low->loop_thread_mutex); + } } return true; } @@ -163,7 +172,7 @@ bool low_loop_run(low_main_t *low) duk_ret_t low_loop_call_chore_safe(duk_context *ctx, void *udata) { - int *args = (int *)udata; + int *args = (int *) udata; low_push_stash(duk_get_low_context(ctx), args[0], args[1]); duk_call(ctx, 0); @@ -176,9 +185,11 @@ duk_ret_t low_loop_call_chore_safe(duk_context *ctx, void *udata) duk_ret_t low_loop_call_callback_safe(duk_context *ctx, void *udata) { - LowLoopCallback *callback = (LowLoopCallback *)udata; - if(!callback->OnLoop()) + LowLoopCallback *callback = (LowLoopCallback *) udata; + if (!callback->OnLoop()) + { delete callback; + } return 0; } @@ -192,8 +203,10 @@ duk_ret_t low_loop_set_chore(duk_context *ctx) int index = low_add_stash(low, 0); int delay = duk_require_int(ctx, 1); - if(delay < 0) + if (delay < 0) + { delay = 0; + } low_chore_t &chore = low->chores[index]; chore.interval = delay; @@ -217,16 +230,22 @@ duk_ret_t low_loop_clear_chore(duk_context *ctx) int index = duk_require_int(ctx, 0); auto iter = low->chores.find(index); - if(iter == low->chores.end()) + if (iter == low->chores.end()) + { return 0; + } auto iter2 = low->chore_times.find(iter->second.stamp); - while(iter2->second != index) + while (iter2->second != index) + { iter2++; + } low->chore_times.erase(iter2); - if(iter->second.ref) + if (iter->second.ref) + { low->run_ref--; + } low->chores.erase(iter); low_remove_stash(low, index); @@ -244,15 +263,21 @@ duk_ret_t low_loop_chore_ref(duk_context *ctx) bool ref = duk_require_boolean(ctx, 1); auto iter = low->chores.find(index); - if(iter == low->chores.end()) + if (iter == low->chores.end()) + { return 0; + } - if(iter->second.ref != ref) + if (iter->second.ref != ref) { - if(ref) + if (ref) + { low->run_ref++; + } else + { low->run_ref--; + } iter->second.ref = ref; } @@ -277,16 +302,20 @@ duk_ret_t low_loop_run_ref(duk_context *ctx) void low_loop_set_callback(low_main_t *low, LowLoopCallback *callback) { pthread_mutex_lock(&low->loop_thread_mutex); - if(callback->mNext || low->loop_callback_last == callback) + if (callback->mNext || low->loop_callback_last == callback) { pthread_mutex_unlock(&low->loop_thread_mutex); return; } - if(low->loop_callback_last) + if (low->loop_callback_last) + { low->loop_callback_last->mNext = callback; + } else + { low->loop_callback_first = callback; + } low->loop_callback_last = callback; pthread_cond_signal(&low->loop_thread_cond); @@ -300,27 +329,33 @@ void low_loop_set_callback(low_main_t *low, LowLoopCallback *callback) void low_loop_clear_callback(low_main_t *low, LowLoopCallback *callback) { pthread_mutex_lock(&low->loop_thread_mutex); - if(callback->mNext || low->loop_callback_last == callback) + if (callback->mNext || low->loop_callback_last == callback) { LowLoopCallback *elem = low->loop_callback_first; - if(elem == callback) + if (elem == callback) { low->loop_callback_first = elem->mNext; - if(!low->loop_callback_first) + if (!low->loop_callback_first) + { low->loop_callback_last = NULL; + } } else { - while(elem->mNext != callback) + while (elem->mNext != callback) + { elem = elem->mNext; + } - if(low->loop_callback_last == callback) + if (low->loop_callback_last == callback) { low->loop_callback_last = elem; elem->mNext = NULL; } else + { elem->mNext = callback->mNext; + } } callback->mNext = NULL; } diff --git a/src/low_loop.h b/src/low_loop.h index 1005d54..925f2ab 100644 --- a/src/low_loop.h +++ b/src/low_loop.h @@ -11,27 +11,27 @@ struct low_main_t; struct low_chore_t { - int stamp, interval; - bool oneshot, ref; + int stamp, interval; + bool oneshot, ref; }; class LowLoopCallback; extern "C" bool low_loop_run(low_main_t *low); + duk_ret_t low_loop_call_chore_safe(duk_context *ctx, void *udata); + duk_ret_t low_loop_call_callback_safe(duk_context *ctx, void *udata); duk_ret_t low_loop_chore_ref(duk_context *ctx); + duk_ret_t low_loop_run_ref(duk_context *ctx); duk_ret_t low_loop_set_chore(duk_context *ctx); + duk_ret_t low_loop_clear_chore(duk_context *ctx); -void low_loop_set_callback( - low_main_t *low, - LowLoopCallback *callback); // may be called from other thread -void low_loop_clear_callback( - low_main_t *low, - LowLoopCallback *callback); // must be called from main thread +void low_loop_set_callback(low_main_t *low, LowLoopCallback *callback); // may be called from other thread +void low_loop_clear_callback(low_main_t *low, LowLoopCallback *callback); // must be called from main thread #endif /* __LOW_LOOP_H__ */ \ No newline at end of file diff --git a/src/low_main.cpp b/src/low_main.cpp index 27f395b..7f5aec5 100644 --- a/src/low_main.cpp +++ b/src/low_main.cpp @@ -20,6 +20,7 @@ #include "low_system.h" #include "duktape.h" + #if LOW_INCLUDE_CARES_RESOLVER #include "../deps/c-ares/ares.h" #include "LowDNSResolver.h" @@ -65,7 +66,7 @@ static void *low_duk_alloc(void *udata, duk_size_t size) static void *low_duk_realloc(void *udata, void *ptr, duk_size_t size) { - if(size == 0) + if (size == 0) { low_free(ptr); return NULL; @@ -98,9 +99,8 @@ static void low_duk_fatal(void *udata, const char *msg) #else low_error(msg); - fprintf(stderr, - "--- exiting as we reached fatal error handler, should not " - "happen ---\n"); + fprintf(stderr, "--- exiting as we reached fatal error handler, should not " + "happen ---\n"); exit(EXIT_FAILURE); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ } @@ -118,7 +118,7 @@ low_main_t *low_init() #endif /* LOW_INCLUDE_CARES_RESOLVER */ low_main_t *low = new(low_new) low_main_t(); - if(!low) + if (!low) { fprintf(stderr, "Memory full\n"); @@ -129,8 +129,10 @@ low_main_t *low_init() } low->web_thread = NULL; - for(int i = 0; i < LOW_NUM_DATA_THREADS; i++) + for (int i = 0; i < LOW_NUM_DATA_THREADS; i++) + { low->data_thread[i] = NULL; + } low->destroying = false; low->duk_flag_stop = 0; @@ -138,9 +140,8 @@ low_main_t *low_init() // we are doing this on reset low->duk_ctx = NULL; #else - low->duk_ctx = duk_create_heap( - low_duk_alloc, low_duk_realloc, low_duk_free, low, low_duk_fatal); - if(!low->duk_ctx) + low->duk_ctx = duk_create_heap(low_duk_alloc, low_duk_realloc, low_duk_free, low, low_duk_fatal); + if (!low->duk_ctx) { fprintf(stderr, "Cannot initialize Duktape heap\n"); @@ -160,8 +161,10 @@ low_main_t *low_init() low->last_chore_time = low_tick_count(); - if(pthread_mutex_init(&low->ref_mutex, NULL) != 0) + if (pthread_mutex_init(&low->ref_mutex, NULL) != 0) + { goto err; + } #if LOW_INCLUDE_CARES_RESOLVER if(pthread_mutex_init(&low->resolvers_mutex, NULL) != 0) @@ -172,7 +175,7 @@ low_main_t *low_init() low->resolvers_active = 0; #endif /* LOW_INCLUDE_CARES_RESOLVER */ - if(pthread_mutex_init(&low->loop_thread_mutex, NULL) != 0) + if (pthread_mutex_init(&low->loop_thread_mutex, NULL) != 0) { #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -180,7 +183,7 @@ low_main_t *low_init() pthread_mutex_destroy(&low->ref_mutex); goto err; } - if(pthread_cond_init(&low->loop_thread_cond, NULL) != 0) + if (pthread_cond_init(&low->loop_thread_cond, NULL) != 0) { #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -191,7 +194,7 @@ low_main_t *low_init() } low->loop_callback_first = low->loop_callback_last = NULL; - if(pthread_mutex_init(&low->data_thread_mutex, NULL) != 0) + if (pthread_mutex_init(&low->data_thread_mutex, NULL) != 0) { #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -202,7 +205,7 @@ low_main_t *low_init() goto err; } - if(pthread_cond_init(&low->data_thread_cond, NULL) != 0) + if (pthread_cond_init(&low->data_thread_cond, NULL) != 0) { #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -214,7 +217,7 @@ low_main_t *low_init() goto err; } - if(pthread_cond_init(&low->data_thread_done_cond, NULL) != 0) + if (pthread_cond_init(&low->data_thread_done_cond, NULL) != 0) { #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -230,7 +233,7 @@ low_main_t *low_init() low->data_callback_first[0] = low->data_callback_last[0] = NULL; low->data_callback_first[1] = low->data_callback_last[1] = NULL; - for(int i = 0; i < LOW_NUM_DATA_THREADS; i++) + for (int i = 0; i < LOW_NUM_DATA_THREADS; i++) { #if LOW_ESP32_LWIP_SPECIALITIES err = xTaskCreatePinnedToCore((void (*)(void *))low_data_thread_main, @@ -245,15 +248,16 @@ low_main_t *low_init() fprintf( stderr, "failed to create data task, error code: %d\n", err); #else - if(pthread_create( - &low->data_thread[i], NULL, low_data_thread_main, low) != 0) + if (pthread_create(&low->data_thread[i], NULL, low_data_thread_main, low) != 0) { pthread_mutex_lock(&low->data_thread_mutex); low->destroying = 1; pthread_cond_broadcast(&low->data_thread_cond); pthread_mutex_unlock(&low->data_thread_mutex); - for(int j = 0; j < i; j++) + for (int j = 0; j < i; j++) + { pthread_join(low->data_thread[j], NULL); + } #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -272,14 +276,16 @@ low_main_t *low_init() low->web_thread_done = low->web_thread_notinevents = false; #if !LOW_ESP32_LWIP_SPECIALITIES - if(pipe(low->web_thread_pipe) < 0) + if (pipe(low->web_thread_pipe) < 0) { pthread_mutex_lock(&low->data_thread_mutex); low->destroying = 1; pthread_cond_broadcast(&low->data_thread_cond); pthread_mutex_unlock(&low->data_thread_mutex); - for(int i = 0; i < LOW_NUM_DATA_THREADS; i++) + for (int i = 0; i < LOW_NUM_DATA_THREADS; i++) + { pthread_join(low->data_thread[i], NULL); + } #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -294,7 +300,7 @@ low_main_t *low_init() goto err; } #endif /* !LOW_ESP32_LWIP_SPECIALITIES */ - if(pthread_mutex_init(&low->web_thread_mutex, NULL) != 0) + if (pthread_mutex_init(&low->web_thread_mutex, NULL) != 0) { #if !LOW_ESP32_LWIP_SPECIALITIES close(low->web_thread_pipe[0]); @@ -304,8 +310,10 @@ low_main_t *low_init() low->destroying = 1; pthread_cond_broadcast(&low->data_thread_cond); pthread_mutex_unlock(&low->data_thread_mutex); - for(int i = 0; i < LOW_NUM_DATA_THREADS; i++) + for (int i = 0; i < LOW_NUM_DATA_THREADS; i++) + { pthread_join(low->data_thread[i], NULL); + } #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -320,7 +328,7 @@ low_main_t *low_init() goto err; } - if(pthread_cond_init(&low->web_thread_done_cond, NULL) != 0) + if (pthread_cond_init(&low->web_thread_done_cond, NULL) != 0) { #if !LOW_ESP32_LWIP_SPECIALITIES close(low->web_thread_pipe[0]); @@ -330,8 +338,10 @@ low_main_t *low_init() low->destroying = 1; pthread_cond_broadcast(&low->data_thread_cond); pthread_mutex_unlock(&low->data_thread_mutex); - for(int i = 0; i < LOW_NUM_DATA_THREADS; i++) + for (int i = 0; i < LOW_NUM_DATA_THREADS; i++) + { pthread_join(low->data_thread[i], NULL); + } #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -359,7 +369,7 @@ low_main_t *low_init() { fprintf(stderr, "failed to create web task, error code: %d\n", err); #else - if(pthread_create(&low->web_thread, NULL, low_web_thread_main, low) != 0) + if (pthread_create(&low->web_thread, NULL, low_web_thread_main, low) != 0) { close(low->web_thread_pipe[0]); close(low->web_thread_pipe[1]); @@ -368,8 +378,10 @@ low_main_t *low_init() low->destroying = 1; pthread_cond_broadcast(&low->data_thread_cond); pthread_mutex_unlock(&low->data_thread_mutex); - for(int i = 0; i < LOW_NUM_DATA_THREADS; i++) + for (int i = 0; i < LOW_NUM_DATA_THREADS; i++) + { pthread_join(low->data_thread[i], NULL); + } #if LOW_INCLUDE_CARES_RESOLVER pthread_mutex_destroy(&low->resolvers_mutex); @@ -390,7 +402,7 @@ low_main_t *low_init() low->fds[0] = new(low_new) LowSocket(low, 0); low->fds[1] = new(low_new) LowSocket(low, 1); low->fds[2] = new(low_new) LowSocket(low, 2); - if(!low->fds[0] || !low->fds[1] || !low->fds[2]) + if (!low->fds[0] || !low->fds[1] || !low->fds[2]) { low_destroy(low); return NULL; @@ -426,7 +438,7 @@ low_main_t *duk_get_low_context(duk_context *ctx) { duk_memory_functions funcs; duk_get_memory_functions(ctx, &funcs); - return (low_main_t *)funcs.udata; + return (low_main_t *) funcs.udata; } @@ -642,11 +654,12 @@ static duk_ret_t low_lib_init_safe(duk_context *ctx, void *udata) bool low_lib_init(low_main_t *low) { - if(duk_safe_call(low->duk_ctx, low_lib_init_safe, NULL, 0, 1) != - DUK_EXEC_SUCCESS) + if (duk_safe_call(low->duk_ctx, low_lib_init_safe, NULL, 0, 1) != DUK_EXEC_SUCCESS) { - if(!low->duk_flag_stop) + if (!low->duk_flag_stop) + { low_duk_print_error(low->duk_ctx); + } return false; } duk_pop(low->duk_ctx); @@ -661,8 +674,10 @@ void low_destroy(low_main_t *low) { #if !LOW_ESP32_LWIP_SPECIALITIES g_low_system.signal_pipe_fd = low->web_thread_pipe[1]; - if(g_low_system.signal_pipe_fd == low->web_thread_pipe[1]) + if (g_low_system.signal_pipe_fd == low->web_thread_pipe[1]) + { g_low_system.signal_pipe_fd = -1; + } low->destroying = true; low_web_thread_break(low); @@ -678,17 +693,25 @@ void low_destroy(low_main_t *low) pthread_cond_broadcast(&low->data_thread_cond); pthread_mutex_unlock(&low->data_thread_mutex); - for(int i = 0; i < LOW_NUM_DATA_THREADS; i++) + for (int i = 0; i < LOW_NUM_DATA_THREADS; i++) + { pthread_join(low->data_thread[i], NULL); + } // Then we close all FDs and delete all classes behind the callbacks - while(low->loop_callback_first) // before FDs important for LowDNSResolver! + while (low->loop_callback_first) + { // before FDs important for LowDNSResolver! delete low->loop_callback_first; - while(low->data_callback_first[0]) + } + while (low->data_callback_first[0]) + { delete low->data_callback_first[0]; - while(low->data_callback_first[1]) + } + while (low->data_callback_first[1]) + { delete low->data_callback_first[1]; - for(auto iter = low->fds.begin(); iter != low->fds.end();) + } + for (auto iter = low->fds.begin(); iter != low->fds.end();) { auto iter2 = iter; iter++; @@ -708,10 +731,12 @@ void low_destroy(low_main_t *low) pthread_mutex_destroy(&low->loop_thread_mutex); pthread_cond_destroy(&low->loop_thread_cond); - if(low->duk_ctx) + if (low->duk_ctx) + { duk_destroy_heap(low->duk_ctx); + } - // After finalizers.. they must not use DukTape heap! + // After finalizers.. they must not use DukTape heap! #if LOW_INCLUDE_CARES_RESOLVER for(int i = 0; i < low->resolvers.size(); i++) if(low->resolvers[i]) @@ -720,12 +745,20 @@ void low_destroy(low_main_t *low) pthread_mutex_destroy(&low->resolvers_mutex); #endif /* LOW_INCLUDE_CARES_RESOLVER */ - for(int i = 0; i < low->tlsContexts.size(); i++) - if(low->tlsContexts[i]) + for (int i = 0; i < low->tlsContexts.size(); i++) + { + if (low->tlsContexts[i]) + { delete low->tlsContexts[i]; - for(int i = 0; i < low->cryptoHashes.size(); i++) - if(low->cryptoHashes[i]) - delete low->cryptoHashes[i]; // TODO: also needed in restart? + } + } + for (int i = 0; i < low->cryptoHashes.size(); i++) + { + if (low->cryptoHashes[i]) + { + delete low->cryptoHashes[i]; + } + } // TODO: also needed in restart? pthread_mutex_destroy(&low->ref_mutex); low_free(low); @@ -738,24 +771,30 @@ void low_destroy(low_main_t *low) int low_add_stash(low_main_t *low, int index) { - if(low->duk_flag_stop) + if (low->duk_flag_stop) + { return 0; + } duk_context *ctx = low->duk_ctx; - if(duk_is_undefined(ctx, index)) + if (duk_is_undefined(ctx, index)) + { return 0; + } duk_push_heap_stash(ctx); duk_get_prop_string(ctx, -1, "low"); int stashIndex; - while(true) + while (true) { stashIndex = ++low->last_stash_index; - if(!stashIndex) + if (!stashIndex) + { stashIndex = ++low->last_stash_index; + } - if(!duk_get_prop_index(ctx, -1, stashIndex)) + if (!duk_get_prop_index(ctx, -1, stashIndex)) { duk_pop(ctx); break; @@ -776,8 +815,10 @@ int low_add_stash(low_main_t *low, int index) void low_remove_stash(low_main_t *low, int index) { - if(low->duk_flag_stop) + if (low->duk_flag_stop) + { return; + } duk_context *ctx = low->duk_ctx; duk_push_heap_stash(ctx); @@ -792,15 +833,19 @@ void low_remove_stash(low_main_t *low, int index) void low_push_stash(low_main_t *low, int index, bool remove) { - if(low->duk_flag_stop) + if (low->duk_flag_stop) + { return; + } duk_context *ctx = low->duk_ctx; duk_push_heap_stash(ctx); duk_get_prop_string(ctx, -1, "low"); duk_get_prop_index(ctx, -1, index); - if(remove) + if (remove) + { duk_del_prop_index(ctx, -2, index); + } duk_replace(ctx, -3); duk_pop(ctx); } @@ -811,13 +856,19 @@ void low_push_stash(low_main_t *low, int index, bool remove) void low_duk_print_error(duk_context *ctx) { - if(duk_is_error(ctx, -1)) + if (duk_is_error(ctx, -1)) { - if(duk_get_prop_string(ctx, -1, "stack")) + if (duk_get_prop_string(ctx, -1, "stack")) + { low_error(duk_safe_to_string(ctx, -1)); + } else + { low_error("JavaScript error with stack"); + } } else + { low_error("JavaScript error with without error object"); + } } \ No newline at end of file diff --git a/src/low_main.h b/src/low_main.h index 4ce94d8..6ef2b2d 100644 --- a/src/low_main.h +++ b/src/low_main.h @@ -21,80 +21,79 @@ using namespace std; class LowLoopCallback; + class LowDataCallback; + class LowFD; + class LowDNSResolver; + class LowTLSContext; + class LowCryptoHash; struct low_main_t { - uint8_t duk_flag_stop; - bool destroying; - duk_context *duk_ctx; - - int run_ref, last_stash_index; - int signal_call_id; - - map, - low_allocator>> - chores; - multimap, low_allocator>> - chore_times; - int last_chore_time; - - pthread_mutex_t loop_thread_mutex; - pthread_cond_t loop_thread_cond; - LowLoopCallback *loop_callback_first, *loop_callback_last; + uint8_t duk_flag_stop; + bool destroying; + duk_context *duk_ctx; + + int run_ref, last_stash_index; + int signal_call_id; + + map, low_allocator>> chores; + multimap, low_allocator>> chore_times; + int last_chore_time; + + pthread_mutex_t loop_thread_mutex; + pthread_cond_t loop_thread_cond; + LowLoopCallback *loop_callback_first, *loop_callback_last; #if LOW_ESP32_LWIP_SPECIALITIES - TaskHandle_t data_thread[LOW_NUM_DATA_THREADS]; - TaskHandle_t web_thread; + TaskHandle_t data_thread[LOW_NUM_DATA_THREADS]; + TaskHandle_t web_thread; #else - pthread_t data_thread[LOW_NUM_DATA_THREADS]; - pthread_t web_thread; + pthread_t data_thread[LOW_NUM_DATA_THREADS]; + pthread_t web_thread; #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - bool data_thread_done; - pthread_mutex_t data_thread_mutex; - pthread_cond_t data_thread_cond, data_thread_done_cond; - LowDataCallback *data_callback_first[2], *data_callback_last[2]; + bool data_thread_done; + pthread_mutex_t data_thread_mutex; + pthread_cond_t data_thread_cond, data_thread_done_cond; + LowDataCallback *data_callback_first[2], *data_callback_last[2]; - pthread_mutex_t web_thread_mutex; - pthread_cond_t web_thread_done_cond; + pthread_mutex_t web_thread_mutex; + pthread_cond_t web_thread_done_cond; #if !LOW_ESP32_LWIP_SPECIALITIES - int web_thread_pipe[2]; + int web_thread_pipe[2]; #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - LowFD *web_changed_first, *web_changed_last; - bool web_thread_done, web_thread_notinevents; + LowFD *web_changed_first, *web_changed_last; + bool web_thread_done, web_thread_notinevents; - map, low_allocator>> fds; + map, low_allocator >> fds; #if LOW_INCLUDE_CARES_RESOLVER - vector> resolvers; - int resolvers_active; - pthread_mutex_t resolvers_mutex; + vector> resolvers; + int resolvers_active; + pthread_mutex_t resolvers_mutex; #endif /* LOW_INCLUDE_CARES_RESOLVER */ - vector> tlsContexts; - vector> cryptoHashes; + vector> tlsContexts; + vector> cryptoHashes; - pthread_mutex_t ref_mutex; + pthread_mutex_t ref_mutex; #if LOW_ESP32_LWIP_SPECIALITIES - char *cwd; + char *cwd; #endif /* LOW_ESP32_LWIP_SPECIALITIES */ }; -extern "C" -{ - low_main_t *low_init(); - bool low_lib_init(low_main_t *low); - void low_destroy(low_main_t *low); +extern "C" { +low_main_t *low_init(); +bool low_lib_init(low_main_t *low); +void low_destroy(low_main_t *low); - duk_context *low_get_duk_context(low_main_t *low); - low_main_t *duk_get_low_context(duk_context *ctx); +duk_context *low_get_duk_context(low_main_t *low); +low_main_t *duk_get_low_context(duk_context *ctx); } #if LOW_ESP32_LWIP_SPECIALITIES @@ -102,7 +101,9 @@ bool low_reset(low_main_t *low); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ int low_add_stash(low_main_t *low, int index); + void low_remove_stash(low_main_t *low, int index); + void low_push_stash(low_main_t *low, int index, bool remove); void low_duk_print_error(duk_context *duk); diff --git a/src/low_module.cpp b/src/low_module.cpp index 3a9c8dc..c2a8b32 100644 --- a/src/low_module.cpp +++ b/src/low_module.cpp @@ -58,11 +58,11 @@ void low_module_init(duk_context *ctx) static duk_ret_t low_module_make_native_safe(duk_context *ctx, void *udata) { - low_main_t *low = *(low_main_t **)udata; - char *name = (char *)(((void **)udata)[1]); - void (*setup_safe_cb)(low_main_t * main, void *data) = - (void (*)(low_main_t * main, void *data))(((void **)udata)[2]); - void *setup_safe_cb_data = ((void **)udata)[3]; + low_main_t *low = *(low_main_t **) udata; + char *name = (char *) (((void **) udata)[1]); + void (*setup_safe_cb)(low_main_t *main, void *data) = + (void (*)(low_main_t *main, void *data)) (((void **) udata)[2]); + void *setup_safe_cb_data = ((void **) udata)[3]; duk_push_object(ctx); // our new module! @@ -85,10 +85,8 @@ static duk_ret_t low_module_make_native_safe(duk_context *ctx, void *udata) duk_put_prop_string(ctx, -2, "children"); duk_push_object(ctx); - duk_put_prop_string(ctx, - -2, - "\xff" - "childrenMap"); + duk_put_prop_string(ctx, -2, "\xff" + "childrenMap"); // [... module] @@ -96,10 +94,8 @@ static duk_ret_t low_module_make_native_safe(duk_context *ctx, void *udata) duk_push_c_function(ctx, low_module_require, 1); duk_dup(ctx, -2); - duk_put_prop_string(ctx, - -2, - "\xff" - "module"); + duk_put_prop_string(ctx, -2, "\xff" + "module"); duk_push_string(ctx, "name"); duk_push_string(ctx, "require"); // this is used in call stack @@ -120,10 +116,8 @@ static duk_ret_t low_module_make_native_safe(duk_context *ctx, void *udata) duk_push_c_function(ctx, low_module_resolve, 2); duk_dup(ctx, -2); - duk_put_prop_string(ctx, - -2, - "\xff" - "module"); + duk_put_prop_string(ctx, -2, "\xff" + "module"); duk_push_string(ctx, "name"); duk_push_string(ctx, "resolve"); // this is used in call stack @@ -153,19 +147,16 @@ static duk_ret_t low_module_make_native_safe(duk_context *ctx, void *udata) return 0; } -bool low_module_make_native(low_main_t *low, - const char *name, - void (*setup_safe_cb)(low_main_t *main, void *data), +bool low_module_make_native(low_main_t *low, const char *name, void (*setup_safe_cb)(low_main_t *main, void *data), void *setup_safe_cb_data) { - void *data[4] = { - (void *)low, (void *)name, (void *)setup_safe_cb, setup_safe_cb_data}; - if(duk_safe_call( - low->duk_ctx, low_module_make_native_safe, (void *)data, 0, 1) != - DUK_EXEC_SUCCESS) + void *data[4] = {(void *) low, (void *) name, (void *) setup_safe_cb, setup_safe_cb_data}; + if (duk_safe_call(low->duk_ctx, low_module_make_native_safe, (void *) data, 0, 1) != DUK_EXEC_SUCCESS) { - if(!low->duk_flag_stop) // flag stop also produces error + if (!low->duk_flag_stop) + { // flag stop also produces error low_duk_print_error(low->duk_ctx); + } duk_pop(low->duk_ctx); return low->duk_flag_stop; @@ -183,16 +174,16 @@ bool neonious_start_result(const char *code); static duk_ret_t low_module_main_safe(duk_context *ctx, void *udata) { - char *path = (char *)udata; - if(path) + char *path = (char *) udata; + if (path) { - char *res_id = (char *)duk_push_fixed_buffer(ctx, 1024); - if(!low_module_resolve_c(ctx, path, ".", res_id)) + char *res_id = (char *) duk_push_fixed_buffer(ctx, 1024); + if (!low_module_resolve_c(ctx, path, ".", res_id)) { #if LOW_ESP32_LWIP_SPECIALITIES if(!neonious_start_result("FILE_NOT_FOUND")) #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - duk_type_error(ctx, "cannot resolve module '%s'", path); + duk_type_error(ctx, "cannot resolve module '%s'", path); return 1; } @@ -202,7 +193,9 @@ static duk_ret_t low_module_main_safe(duk_context *ctx, void *udata) low_module_run(ctx, res_id, LOW_MODULE_FLAG_MAIN); } else + { low_module_run(ctx, "lib:main", LOW_MODULE_FLAG_MAIN); + } return 0; } @@ -214,18 +207,18 @@ bool low_module_main(low_main_t *low, const char *path) DUK_EXEC_SUCCESS) #else char path2[PATH_MAX]; - if(path) + if (path) + { realpath(path, path2); + } - if(duk_safe_call(low->duk_ctx, - low_module_main_safe, - (void *)(path ? path2 : NULL), - 0, - 1) != DUK_EXEC_SUCCESS) + if (duk_safe_call(low->duk_ctx, low_module_main_safe, (void *) (path ? path2 : NULL), 0, 1) != DUK_EXEC_SUCCESS) #endif /* LOW_ESP32_LWIP_SPECIALITIES */ { - if(!low->duk_flag_stop) // flag stop also produces error + if (!low->duk_flag_stop) + { // flag stop also produces error low_duk_print_error(low->duk_ctx); + } duk_pop(low->duk_ctx); return low->duk_flag_stop; @@ -246,8 +239,7 @@ bool get_data_block(const char *path, bool escapeZero = false); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - void - low_module_run(duk_context *ctx, const char *path, int flags) +void low_module_run(duk_context *ctx, const char *path, int flags) { unsigned char *data; int len; @@ -256,14 +248,19 @@ bool get_data_block(const char *path, bool isLib = memcmp(path, "lib:", 4) == 0; int fullLen = strlen(path); - for(len = fullLen; len >= 0; len--) - if(path[len] == '.') + for (len = fullLen; len >= 0; len--) + { + if (path[len] == '.') + { break; - if(fullLen - len == 5 && path[len] == '.' && (path[len + 1] == 'j' || path[len + 1] == 'J') && - (path[len + 2] == 's' || path[len + 2] == 'S') && - (path[len + 3] == 'o' || path[len + 3] == 'O') && - (path[len + 4] == 'n' || path[len + 4] == 'N')) + } + } + if (fullLen - len == 5 && path[len] == '.' && (path[len + 1] == 'j' || path[len + 1] == 'J') && + (path[len + 2] == 's' || path[len + 2] == 'S') && (path[len + 3] == 'o' || path[len + 3] == 'O') && + (path[len + 4] == 'n' || path[len + 4] == 'N')) + { flags |= LOW_MODULE_FLAG_JSON; + } #if LOW_ESP32_LWIP_SPECIALITIES char *txt; @@ -331,14 +328,18 @@ bool get_data_block(const char *path, } #else int fd; - if(isLib) + if (isLib) { - if(len > 1000) + if (len > 1000) + { goto cantLoad; + } - char *txt = (char *)low_alloc(1024); - if(!txt) + char *txt = (char *) low_alloc(1024); + if (!txt) + { goto cantLoad; + } sprintf(txt, "%s%s.low", g_low_system.lib_path, path + 4); flags |= LOW_MODULE_FLAG_DUK_FORMAT; @@ -347,24 +348,28 @@ bool get_data_block(const char *path, low_free(txt); } else + { fd = open(path, O_RDONLY); - if(fd < 0) + } + if (fd < 0) + { duk_type_error(ctx, "cannot find module '%s'", path); + } - if(fstat(fd, &st) < 0) + if (fstat(fd, &st) < 0) { close(fd); goto cantLoad; } len = st.st_size; // TODO: use buffer object so we no longer have a memory - // leak! - data = (unsigned char *)low_alloc(len); - if(!data) + // leak! + data = (unsigned char *) low_alloc(len); + if (!data) { close(fd); goto cantLoad; } - if(read(fd, data, len) != len) + if (read(fd, data, len) != len) { low_free(data); close(fd); @@ -375,12 +380,12 @@ bool get_data_block(const char *path, duk_push_object(ctx); // our new module! - if(flags & LOW_MODULE_FLAG_MAIN) + if (flags & LOW_MODULE_FLAG_MAIN) { duk_dup(ctx, -1); duk_put_prop_string(ctx, -2, "main"); } - else if(!(flags & LOW_MODULE_FLAG_GLOBAL)) + else if (!(flags & LOW_MODULE_FLAG_GLOBAL)) { duk_get_prop_string(ctx, -2, "main"); duk_put_prop_string(ctx, -2, "main"); @@ -394,12 +399,16 @@ bool get_data_block(const char *path, duk_put_prop_string(ctx, -3, "filename"); duk_put_prop_string(ctx, -2, "id"); - if(!(flags & LOW_MODULE_FLAG_JSON)) + if (!(flags & LOW_MODULE_FLAG_JSON)) { - if(flags & LOW_MODULE_FLAG_GLOBAL) + if (flags & LOW_MODULE_FLAG_GLOBAL) + { duk_push_global_object(ctx); + } else + { duk_push_object(ctx); + } duk_put_prop_string(ctx, -2, "exports"); } @@ -413,10 +422,8 @@ bool get_data_block(const char *path, duk_put_prop_string(ctx, -2, "children"); duk_push_object(ctx); - duk_put_prop_string(ctx, - -2, - "\xff" - "childrenMap"); + duk_put_prop_string(ctx, -2, "\xff" + "childrenMap"); // [... module] @@ -424,10 +431,8 @@ bool get_data_block(const char *path, duk_push_c_function(ctx, low_module_require, 1); duk_dup(ctx, -2); - duk_put_prop_string(ctx, - -2, - "\xff" - "module"); + duk_put_prop_string(ctx, -2, "\xff" + "module"); duk_push_string(ctx, "name"); duk_push_string(ctx, "require"); // this is used in call stack @@ -448,10 +453,8 @@ bool get_data_block(const char *path, duk_push_c_function(ctx, low_module_resolve, 1); duk_dup(ctx, -3); - duk_put_prop_string(ctx, - -2, - "\xff" - "module"); + duk_put_prop_string(ctx, -2, "\xff" + "module"); duk_push_string(ctx, "name"); duk_push_string(ctx, "resolve"); // this is used in call stack @@ -462,26 +465,27 @@ bool get_data_block(const char *path, duk_get_prop_string(ctx, -2, "main"); duk_put_prop_string(ctx, -2, "main"); - if(!isLib && !(flags & LOW_MODULE_FLAG_JSON)) // security problem + if (!isLib && !(flags & LOW_MODULE_FLAG_JSON)) + { // security problem duk_put_prop_string(ctx, -2, "require"); + } // [... module [require]] - if(!(flags & LOW_MODULE_FLAG_GLOBAL)) + if (!(flags & LOW_MODULE_FLAG_GLOBAL)) { // Cache module duk_push_heap_stash(ctx); - duk_get_prop_string( - ctx, -1, memcmp(path, "lib:", 4) == 0 ? "lib_modules" : "modules"); + duk_get_prop_string(ctx, -1, memcmp(path, "lib:", 4) == 0 ? "lib_modules" : "modules"); duk_dup(ctx, !isLib && !(flags & LOW_MODULE_FLAG_JSON) ? -3 : -4); duk_put_prop_string(ctx, -2, path); duk_pop_2(ctx); } - if(flags & LOW_MODULE_FLAG_JSON) + if (flags & LOW_MODULE_FLAG_JSON) { - duk_push_lstring(ctx, (char *)data, len); + duk_push_lstring(ctx, (char *) data, len); low_free(data); duk_json_decode(ctx, -1); @@ -491,11 +495,9 @@ bool get_data_block(const char *path, } else { - if(flags & LOW_MODULE_FLAG_DUK_FORMAT) + if (flags & LOW_MODULE_FLAG_DUK_FORMAT) { - memcpy(duk_push_fixed_buffer(ctx, len), - data, - len); // TODO: remove copy + memcpy(duk_push_fixed_buffer(ctx, len), data, len); // TODO: remove copy low_free(data); duk_load_function(ctx); } @@ -503,12 +505,9 @@ bool get_data_block(const char *path, { // TODO: remove concat bool shebang = len >= 2 && data[0] == '#' && data[1] == '!'; - duk_push_string( - ctx, - shebang - ? "function(exports,require,module,__filename,__dirname){//" - : "function(exports,require,module,__filename,__dirname){"); - duk_push_lstring(ctx, (char *)data, len); + duk_push_string(ctx, shebang ? "function(exports,require,module,__filename,__dirname){//" + : "function(exports,require,module,__filename,__dirname){"); + duk_push_lstring(ctx, (char *) data, len); low_free(data); duk_push_string(ctx, "\n}"); /* Newline allows module last line to contain a // comment. */ @@ -522,19 +521,25 @@ bool get_data_block(const char *path, /* call the function wrapper */ duk_get_prop_string(ctx, isLib ? -3 : -2, "exports"); /* exports */ - if(isLib) + if (isLib) { duk_dup(ctx, -3); /* require */ duk_remove(ctx, -4); } else - duk_get_prop_string(ctx, -3, "require"); /* require */ + { + duk_get_prop_string(ctx, -3, "require"); + } /* require */ duk_dup(ctx, -4); /* module */ duk_push_string(ctx, path); /* __filename */ - for(len = strlen(path) - 1; len > 0; len--) - if(path[len] == '/') + for (len = strlen(path) - 1; len > 0; len--) + { + if (path[len] == '/') + { break; + } + } duk_push_lstring(ctx, path, len == -1 ? 0 : len); /* __dirname */ duk_call(ctx, 5); @@ -559,51 +564,53 @@ bool get_data_block(const char *path, duk_ret_t low_module_require(duk_context *ctx) { - char *res_id = (char *)duk_push_fixed_buffer(ctx, 1024); + char *res_id = (char *) duk_push_fixed_buffer(ctx, 1024); const char *id = duk_require_string(ctx, 0); // Get parent ID duk_push_current_function(ctx); - duk_get_prop_string(ctx, - -1, - "\xff" - "module"); + duk_get_prop_string(ctx, -1, "\xff" + "module"); duk_remove(ctx, -2); const char *parent_id; int popCount = 0; - while(true) + while (true) { duk_get_prop_string(ctx, -1, "filename"); parent_id = duk_get_string(ctx, -1); duk_pop(ctx); - if(parent_id) + if (parent_id) + { break; + } // If a module does not have a filename (vm.createContext), then try // parent popCount++; - if(!duk_get_prop_string(ctx, -1, "parent")) + if (!duk_get_prop_string(ctx, -1, "parent")) + { break; + } } - while(popCount--) + while (popCount--) + { duk_pop(ctx); + } // We always resolve with our own function - if(!low_module_resolve_c(ctx, id, parent_id, res_id)) + if (!low_module_resolve_c(ctx, id, parent_id, res_id)) { - duk_type_error( - ctx, "cannot resolve module '%s', parent '%s'", id, parent_id); + duk_type_error(ctx, "cannot resolve module '%s', parent '%s'", id, parent_id); return 1; } // Try to find in cache duk_push_heap_stash(ctx); - duk_get_prop_string( - ctx, -1, memcmp(res_id, "lib:", 4) == 0 ? "lib_modules" : "modules"); - if(duk_get_prop_string(ctx, -1, res_id)) + duk_get_prop_string(ctx, -1, memcmp(res_id, "lib:", 4) == 0 ? "lib_modules" : "modules"); + if (duk_get_prop_string(ctx, -1, res_id)) { duk_remove(ctx, -2); duk_remove(ctx, -2); @@ -619,14 +626,14 @@ duk_ret_t low_module_require(duk_context *ctx) // [ id parent module ] - if(memcmp(parent_id, "lib:", 4) != 0) // security check + if (memcmp(parent_id, "lib:", 4) != 0) // security check { - duk_get_prop_string(ctx, - -2, - "\xff" - "childrenMap"); - if(duk_get_prop_string(ctx, -1, res_id)) + duk_get_prop_string(ctx, -2, "\xff" + "childrenMap"); + if (duk_get_prop_string(ctx, -1, res_id)) + { duk_pop_2(ctx); + } else { duk_push_boolean(ctx, true); @@ -652,47 +659,50 @@ duk_ret_t low_module_require(duk_context *ctx) duk_ret_t low_module_resolve(duk_context *ctx) { - char *res_id = (char *)duk_push_fixed_buffer(ctx, 1024); + char *res_id = (char *) duk_push_fixed_buffer(ctx, 1024); const char *id = duk_require_string(ctx, 0); // Get parent ID duk_push_current_function(ctx); - duk_get_prop_string(ctx, - -1, - "\xff" - "module"); + duk_get_prop_string(ctx, -1, "\xff" + "module"); duk_remove(ctx, -2); const char *parent_id; int popCount = 1; - while(true) + while (true) { duk_get_prop_string(ctx, -1, "filename"); parent_id = duk_get_string(ctx, -1); duk_pop(ctx); - if(parent_id) + if (parent_id) + { break; + } // If a module does not have a filename (vm.createContext), then try // parent popCount++; - if(!duk_get_prop_string(ctx, -1, "parent")) + if (!duk_get_prop_string(ctx, -1, "parent")) + { break; + } } - while(popCount--) + while (popCount--) + { duk_pop(ctx); + } - if(low_module_resolve_c(ctx, id, parent_id, res_id)) + if (low_module_resolve_c(ctx, id, parent_id, res_id)) { duk_push_string(ctx, res_id); return 1; } else { - duk_type_error( - ctx, "cannot resolve module '%s', parent '%s'", id, parent_id); + duk_type_error(ctx, "cannot resolve module '%s', parent '%s'", id, parent_id); return 1; } } @@ -730,10 +740,8 @@ duk_ret_t low_module_make(duk_context *ctx) duk_put_prop_string(ctx, -2, "children"); duk_push_object(ctx); - duk_put_prop_string(ctx, - -2, - "\xff" - "childrenMap"); + duk_put_prop_string(ctx, -2, "\xff" + "childrenMap"); // [... module] @@ -741,10 +749,8 @@ duk_ret_t low_module_make(duk_context *ctx) duk_push_c_function(ctx, low_module_require, 1); duk_dup(ctx, -2); - duk_put_prop_string(ctx, - -2, - "\xff" - "module"); + duk_put_prop_string(ctx, -2, "\xff" + "module"); duk_push_string(ctx, "name"); duk_push_string(ctx, "require"); // this is used in call stack @@ -765,10 +771,8 @@ duk_ret_t low_module_make(duk_context *ctx) duk_push_c_function(ctx, low_module_resolve, 2); duk_dup(ctx, -2); - duk_put_prop_string(ctx, - -2, - "\xff" - "module"); + duk_put_prop_string(ctx, -2, "\xff" + "module"); duk_push_string(ctx, "name"); duk_push_string(ctx, "resolve"); // this is used in call stack @@ -795,17 +799,13 @@ duk_ret_t low_module_make(duk_context *ctx) // result must be min 1024 bytes // ----------------------------------------------------------------------------- -bool low_module_resolve_c(duk_context *ctx, - const char *module_id, - const char *parent_id, - char *res_id) +bool low_module_resolve_c(duk_context *ctx, const char *module_id, const char *parent_id, char *res_id) { struct stat st; // lib: may get native - if(strcmp(module_id, "native") == 0 && parent_id && - (memcmp(parent_id, "lib:", 4) == 0 || - memcmp(parent_id, "module:", 7) == 0)) + if (strcmp(module_id, "native") == 0 && parent_id && + (memcmp(parent_id, "lib:", 4) == 0 || memcmp(parent_id, "module:", 7) == 0)) { strcpy(res_id, "lib:native"); return true; @@ -813,20 +813,21 @@ bool low_module_resolve_c(duk_context *ctx, bool is_not_absolute_path = false; int i; - for(i = 0; module_id[i]; i++) - if(module_id[i] == '.') + for (i = 0; module_id[i]; i++) + { + if (module_id[i] == '.') { is_not_absolute_path = true; break; } - if(!is_not_absolute_path && i < 1000 && strcmp(module_id, "init") != 0 && - strcmp(module_id, "main") != 0) + } + if (!is_not_absolute_path && i < 1000 && strcmp(module_id, "init") != 0 && strcmp(module_id, "main") != 0) { sprintf(res_id, "lib:%s", module_id); duk_push_heap_stash(ctx); duk_get_prop_string(ctx, -1, "lib_modules"); - if(duk_get_prop_string(ctx, -1, res_id)) + if (duk_get_prop_string(ctx, -1, res_id)) { duk_pop_3(ctx); return true; @@ -835,38 +836,44 @@ bool low_module_resolve_c(duk_context *ctx, // system module sprintf(res_id, "%s%s.low", g_low_system.lib_path, module_id); - if(stat(res_id, &st) == 0) + if (stat(res_id, &st) == 0) { sprintf(res_id, "lib:%s", module_id); return true; } } - if(!parent_id || memcmp(parent_id, "lib:", 4) == 0) + if (!parent_id || memcmp(parent_id, "lib:", 4) == 0) + { return false; + } const char *parent_end = NULL; - while(true) + while (true) { - if(!parent_end) + if (!parent_end) { // For next start parent_end = parent_id + strlen(parent_id); - if(!((module_id[0] == '.' && module_id[1] == '/') || - (module_id[0] == '/') || - (module_id[0] == '.' && module_id[1] == '.' && - module_id[2] == '/'))) + if (!((module_id[0] == '.' && module_id[1] == '/') || (module_id[0] == '/') || + (module_id[0] == '.' && module_id[1] == '.' && module_id[2] == '/'))) + { continue; + } low_fs_resolve(res_id, 1024, parent_id, module_id); } else { // Go through node_modules - while(parent_id != parent_end && parent_end[-1] != '/') + while (parent_id != parent_end && parent_end[-1] != '/') + { parent_end--; - if(parent_id == parent_end) + } + if (parent_id == parent_end) + { return false; + } low_fs_resolve(res_id, 1024, parent_id, module_id, parent_end); parent_end--; @@ -878,15 +885,17 @@ bool low_module_resolve_c(duk_context *ctx, #endif /* LOW_ESP32_LWIP_SPECIALITIES */ bool isFolder = path[-1] == '/'; - if(isFolder) + if (isFolder) + { path--; + } - if(!isFolder) + if (!isFolder) { // LOAD_AS_FILE path[0] = 0; - if(stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) { #if LOW_ESP32_LWIP_SPECIALITIES memmove(res_id, start, path + 1 - start); @@ -894,10 +903,12 @@ bool low_module_resolve_c(duk_context *ctx, return true; } - if(path + 3 - res_id >= 1024) + if (path + 3 - res_id >= 1024) + { return false; + } strcpy(path, ".js"); - if(stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) { #if LOW_ESP32_LWIP_SPECIALITIES memmove(res_id, start, path + 4 - start); @@ -905,10 +916,12 @@ bool low_module_resolve_c(duk_context *ctx, return true; } - if(path + 5 - res_id >= 1024) + if (path + 5 - res_id >= 1024) + { return false; + } strcpy(path, ".json"); - if(stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) { #if LOW_ESP32_LWIP_SPECIALITIES memmove(res_id, start, path + 6 - start); @@ -919,20 +932,24 @@ bool low_module_resolve_c(duk_context *ctx, // LOAD_AS_DIRECTORY - if(path + 13 - res_id >= 1024) + if (path + 13 - res_id >= 1024) + { return false; + } strcpy(path, "/package.json"); - if(stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) { int len = st.st_size; void *data = duk_push_buffer(ctx, len, false); int fd = open(res_id, O_RDONLY); - if(fd < 0) + if (fd < 0) + { return false; + } - if(read(fd, data, len) != len) + if (read(fd, data, len) != len) { close(fd); duk_pop(ctx); @@ -944,12 +961,12 @@ bool low_module_resolve_c(duk_context *ctx, duk_buffer_to_string(ctx, -1); duk_json_decode(ctx, -1); - if(duk_get_prop_string(ctx, -1, "main")) + if (duk_get_prop_string(ctx, -1, "main")) { const char *str = duk_get_string(ctx, -1); len = strlen(str); - char *res_id2 = (char *)duk_push_buffer(ctx, 1024, false); + char *res_id2 = (char *) duk_push_buffer(ctx, 1024, false); low_fs_resolve(res_id2, 1024, res_id, str); char *path = res_id2 + strlen(res_id2); @@ -960,51 +977,61 @@ bool low_module_resolve_c(duk_context *ctx, #endif /* LOW_ESP32_LWIP_SPECIALITIES */ bool isFolder = path[-1] == '/'; - if(isFolder) + if (isFolder) + { path--; + } path[0] = 0; - if(stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) { memmove(res_id, start, path + 1 - start); duk_pop_3(ctx); return true; } - if(path + 3 - res_id2 >= 1024) + if (path + 3 - res_id2 >= 1024) + { return false; + } strcpy(path, ".js"); - if(stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) { memmove(res_id, start, path + 4 - start); duk_pop_3(ctx); return true; } - if(path + 5 - res_id2 >= 1024) + if (path + 5 - res_id2 >= 1024) + { return false; + } strcpy(path, ".json"); - if(stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) { memmove(res_id, start, path + 6 - start); duk_pop_3(ctx); return true; } - if(path + 9 - res_id2 >= 1024) + if (path + 9 - res_id2 >= 1024) + { return false; + } strcpy(path, "/index.js"); - if(stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) { memmove(res_id, start, path + 10 - start); duk_pop_3(ctx); return true; } - if(path + 11 - res_id2 >= 1024) + if (path + 11 - res_id2 >= 1024) + { return false; + } strcpy(path, "/index.json"); - if(stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id2, &st) == 0 && S_ISREG(st.st_mode)) { memmove(res_id, start, path + 12 - start); duk_pop_3(ctx); @@ -1014,13 +1041,17 @@ bool low_module_resolve_c(duk_context *ctx, duk_pop_3(ctx); } else + { duk_pop_2(ctx); + } } - if(path + 9 - res_id >= 1024) + if (path + 9 - res_id >= 1024) + { return false; + } strcpy(path, "/index.js"); - if(stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) { #if LOW_ESP32_LWIP_SPECIALITIES memmove(res_id, start, path + 10 - start); @@ -1028,10 +1059,12 @@ bool low_module_resolve_c(duk_context *ctx, return true; } - if(path + 11 - res_id >= 1024) + if (path + 11 - res_id >= 1024) + { return false; + } strcpy(path, "/index.json"); - if(stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) + if (stat(res_id, &st) == 0 && S_ISREG(st.st_mode)) { #if LOW_ESP32_LWIP_SPECIALITIES memmove(res_id, start, path + 12 - start); diff --git a/src/low_module.h b/src/low_module.h index 2c25e97..9eff32e 100644 --- a/src/low_module.h +++ b/src/low_module.h @@ -17,22 +17,19 @@ struct low_main_t; void low_module_init(duk_context *ctx); -extern "C" bool low_module_make_native(low_main_t *low, - const char *name, - void (*setup_safe_cb)(low_main_t *main, - void *data), - void *cb_data); +extern "C" bool +low_module_make_native(low_main_t *low, const char *name, void (*setup_safe_cb)(low_main_t *main, void *data), + void *cb_data); extern "C" bool low_module_main(low_main_t *low, const char *path); void low_module_run(duk_context *ctx, const char *path, int flags); duk_ret_t low_module_require(duk_context *ctx); + duk_ret_t low_module_resolve(duk_context *ctx); + duk_ret_t low_module_make(duk_context *ctx); -bool low_module_resolve_c(duk_context *ctx, - const char *module_id, - const char *parent_id, - char *res_id); +bool low_module_resolve_c(duk_context *ctx, const char *module_id, const char *parent_id, char *res_id); #endif /* __LOW_MODULE_H__ */ \ No newline at end of file diff --git a/src/low_native.cpp b/src/low_native.cpp index 6a58e24..19b031d 100644 --- a/src/low_native.cpp +++ b/src/low_native.cpp @@ -15,61 +15,60 @@ #include "low_tls.h" // The methods of the module 'native', accessable by files in lib_js directory -duk_function_list_entry g_low_native_methods[] = { - {"processInfo", low_process_info, 2}, - {"ttyInfo", low_tty_info, 0}, - {"hrtime", low_hrtime, 1}, - {"compile", low_compile, 1}, - {"runInContext", low_run_in_context, 4}, - {"compare", low_compare, 2}, - {"setChore", low_loop_set_chore, 3}, - {"clearChore", low_loop_clear_chore, 1}, - {"choreRef", low_loop_chore_ref, 2}, - {"runRef", low_loop_run_ref, 1}, - {"open", low_fs_open, 4}, - {"openSync", low_fs_open_sync, 3}, - {"close", low_fs_close, 2}, - {"closeSync", low_fs_close_sync, 1}, - {"read", low_fs_read, 6}, - {"write", low_fs_write, 6}, - {"fstat", low_fs_fstat, 2}, - {"stat", low_fs_stat, 2}, - {"rename", low_fs_rename, 3}, - {"unlink", low_fs_unlink, 2}, - {"access", low_fs_access, 3}, - {"readdir", low_fs_readdir, 3}, - {"mkdir", low_fs_mkdir, 3}, - {"rmdir", low_fs_rmdir, 2}, - {"statSync", low_fs_stat_sync, 1}, - {"renameSync", low_fs_rename_sync, 2}, - {"unlinkSync", low_fs_unlink_sync, 1}, - {"accessSync", low_fs_access_sync, 2}, - {"readdirSync", low_fs_readdir_sync, 2}, - {"mkdirSync", low_fs_mkdir_sync, 2}, - {"rmdirSync", low_fs_rmdir_sync, 1}, - {"waitDone", low_fs_waitdone, 1}, - {"file_pos", low_fs_file_pos, 1}, - {"listen", low_net_listen, 7}, - {"connect", low_net_connect, 5}, - {"setsockopt", low_net_setsockopt, 5}, - {"shutdown", low_net_shutdown, 2}, - {"isIP", low_is_ip, 1}, - {"lookup", low_dns_lookup, 4}, - {"lookupService", low_dns_lookup_service, 3}, - {"newResolver", low_dns_new_resolver, 1}, - {"resolverCancel", low_dns_resolver_cancel, 1}, - {"resolverGetServers", low_dns_resolver_get_servers, 1}, - {"resolverSetServers", low_dns_resolver_set_servers, 2}, - {"resolverResolve", low_dns_resolver_resolve, 5}, - {"resolverGetHostByAddr", low_dns_resolver_gethostbyaddr, 3}, - {"httpGetRequest", low_http_get_request, 2}, - {"httpDetach", low_http_detach, 1}, - {"httpRead", low_http_read, 3}, - {"httpWrite", low_http_write, 3}, - {"httpWriteHead", low_http_write_head, 4}, - {"createTLSContext", low_tls_create_context, 1}, - {"makeModule", low_module_make, 2}, - {"createCryptoHash", low_crypto_create_hash, 3}, - {"cryptoHashUpdate", low_crypto_hash_update, 2}, - {"cryptoHashDigest", low_crypto_hash_digest, 1}, - {NULL, NULL, 0}}; +duk_function_list_entry g_low_native_methods[] = {{"processInfo", low_process_info, 2}, + {"ttyInfo", low_tty_info, 0}, + {"hrtime", low_hrtime, 1}, + {"compile", low_compile, 1}, + {"runInContext", low_run_in_context, 4}, + {"compare", low_compare, 2}, + {"setChore", low_loop_set_chore, 3}, + {"clearChore", low_loop_clear_chore, 1}, + {"choreRef", low_loop_chore_ref, 2}, + {"runRef", low_loop_run_ref, 1}, + {"open", low_fs_open, 4}, + {"openSync", low_fs_open_sync, 3}, + {"close", low_fs_close, 2}, + {"closeSync", low_fs_close_sync, 1}, + {"read", low_fs_read, 6}, + {"write", low_fs_write, 6}, + {"fstat", low_fs_fstat, 2}, + {"stat", low_fs_stat, 2}, + {"rename", low_fs_rename, 3}, + {"unlink", low_fs_unlink, 2}, + {"access", low_fs_access, 3}, + {"readdir", low_fs_readdir, 3}, + {"mkdir", low_fs_mkdir, 3}, + {"rmdir", low_fs_rmdir, 2}, + {"statSync", low_fs_stat_sync, 1}, + {"renameSync", low_fs_rename_sync, 2}, + {"unlinkSync", low_fs_unlink_sync, 1}, + {"accessSync", low_fs_access_sync, 2}, + {"readdirSync", low_fs_readdir_sync, 2}, + {"mkdirSync", low_fs_mkdir_sync, 2}, + {"rmdirSync", low_fs_rmdir_sync, 1}, + {"waitDone", low_fs_waitdone, 1}, + {"file_pos", low_fs_file_pos, 1}, + {"listen", low_net_listen, 7}, + {"connect", low_net_connect, 5}, + {"setsockopt", low_net_setsockopt, 5}, + {"shutdown", low_net_shutdown, 2}, + {"isIP", low_is_ip, 1}, + {"lookup", low_dns_lookup, 4}, + {"lookupService", low_dns_lookup_service, 3}, + {"newResolver", low_dns_new_resolver, 1}, + {"resolverCancel", low_dns_resolver_cancel, 1}, + {"resolverGetServers", low_dns_resolver_get_servers, 1}, + {"resolverSetServers", low_dns_resolver_set_servers, 2}, + {"resolverResolve", low_dns_resolver_resolve, 5}, + {"resolverGetHostByAddr", low_dns_resolver_gethostbyaddr, 3}, + {"httpGetRequest", low_http_get_request, 2}, + {"httpDetach", low_http_detach, 1}, + {"httpRead", low_http_read, 3}, + {"httpWrite", low_http_write, 3}, + {"httpWriteHead", low_http_write_head, 4}, + {"createTLSContext", low_tls_create_context, 1}, + {"makeModule", low_module_make, 2}, + {"createCryptoHash", low_crypto_create_hash, 3}, + {"cryptoHashUpdate", low_crypto_hash_update, 2}, + {"cryptoHashDigest", low_crypto_hash_digest, 1}, + {NULL, NULL, 0}}; diff --git a/src/low_native_aux.cpp b/src/low_native_aux.cpp index 5ce12e1..10f6854 100644 --- a/src/low_native_aux.cpp +++ b/src/low_native_aux.cpp @@ -1,4 +1,3 @@ - // ----------------------------------------------------------------------------- // low_native_aux.cpp // ----------------------------------------------------------------------------- @@ -22,15 +21,21 @@ duk_ret_t low_compare(duk_context *ctx) { duk_size_t a_len, b_len; - unsigned char *a = (unsigned char *)duk_require_buffer_data(ctx, 0, &a_len); - unsigned char *b = (unsigned char *)duk_require_buffer_data(ctx, 1, &b_len); + unsigned char *a = (unsigned char *) duk_require_buffer_data(ctx, 0, &a_len); + unsigned char *b = (unsigned char *) duk_require_buffer_data(ctx, 1, &b_len); - if(a_len < b_len) + if (a_len < b_len) + { duk_push_int(ctx, -1); - else if(a_len > b_len) + } + else if (a_len > b_len) + { duk_push_int(ctx, 1); + } else + { duk_push_int(ctx, memcmp(a, b, a_len)); + } return 1; } @@ -43,9 +48,9 @@ duk_ret_t low_is_ip(duk_context *ctx) const char *ip = duk_require_string(ctx, 0); bool isIPv4 = false; - for(int i = 0; ip[i]; i++) + for (int i = 0; ip[i]; i++) { - if(ip[i] == '.') + if (ip[i] == '.') { isIPv4 = true; break; @@ -53,7 +58,7 @@ duk_ret_t low_is_ip(duk_context *ctx) } unsigned char buf[16]; - if(inet_pton(isIPv4 ? AF_INET : AF_INET6, ip, buf) != 1) + if (inet_pton(isIPv4 ? AF_INET : AF_INET6, ip, buf) != 1) { duk_push_int(ctx, 0); return 1; @@ -103,8 +108,7 @@ duk_ret_t low_run_in_context(duk_context *ctx) duk_set_global_object(low->duk_ctx); duk_dup(low->duk_ctx, 0); - if(duk_safe_call(low->duk_ctx, low_run_in_context_safe, NULL, 1, 1) != - DUK_EXEC_SUCCESS) + if (duk_safe_call(low->duk_ctx, low_run_in_context_safe, NULL, 1, 1) != DUK_EXEC_SUCCESS) { duk_dup(low->duk_ctx, 4); duk_set_global_object(low->duk_ctx); diff --git a/src/low_native_aux.h b/src/low_native_aux.h index 43f9229..7ed0e1c 100644 --- a/src/low_native_aux.h +++ b/src/low_native_aux.h @@ -1,4 +1,3 @@ - // ----------------------------------------------------------------------------- // low_native_aux.cpp // ----------------------------------------------------------------------------- @@ -9,9 +8,11 @@ #include "duktape.h" duk_ret_t low_compare(duk_context *ctx); + duk_ret_t low_is_ip(duk_context *ctx); duk_ret_t low_compile(duk_context *ctx); + duk_ret_t low_run_in_context(duk_context *ctx); #endif /* __LOW_NATIVE_AUX_H__ */ \ No newline at end of file diff --git a/src/low_net.cpp b/src/low_net.cpp index 6c0d6b6..e4392cd 100644 --- a/src/low_net.cpp +++ b/src/low_net.cpp @@ -34,14 +34,15 @@ duk_ret_t low_net_listen(duk_context *ctx) bool isHTTP = duk_require_boolean(ctx, 3); LowTLSContext *tlsContext = NULL; - if(duk_is_object(ctx, 4)) + if (duk_is_object(ctx, 4)) { duk_get_prop_string(ctx, 4, "_index"); int index = duk_require_int(ctx, -1); - if(index < 0 || index >= low->tlsContexts.size() || - !low->tlsContexts[index]) + if (index < 0 || index >= low->tlsContexts.size() || !low->tlsContexts[index]) + { duk_reference_error(ctx, "tls context not found"); + } tlsContext = low->tlsContexts[index]; } @@ -57,10 +58,10 @@ duk_ret_t low_net_listen(duk_context *ctx) } else #endif /* LOW_HAS_UNIX_SOCKET */ - addrLen = family == 4 ? sizeof(sockaddr_in) : sizeof(sockaddr_in6); + addrLen = family == 4 ? sizeof(sockaddr_in) : sizeof(sockaddr_in6); unsigned char addrBuf[addrLen]; - sockaddr *addr = (sockaddr *)addrBuf; + sockaddr *addr = (sockaddr *) addrBuf; memset(addr, 0, addrLen); #if LOW_HAS_UNIX_SOCKET @@ -75,12 +76,12 @@ duk_ret_t low_net_listen(duk_context *ctx) #endif /* LOW_HAS_UNIX_SOCKET */ { int port = duk_require_int(ctx, 2); - if(family == 4) + if (family == 4) { - sockaddr_in *addr_in = (sockaddr_in *)addr; + sockaddr_in *addr_in = (sockaddr_in *) addr; addr_in->sin_family = AF_INET; - if(inet_pton(AF_INET, address, &addr_in->sin_addr) != 1) + if (inet_pton(AF_INET, address, &addr_in->sin_addr) != 1) { int err = errno; duk_dup(low->duk_ctx, 5); @@ -92,10 +93,10 @@ duk_ret_t low_net_listen(duk_context *ctx) } else { - sockaddr_in6 *addr_in6 = (sockaddr_in6 *)addr; + sockaddr_in6 *addr_in6 = (sockaddr_in6 *) addr; addr_in6->sin6_family = AF_INET6; - if(inet_pton(AF_INET6, address, &addr_in6->sin6_addr) != 1) + if (inet_pton(AF_INET6, address, &addr_in6->sin6_addr) != 1) { int err = errno; duk_dup(low->duk_ctx, 5); @@ -107,9 +108,8 @@ duk_ret_t low_net_listen(duk_context *ctx) } } - LowServerSocket *server = - new(low_new) LowServerSocket(low, isHTTP, tlsContext); - if(!server) + LowServerSocket *server = new(low_new) LowServerSocket(low, isHTTP, tlsContext); + if (!server) { duk_dup(low->duk_ctx, 5); low_push_error(low, ENOMEM, "malloc"); @@ -119,7 +119,7 @@ duk_ret_t low_net_listen(duk_context *ctx) int err; const char *syscall; - if(!server->Listen(addr, addrLen, 6, err, syscall)) + if (!server->Listen(addr, addrLen, 6, err, syscall)) { delete server; @@ -132,12 +132,18 @@ duk_ret_t low_net_listen(duk_context *ctx) duk_dup(ctx, 5); duk_push_null(ctx); duk_push_int(ctx, server->FD()); - if(family == 4) - duk_push_int(ctx, ntohs(((struct sockaddr_in *)addr)->sin_port)); - else if(family == 6) - duk_push_int(ctx, ntohs(((struct sockaddr_in6 *)addr)->sin6_port)); + if (family == 4) + { + duk_push_int(ctx, ntohs(((struct sockaddr_in *) addr)->sin_port)); + } + else if (family == 6) + { + duk_push_int(ctx, ntohs(((struct sockaddr_in6 *) addr)->sin6_port)); + } else + { duk_push_int(ctx, 0); + } duk_call(ctx, 3); } return 0; @@ -165,10 +171,10 @@ duk_ret_t low_net_connect(duk_context *ctx) } else #endif /* LOW_HAS_UNIX_SOCKET */ - addrLen = family == 4 ? sizeof(sockaddr_in) : sizeof(sockaddr_in6); + addrLen = family == 4 ? sizeof(sockaddr_in) : sizeof(sockaddr_in6); unsigned char addrBuf[addrLen]; - sockaddr *addr = (sockaddr *)addrBuf; + sockaddr *addr = (sockaddr *) addrBuf; memset(addr, 0, addrLen); #if LOW_HAS_UNIX_SOCKET @@ -183,12 +189,12 @@ duk_ret_t low_net_connect(duk_context *ctx) #endif /* LOW_HAS_UNIX_SOCKET */ { int port = duk_require_int(ctx, 2); - if(family == 4) + if (family == 4) { - sockaddr_in *addr_in = (sockaddr_in *)addr; + sockaddr_in *addr_in = (sockaddr_in *) addr; addr_in->sin_family = AF_INET; - if(inet_pton(AF_INET, address, &addr_in->sin_addr) != 1) + if (inet_pton(AF_INET, address, &addr_in->sin_addr) != 1) { int err = errno; duk_dup(low->duk_ctx, 4); @@ -200,10 +206,10 @@ duk_ret_t low_net_connect(duk_context *ctx) } else { - sockaddr_in6 *addr_in6 = (sockaddr_in6 *)addr; + sockaddr_in6 *addr_in6 = (sockaddr_in6 *) addr; addr_in6->sin6_family = AF_INET6; - if(inet_pton(AF_INET6, address, &addr_in6->sin6_addr) != 1) + if (inet_pton(AF_INET6, address, &addr_in6->sin6_addr) != 1) { int err = errno; duk_dup(low->duk_ctx, 4); @@ -216,7 +222,7 @@ duk_ret_t low_net_connect(duk_context *ctx) } LowSocket *socket = new(low_new) LowSocket(low, NULL, 0, NULL); - if(!socket) + if (!socket) { duk_dup(low->duk_ctx, 4); low_push_error(low, ENOMEM, "malloc"); @@ -226,7 +232,7 @@ duk_ret_t low_net_connect(duk_context *ctx) int err; const char *syscall; - if(!socket->Connect(addr, addrLen, 4, err, syscall)) + if (!socket->Connect(addr, addrLen, 4, err, syscall)) { delete socket; @@ -244,31 +250,43 @@ duk_ret_t low_net_connect(duk_context *ctx) duk_ret_t low_net_setsockopt(duk_context *ctx) { low_main_t *low = duk_get_low_context(ctx); - if(!duk_is_undefined(ctx, 4)) - if(!low_set_raw_mode(duk_require_boolean(ctx, 4))) + if (!duk_is_undefined(ctx, 4)) + { + if (!low_set_raw_mode(duk_require_boolean(ctx, 4))) { low_push_error(low, errno, "tcsetattr"); duk_throw(ctx); } + } bool setKeepAlive = !duk_is_undefined(ctx, 1); bool setNoDelay = !duk_is_undefined(ctx, 3); - if(!setKeepAlive && !setNoDelay) + if (!setKeepAlive && !setNoDelay) + { return 0; + } int fd = duk_require_int(ctx, 0); auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { return 0; + } - if(iter->second->FDType() != LOWFD_TYPE_SOCKET) + if (iter->second->FDType() != LOWFD_TYPE_SOCKET) + { duk_reference_error(ctx, "file descriptor is not a socket"); - LowSocket *socket = (LowSocket *)iter->second; + } + LowSocket *socket = (LowSocket *) iter->second; - if(setKeepAlive) + if (setKeepAlive) + { socket->KeepAlive(duk_require_boolean(ctx, 1), duk_require_int(ctx, 2)); - if(setNoDelay) + } + if (setNoDelay) + { socket->NoDelay(duk_require_boolean(ctx, 3)); + } return 0; } @@ -283,12 +301,16 @@ duk_ret_t low_net_shutdown(duk_context *ctx) int fd = duk_require_int(ctx, 0); auto iter = low->fds.find(fd); - if(iter == low->fds.end()) + if (iter == low->fds.end()) + { return 0; + } - if(iter->second->FDType() != LOWFD_TYPE_SOCKET) + if (iter->second->FDType() != LOWFD_TYPE_SOCKET) + { duk_reference_error(ctx, "file descriptor is not a socket"); - LowSocket *socket = (LowSocket *)iter->second; + } + LowSocket *socket = (LowSocket *) iter->second; socket->Shutdown(1); return 0; diff --git a/src/low_net.h b/src/low_net.h index 5ef4250..f53316d 100644 --- a/src/low_net.h +++ b/src/low_net.h @@ -8,8 +8,11 @@ #include "duktape.h" duk_ret_t low_net_listen(duk_context *ctx); + duk_ret_t low_net_connect(duk_context *ctx); + duk_ret_t low_net_setsockopt(duk_context *ctx); + duk_ret_t low_net_shutdown(duk_context *ctx); #endif /* __LOW_NET_H__ */ \ No newline at end of file diff --git a/src/low_process.cpp b/src/low_process.cpp index 5fe2ef5..383217f 100644 --- a/src/low_process.cpp +++ b/src/low_process.cpp @@ -20,9 +20,11 @@ #include #include #else + #include #include #include + #endif /* __APPLE__ */ // used in low_hrtime() below @@ -56,7 +58,7 @@ static duk_ret_t low_process_cwd(duk_context *ctx) duk_push_string(ctx, duk_get_low_context(ctx)->cwd); #else char path[1024]; - if(!getcwd(path, sizeof(path))) + if (!getcwd(path, sizeof(path))) { low_push_error(duk_get_low_context(ctx), errno, "getcwd"); duk_throw(ctx); @@ -89,7 +91,7 @@ static duk_ret_t low_process_chdir(duk_context *ctx) low_free(low->cwd); low->cwd = cwd; #else - if(chdir(path) < 0) + if (chdir(path) < 0) { low_push_error(duk_get_low_context(ctx), errno, "getcwd"); duk_throw(ctx); @@ -133,14 +135,14 @@ duk_ret_t low_process_info(duk_context *ctx) duk_push_object(ctx); #if !LOW_ESP32_LWIP_SPECIALITIES - for(int i = 0; environ && environ[i]; i++) + for (int i = 0; environ && environ[i]; i++) { int j; - for(j = 0; environ[i][j] && environ[i][j] != '='; j++) + for (j = 0; environ[i][j] && environ[i][j] != '='; j++) { } - if(environ[i][j]) + if (environ[i][j]) { duk_push_string(ctx, &environ[i][j + 1]); environ[i][j] = '\0'; @@ -260,14 +262,16 @@ duk_ret_t low_hrtime(duk_context *ctx) clock_get_time(cclock, &ts); #else struct timespec ts; - if(clock_gettime(CLOCK_MONOTONIC, &ts) < 0) + if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0) + { low_error_errno(); + } #endif /* __APPLE__ */ - t = (((uint64_t)ts.tv_sec) * NANOS_PER_SEC + ts.tv_nsec); + t = (((uint64_t) ts.tv_sec) * NANOS_PER_SEC + ts.tv_nsec); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - uint32_t *fields = (uint32_t *)duk_require_buffer_data(ctx, 0, nullptr); + uint32_t *fields = (uint32_t *) duk_require_buffer_data(ctx, 0, nullptr); fields[0] = (t / NANOS_PER_SEC) >> 32; fields[1] = (t / NANOS_PER_SEC) & 0xffffffff; fields[2] = t % NANOS_PER_SEC; diff --git a/src/low_process.h b/src/low_process.h index 8e46dd9..d45abcc 100644 --- a/src/low_process.h +++ b/src/low_process.h @@ -8,7 +8,9 @@ #include "duktape.h" duk_ret_t low_process_info(duk_context *ctx); + duk_ret_t low_tty_info(duk_context *ctx); + duk_ret_t low_hrtime(duk_context *ctx); #endif /* __LOW_PROCESS_H__ */ \ No newline at end of file diff --git a/src/low_system.cpp b/src/low_system.cpp index 4d93120..e7a101b 100644 --- a/src/low_system.cpp +++ b/src/low_system.cpp @@ -30,9 +30,11 @@ #include #include #else + #include #include #include + #endif /* __APPLE__ */ // Global variables @@ -103,15 +105,14 @@ bool low_system_init() #else #define MAX_PATH_LEN 1024 - g_low_system.lib_path = - (char *)low_alloc(MAX_PATH_LEN + 1 + lib_add_path_len); - if(!g_low_system.lib_path) + g_low_system.lib_path = (char *) low_alloc(MAX_PATH_LEN + 1 + lib_add_path_len); + if (!g_low_system.lib_path) { low_error_errno(); goto err; } memset(g_low_system.lib_path, 0, MAX_PATH_LEN + 1); - if(readlink("/proc/self/exe", g_low_system.lib_path, MAX_PATH_LEN) < 0) + if (readlink("/proc/self/exe", g_low_system.lib_path, MAX_PATH_LEN) < 0) { low_error_errno(); goto err; @@ -119,12 +120,14 @@ bool low_system_init() #endif /* __APPLE__ */ int i; - for(i = strlen(g_low_system.lib_path); i > 0; i--) - if(g_low_system.lib_path[i - 1] == '/') + for (i = strlen(g_low_system.lib_path); i > 0; i--) + { + if (g_low_system.lib_path[i - 1] == '/') { g_low_system.lib_path[i] = '\0'; break; } + } strcpy(g_low_system.lib_path + i, lib_add_path); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ @@ -232,11 +235,13 @@ int low_tick_count() clock_get_time(cclock, &tv); #else struct timespec tv; - if(clock_gettime(CLOCK_MONOTONIC, &tv) < 0) + if (clock_gettime(CLOCK_MONOTONIC, &tv) < 0) + { low_error_errno(); + } #endif /* __APPLE__ */ - return (int)(((long long)tv.tv_sec) * 1000 + tv.tv_nsec / 1000000); + return (int) (((long long) tv.tv_sec) * 1000 + tv.tv_nsec / 1000000); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ } @@ -246,387 +251,375 @@ int low_tick_count() void low_push_error(struct low_main_t *low, int error, const char *syscall) { - const char *low_errcode[LOW_NUM_ERROR_CODES] = { - "EUNKNOWN", "ENODATA", "EFORMERR", - "ESERVFAIL", "ENOTFOUND", "ENOTIMP", - "EREFUSED", "EBADQUERY", "EBADNAME", - "EBADFAMILY", "EBADRESP", "ECONNREFUSED", - "ETIMEOUT", "EOF", "EFILE", - "ENOMEM", "EDESTRUCTION", "EBADSTR", - "EBADFLAGS", "ENONAME", "EBADHINTS", - "ENOTINITIALIZED", "ELOADIPHLPAPI", "EADDRGETNETWORKPARAMS", - "ECANCELLED"}; - const char *low_errtext[LOW_NUM_ERROR_CODES] = { - "Unknown error", - "DNS server returned answer with no data", - "DNS server claims query was misformatted", - "DNS server returned general failure", - "Domain name not found", - "DNS server does not implement requested operation", - "DNS server refused query", - "Misformatted DNS query", - "Misformatted domain name", - "Unsupported address family", - "Misformatted DNS reply", - "Could not contact DNS servers", - "Timeout while contacting DNS servers", - "End of file", - "Error reading file", - "Out of memory", - "Channel is being destroyed", - "Misformatted string", - "Illegal flags specified", - "Given hostname is not numeric", - "Illegal hints flags specified", - "c-ares library initialization not yet performed", - "Error loading iphlpapi.dll", - "Could not find GetNetworkParams function", - "DNS query cancelled"}; + const char *low_errcode[LOW_NUM_ERROR_CODES] = {"EUNKNOWN", "ENODATA", "EFORMERR", "ESERVFAIL", "ENOTFOUND", + "ENOTIMP", "EREFUSED", "EBADQUERY", "EBADNAME", "EBADFAMILY", + "EBADRESP", "ECONNREFUSED", "ETIMEOUT", "EOF", "EFILE", "ENOMEM", + "EDESTRUCTION", "EBADSTR", "EBADFLAGS", "ENONAME", "EBADHINTS", + "ENOTINITIALIZED", "ELOADIPHLPAPI", "EADDRGETNETWORKPARAMS", + "ECANCELLED"}; + const char *low_errtext[LOW_NUM_ERROR_CODES] = {"Unknown error", "DNS server returned answer with no data", + "DNS server claims query was misformatted", + "DNS server returned general failure", "Domain name not found", + "DNS server does not implement requested operation", + "DNS server refused query", "Misformatted DNS query", + "Misformatted domain name", "Unsupported address family", + "Misformatted DNS reply", "Could not contact DNS servers", + "Timeout while contacting DNS servers", "End of file", + "Error reading file", "Out of memory", "Channel is being destroyed", + "Misformatted string", "Illegal flags specified", + "Given hostname is not numeric", "Illegal hints flags specified", + "c-ares library initialization not yet performed", + "Error loading iphlpapi.dll", + "Could not find GetNetworkParams function", "DNS query cancelled"}; char message[1024] = "", txt[10]; const char *code; - if(-error >= 0 && -error < LOW_NUM_ERROR_CODES) + if (-error >= 0 && -error < LOW_NUM_ERROR_CODES) { code = low_errcode[-error]; strcpy(message, low_errtext[-error]); } else - switch(error) + { + switch (error) { - case EPERM: - code = "EPERM"; - break; - case ENOENT: - code = "ENOENT"; - break; - case ESRCH: - code = "ESRCH"; - break; - case EINTR: - code = "EINTR"; - break; - case EIO: - code = "EIO"; - break; - case ENXIO: - code = "ENXIO"; - break; - case E2BIG: - code = "E2BIG"; - break; - case ENOEXEC: - code = "ENOEXEC"; - break; - case EBADF: - code = "EBADF"; - break; - case ECHILD: - code = "ECHILD"; - break; - case EDEADLK: - code = "EDEADLK"; - break; - case ENOMEM: - code = "ENOMEM"; - break; - case EACCES: - code = "EACCES"; - break; - case EFAULT: - code = "EFAULT"; - break; - case EBUSY: - code = "EBUSY"; - break; - case EEXIST: - code = "EEXIST"; - break; - case EXDEV: - code = "EXDEV"; - break; - case ENODEV: - code = "ENODEV"; - break; - case ENOTDIR: - code = "ENOTDIR"; - break; - case EISDIR: - code = "EISDIR"; - break; - case EINVAL: - code = "EINVAL"; - break; - case ENFILE: - code = "ENFILE"; - break; - case EMFILE: - code = "EMFILE"; - break; - case ENOTTY: - code = "ENOTTY"; - break; - case ETXTBSY: - code = "ETXTBSY"; - break; - case EFBIG: - code = "EFBIG"; - break; - case ENOSPC: - code = "ENOSPC"; - break; - case ESPIPE: - code = "ESPIPE"; - break; - case EROFS: - code = "EROFS"; - break; - case EMLINK: - code = "EMLINK"; - break; - case EPIPE: - code = "EPIPE"; - break; - case EDOM: - code = "EDOM"; - break; - case ERANGE: - code = "ERANGE"; - break; - case EAGAIN: - code = "EAGAIN"; - break; - case EINPROGRESS: - code = "EINPROGRESS"; - break; - case EALREADY: - code = "EALREADY"; - break; - case ENOTSOCK: - code = "ENOTSOCK"; - break; - case EDESTADDRREQ: - code = "EDESTADDRREQ"; - break; - case EMSGSIZE: - code = "EMSGSIZE"; - break; - case EPROTOTYPE: - code = "EPROTOTYPE"; - break; - case ENOPROTOOPT: - code = "ENOPROTOOPT"; - break; - case EPROTONOSUPPORT: - code = "EPROTONOSUPPORT"; - break; - case ENOTSUP: - code = "ENOTSUP"; - break; - case EPFNOSUPPORT: - code = "EPFNOSUPPORT"; - break; - case EAFNOSUPPORT: - code = "EAFNOSUPPORT"; - break; - case EADDRINUSE: - code = "EADDRINUSE"; - break; - case EADDRNOTAVAIL: - code = "EADDRNOTAVAIL"; - break; - case ENETDOWN: - code = "ENETDOWN"; - break; - case ENETUNREACH: - code = "ENETUNREACH"; - break; - case ENETRESET: - code = "ENETRESET"; - break; - case ECONNABORTED: - code = "ECONNABORTED"; - break; - case ECONNRESET: - code = "ECONNRESET"; - break; - case ENOBUFS: - code = "ENOBUFS"; - break; - case EISCONN: - code = "EISCONN"; - break; - case ENOTCONN: - code = "ENOTCONN"; - break; - case ETOOMANYREFS: - code = "ETOOMANYREFS"; - break; - case ETIMEDOUT: - code = "ETIMEDOUT"; - break; - case ECONNREFUSED: - code = "ECONNREFUSED"; - break; - case ELOOP: - code = "ELOOP"; - break; - case ENAMETOOLONG: - code = "ENAMETOOLONG"; - break; - case EHOSTDOWN: - code = "EHOSTDOWN"; - break; - case EHOSTUNREACH: - code = "EHOSTUNREACH"; - break; - case ENOTEMPTY: - code = "ENOTEMPTY"; - break; - case EDQUOT: - code = "EDQUOT"; - break; - case ESTALE: - code = "ESTALE"; - break; - case ENOLCK: - code = "ENOLCK"; - break; - case ENOSYS: - code = "ENOSYS"; - break; - case EOVERFLOW: - code = "EOVERFLOW"; - break; - case ECANCELED: - code = "ECANCELED"; - break; - case EIDRM: - code = "EIDRM"; - break; - case ENOMSG: - code = "ENOMSG"; - break; - case EILSEQ: - code = "EILSEQ"; - break; - case EBADMSG: - code = "EBADMSG"; - break; - case EMULTIHOP: - code = "EMULTIHOP"; - break; - case ENODATA: - code = "ENODATA"; - break; - case ENOLINK: - code = "ENOLINK"; - break; - case ENOSR: - code = "ENOSR"; - break; - case ENOSTR: - code = "ENOSTR"; - break; - case EPROTO: - code = "EPROTO"; - break; - case ETIME: - code = "ETIME"; - break; - case ENOTRECOVERABLE: - code = "ENOTRECOVERABLE"; - break; - case EOWNERDEAD: - code = "EOWNERDEAD"; - break; + case EPERM: + code = "EPERM"; + break; + case ENOENT: + code = "ENOENT"; + break; + case ESRCH: + code = "ESRCH"; + break; + case EINTR: + code = "EINTR"; + break; + case EIO: + code = "EIO"; + break; + case ENXIO: + code = "ENXIO"; + break; + case E2BIG: + code = "E2BIG"; + break; + case ENOEXEC: + code = "ENOEXEC"; + break; + case EBADF: + code = "EBADF"; + break; + case ECHILD: + code = "ECHILD"; + break; + case EDEADLK: + code = "EDEADLK"; + break; + case ENOMEM: + code = "ENOMEM"; + break; + case EACCES: + code = "EACCES"; + break; + case EFAULT: + code = "EFAULT"; + break; + case EBUSY: + code = "EBUSY"; + break; + case EEXIST: + code = "EEXIST"; + break; + case EXDEV: + code = "EXDEV"; + break; + case ENODEV: + code = "ENODEV"; + break; + case ENOTDIR: + code = "ENOTDIR"; + break; + case EISDIR: + code = "EISDIR"; + break; + case EINVAL: + code = "EINVAL"; + break; + case ENFILE: + code = "ENFILE"; + break; + case EMFILE: + code = "EMFILE"; + break; + case ENOTTY: + code = "ENOTTY"; + break; + case ETXTBSY: + code = "ETXTBSY"; + break; + case EFBIG: + code = "EFBIG"; + break; + case ENOSPC: + code = "ENOSPC"; + break; + case ESPIPE: + code = "ESPIPE"; + break; + case EROFS: + code = "EROFS"; + break; + case EMLINK: + code = "EMLINK"; + break; + case EPIPE: + code = "EPIPE"; + break; + case EDOM: + code = "EDOM"; + break; + case ERANGE: + code = "ERANGE"; + break; + case EAGAIN: + code = "EAGAIN"; + break; + case EINPROGRESS: + code = "EINPROGRESS"; + break; + case EALREADY: + code = "EALREADY"; + break; + case ENOTSOCK: + code = "ENOTSOCK"; + break; + case EDESTADDRREQ: + code = "EDESTADDRREQ"; + break; + case EMSGSIZE: + code = "EMSGSIZE"; + break; + case EPROTOTYPE: + code = "EPROTOTYPE"; + break; + case ENOPROTOOPT: + code = "ENOPROTOOPT"; + break; + case EPROTONOSUPPORT: + code = "EPROTONOSUPPORT"; + break; + case ENOTSUP: + code = "ENOTSUP"; + break; + case EPFNOSUPPORT: + code = "EPFNOSUPPORT"; + break; + case EAFNOSUPPORT: + code = "EAFNOSUPPORT"; + break; + case EADDRINUSE: + code = "EADDRINUSE"; + break; + case EADDRNOTAVAIL: + code = "EADDRNOTAVAIL"; + break; + case ENETDOWN: + code = "ENETDOWN"; + break; + case ENETUNREACH: + code = "ENETUNREACH"; + break; + case ENETRESET: + code = "ENETRESET"; + break; + case ECONNABORTED: + code = "ECONNABORTED"; + break; + case ECONNRESET: + code = "ECONNRESET"; + break; + case ENOBUFS: + code = "ENOBUFS"; + break; + case EISCONN: + code = "EISCONN"; + break; + case ENOTCONN: + code = "ENOTCONN"; + break; + case ETOOMANYREFS: + code = "ETOOMANYREFS"; + break; + case ETIMEDOUT: + code = "ETIMEDOUT"; + break; + case ECONNREFUSED: + code = "ECONNREFUSED"; + break; + case ELOOP: + code = "ELOOP"; + break; + case ENAMETOOLONG: + code = "ENAMETOOLONG"; + break; + case EHOSTDOWN: + code = "EHOSTDOWN"; + break; + case EHOSTUNREACH: + code = "EHOSTUNREACH"; + break; + case ENOTEMPTY: + code = "ENOTEMPTY"; + break; + case EDQUOT: + code = "EDQUOT"; + break; + case ESTALE: + code = "ESTALE"; + break; + case ENOLCK: + code = "ENOLCK"; + break; + case ENOSYS: + code = "ENOSYS"; + break; + case EOVERFLOW: + code = "EOVERFLOW"; + break; + case ECANCELED: + code = "ECANCELED"; + break; + case EIDRM: + code = "EIDRM"; + break; + case ENOMSG: + code = "ENOMSG"; + break; + case EILSEQ: + code = "EILSEQ"; + break; + case EBADMSG: + code = "EBADMSG"; + break; + case EMULTIHOP: + code = "EMULTIHOP"; + break; + case ENODATA: + code = "ENODATA"; + break; + case ENOLINK: + code = "ENOLINK"; + break; + case ENOSR: + code = "ENOSR"; + break; + case ENOSTR: + code = "ENOSTR"; + break; + case EPROTO: + code = "EPROTO"; + break; + case ETIME: + code = "ETIME"; + break; + case ENOTRECOVERABLE: + code = "ENOTRECOVERABLE"; + break; + case EOWNERDEAD: + code = "EOWNERDEAD"; + break; #ifdef __APPLE__ - case EPROCLIM: - code = "EPROCLIM"; - break; - case EBADRPC: - code = "EBADRPC"; - break; - case ERPCMISMATCH: - code = "ERPCMISMATCH"; - break; - case EPROGUNAVAIL: - code = "EPROGUNAVAIL"; - break; - case EPROGMISMATCH: - code = "EPROGMISMATCH"; - break; - case EPROCUNAVAIL: - code = "EPROCUNAVAIL"; - break; - case EFTYPE: - code = "EFTYPE"; - break; - case EAUTH: - code = "EAUTH"; - break; - case ENEEDAUTH: - code = "ENEEDAUTH"; - break; - case EPWROFF: - code = "EPWROFF"; - break; - case EDEVERR: - code = "EDEVERR"; - break; - case EBADEXEC: - code = "EBADEXEC"; - break; - case EBADARCH: - code = "EBADARCH"; - break; - case ESHLIBVERS: - code = "ESHLIBVERS"; - break; - case EBADMACHO: - code = "EBADMACHO"; - break; - case ENOATTR: - code = "ENOATTR"; - break; - case EOPNOTSUPP: - code = "EOPNOTSUPP"; - break; - case ENOPOLICY: - code = "ENOPOLICY"; - break; - case EQFULL: - code = "EQFULL"; - break; + case EPROCLIM: + code = "EPROCLIM"; + break; + case EBADRPC: + code = "EBADRPC"; + break; + case ERPCMISMATCH: + code = "ERPCMISMATCH"; + break; + case EPROGUNAVAIL: + code = "EPROGUNAVAIL"; + break; + case EPROGMISMATCH: + code = "EPROGMISMATCH"; + break; + case EPROCUNAVAIL: + code = "EPROCUNAVAIL"; + break; + case EFTYPE: + code = "EFTYPE"; + break; + case EAUTH: + code = "EAUTH"; + break; + case ENEEDAUTH: + code = "ENEEDAUTH"; + break; + case EPWROFF: + code = "EPWROFF"; + break; + case EDEVERR: + code = "EDEVERR"; + break; + case EBADEXEC: + code = "EBADEXEC"; + break; + case EBADARCH: + code = "EBADARCH"; + break; + case ESHLIBVERS: + code = "ESHLIBVERS"; + break; + case EBADMACHO: + code = "EBADMACHO"; + break; + case ENOATTR: + code = "ENOATTR"; + break; + case EOPNOTSUPP: + code = "EOPNOTSUPP"; + break; + case ENOPOLICY: + code = "ENOPOLICY"; + break; + case EQFULL: + code = "EQFULL"; + break; #endif /* __APPLE__ */ #if !LOW_ESP32_LWIP_SPECIALITIES - case ENOTBLK: - code = "ENOTBLK"; - break; - case ESOCKTNOSUPPORT: - code = "ESOCKTNOSUPPORT"; - break; - case ESHUTDOWN: - code = "ESHUTDOWN"; - break; - case EUSERS: - code = "EUSERS"; - break; - case EREMOTE: - code = "EREMOTE"; - break; + case ENOTBLK: + code = "ENOTBLK"; + break; + case ESOCKTNOSUPPORT: + code = "ESOCKTNOSUPPORT"; + break; + case ESHUTDOWN: + code = "ESHUTDOWN"; + break; + case EUSERS: + code = "EUSERS"; + break; + case EREMOTE: + code = "EREMOTE"; + break; #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - default: - code = txt; - sprintf(txt, "E%d", error); - break; + default: + code = txt; + sprintf(txt, "E%d", error); + break; } + } - if(!message[0]) + if (!message[0]) + { strerror_r(error, message, sizeof(message) - 16 - strlen(syscall)); + } sprintf(message + strlen(message), " (at %s)", syscall); duk_push_error_object(low->duk_ctx, DUK_ERR_ERROR, message); duk_push_string(low->duk_ctx, code); diff --git a/src/low_system.h b/src/low_system.h index 6bc9e40..b559c9e 100644 --- a/src/low_system.h +++ b/src/low_system.h @@ -43,28 +43,29 @@ struct low_system_t { - char *lib_path; + char *lib_path; #if LOW_HAS_TERMIOS - bool isatty, raw_mode; - struct termios orig_termios; + bool isatty, raw_mode; + struct termios orig_termios; #endif /* LOW_HAS_TERMIOS */ - int signal_pipe_fd; + int signal_pipe_fd; }; -extern "C" -{ - bool low_system_init(); - void low_system_destroy(); +extern "C" { +bool low_system_init(); +void low_system_destroy(); } bool low_set_raw_mode(bool mode); + int low_tick_count(); void low_push_error(struct low_main_t *low, int error, const char *syscall); void low_error_errno(); + void low_error(const char *txt); #endif /* __LOW_SYSTEM_H__ */ diff --git a/src/low_tls.cpp b/src/low_tls.cpp index 09e1aed..1cfd0a4 100644 --- a/src/low_tls.cpp +++ b/src/low_tls.cpp @@ -24,10 +24,10 @@ duk_ret_t low_tls_create_context(duk_context *ctx) duk_size_t cert_len, key_len, ca_len; duk_get_prop_string(ctx, 0, "cert"); - if(duk_is_string(ctx, -1)) + if (duk_is_string(ctx, -1)) { my_cert = low_strdup(duk_get_string(ctx, -1)); - if(!my_cert) + if (!my_cert) { low_push_error(low, ENOMEM, "malloc"); duk_throw(ctx); @@ -36,11 +36,11 @@ duk_ret_t low_tls_create_context(duk_context *ctx) } else { - cert = (unsigned char *)duk_get_buffer_data(ctx, -1, &cert_len); - if(cert) + cert = (unsigned char *) duk_get_buffer_data(ctx, -1, &cert_len); + if (cert) { - my_cert = (char *)low_alloc(cert_len + 1); - if(!my_cert) + my_cert = (char *) low_alloc(cert_len + 1); + if (!my_cert) { low_push_error(low, ENOMEM, "malloc"); duk_throw(ctx); @@ -50,10 +50,10 @@ duk_ret_t low_tls_create_context(duk_context *ctx) } } duk_get_prop_string(ctx, 0, "key"); - if(duk_is_string(ctx, -1)) + if (duk_is_string(ctx, -1)) { my_key = low_strdup(duk_get_string(ctx, -1)); - if(!my_key) + if (!my_key) { low_free(my_cert); low_push_error(low, ENOMEM, "malloc"); @@ -63,11 +63,11 @@ duk_ret_t low_tls_create_context(duk_context *ctx) } else { - key = (unsigned char *)duk_get_buffer_data(ctx, -1, &key_len); - if(key) + key = (unsigned char *) duk_get_buffer_data(ctx, -1, &key_len); + if (key) { - my_key = (char *)low_alloc(key_len + 1); - if(!my_key) + my_key = (char *) low_alloc(key_len + 1); + if (!my_key) { low_free(my_cert); low_push_error(low, ENOMEM, "malloc"); @@ -78,11 +78,11 @@ duk_ret_t low_tls_create_context(duk_context *ctx) } } duk_get_prop_string(ctx, 0, "ca"); - ca = (unsigned char *)duk_get_buffer_data(ctx, -1, &ca_len); - if(duk_is_string(ctx, -1)) + ca = (unsigned char *) duk_get_buffer_data(ctx, -1, &ca_len); + if (duk_is_string(ctx, -1)) { my_ca = low_strdup(duk_get_string(ctx, -1)); - if(!my_ca) + if (!my_ca) { low_free(my_cert); low_free(my_key); @@ -93,11 +93,11 @@ duk_ret_t low_tls_create_context(duk_context *ctx) } else { - ca = (unsigned char *)duk_get_buffer_data(ctx, -1, &ca_len); - if(ca) + ca = (unsigned char *) duk_get_buffer_data(ctx, -1, &ca_len); + if (ca) { - my_ca = (char *)low_alloc(ca_len + 1); - if(!my_ca) + my_ca = (char *) low_alloc(ca_len + 1); + if (!my_ca) { low_free(my_cert); low_free(my_key); @@ -109,27 +109,30 @@ duk_ret_t low_tls_create_context(duk_context *ctx) } } - LowTLSContext *context = new(low_new) LowTLSContext( - low, my_cert, cert_len, my_key, key_len, my_ca, ca_len, true); + LowTLSContext *context = new(low_new) LowTLSContext(low, my_cert, cert_len, my_key, key_len, my_ca, ca_len, true); low_free(my_cert); low_free(my_key); low_free(my_ca); - if(!context->IsOK()) + if (!context->IsOK()) { delete context; duk_generic_error(ctx, "SSL context error"); } int index; - for(index = 0; index < low->tlsContexts.size(); index++) - if(!low->tlsContexts[index]) + for (index = 0; index < low->tlsContexts.size(); index++) + { + if (!low->tlsContexts[index]) { low->tlsContexts[index] = context; break; } - if(index == low->tlsContexts.size()) + } + if (index == low->tlsContexts.size()) + { low->tlsContexts.push_back(context); + } context->SetIndex(index); duk_push_object(low->duk_ctx); @@ -152,8 +155,10 @@ duk_ret_t low_tls_context_finalizer(duk_context *ctx) duk_get_prop_string(ctx, 0, "_index"); int index = duk_require_int(ctx, -1); - if(index < 0 || index >= low->tlsContexts.size()) + if (index < 0 || index >= low->tlsContexts.size()) + { duk_reference_error(ctx, "tls context not found"); + } low->tlsContexts[index]->DecRef(); return 0; diff --git a/src/low_tls.h b/src/low_tls.h index b8957e8..f18c01c 100644 --- a/src/low_tls.h +++ b/src/low_tls.h @@ -8,6 +8,7 @@ #include "duktape.h" duk_ret_t low_tls_create_context(duk_context *ctx); + duk_ret_t low_tls_context_finalizer(duk_context *ctx); #endif /* __LOW_TLS_H__ */ \ No newline at end of file diff --git a/src/low_web_thread.cpp b/src/low_web_thread.cpp index 9f12a3f..50bcd53 100644 --- a/src/low_web_thread.cpp +++ b/src/low_web_thread.cpp @@ -16,6 +16,7 @@ #include "low_alloc.h" #include + #if LOW_HAS_POLL #include #endif /* LOW_HAS_POLL */ @@ -36,7 +37,7 @@ using namespace std; void *low_web_thread_main(void *arg) { - low_main_t *low = (low_main_t *)arg; + low_main_t *low = (low_main_t *) arg; #if LOW_HAS_POLL vector fds; @@ -259,7 +260,7 @@ void *low_web_thread_main(void *arg) } #else fd_set read_set, write_set; - vector> fds; + vector > fds; FD_ZERO(&read_set); FD_ZERO(&write_set); @@ -272,76 +273,78 @@ void *low_web_thread_main(void *arg) FD_SET(low->web_thread_pipe[0], &read_set); #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - while(true) - { - int timeout = -1, i; + while (true) + { + int timeout = -1, i; - int first_cares_fd = fds.size(); - fd_set read_set1 = read_set; - fd_set write_set1 = write_set; + int first_cares_fd = fds.size(); + fd_set read_set1 = read_set; + fd_set write_set1 = write_set; #if LOW_INCLUDE_CARES_RESOLVER - bool has_cares = false; - if(low->resolvers_active) + bool has_cares = false; + if(low->resolvers_active) + { + pthread_mutex_lock(&low->resolvers_mutex); + for(i = 0; i < low->resolvers.size(); i++) { - pthread_mutex_lock(&low->resolvers_mutex); - for(i = 0; i < low->resolvers.size(); i++) + if(!low->resolvers[i]->IsActive()) + continue; + ares_channel &channel = low->resolvers[i]->Channel(); + + int count = ares_fds(channel, &read_set1, &write_set1); + if(count) { - if(!low->resolvers[i]->IsActive()) - continue; - ares_channel &channel = low->resolvers[i]->Channel(); + has_cares = true; - int count = ares_fds(channel, &read_set1, &write_set1); - if(count) + struct timeval tv; + struct timeval *val = ares_timeout(channel, NULL, &tv); + if(val) { - has_cares = true; - - struct timeval tv; - struct timeval *val = ares_timeout(channel, NULL, &tv); - if(val) - { - int millisecs = - val->tv_sec * 1000 + val->tv_usec / 1000; - if(timeout > millisecs || timeout == -1) - timeout = millisecs; - } + int millisecs = + val->tv_sec * 1000 + val->tv_usec / 1000; + if(timeout > millisecs || timeout == -1) + timeout = millisecs; } } - pthread_mutex_unlock(&low->resolvers_mutex); } + pthread_mutex_unlock(&low->resolvers_mutex); + } #endif /* LOW_INCLUDE_CARES_RESOLVER */ #if LOW_ESP32_LWIP_SPECIALITIES - int timeout2 = gWebThreadNextTick - low_tick_count(); - while(timeout2 <= 0) - { - low->web_thread_notinevents = true; - neoniousWebThreadTick(); - low->web_thread_notinevents = false; - timeout2 = gWebThreadNextTick - low_tick_count(); - } - if(timeout == -1 || timeout > timeout2) - timeout = timeout2; - - int count; - if(timeout == -1) - count = lwip_select(FD_SETSIZE, &read_set1, &write_set1, NULL, - NULL); - else - { - struct timeval tv; - tv.tv_sec = timeout / 1000; - tv.tv_usec = (timeout - tv.tv_sec * 1000) * 1000; + int timeout2 = gWebThreadNextTick - low_tick_count(); + while(timeout2 <= 0) + { + low->web_thread_notinevents = true; + neoniousWebThreadTick(); + low->web_thread_notinevents = false; + timeout2 = gWebThreadNextTick - low_tick_count(); + } + if(timeout == -1 || timeout > timeout2) + timeout = timeout2; - count = - lwip_select(FD_SETSIZE, &read_set1, &write_set1, NULL, &tv); - } - if(count < 0) - vTaskDelay(1000); // do not block! -#else int count; if(timeout == -1) + count = lwip_select(FD_SETSIZE, &read_set1, &write_set1, NULL, + NULL); + else + { + struct timeval tv; + tv.tv_sec = timeout / 1000; + tv.tv_usec = (timeout - tv.tv_sec * 1000) * 1000; + + count = + lwip_select(FD_SETSIZE, &read_set1, &write_set1, NULL, &tv); + } + if(count < 0) + vTaskDelay(1000); // do not block! +#else + int count; + if (timeout == -1) + { count = select(FD_SETSIZE, &read_set1, &write_set1, NULL, NULL); + } else { struct timeval tv; @@ -352,146 +355,136 @@ void *low_web_thread_main(void *arg) } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(low->destroying) - break; + if (low->destroying) + { + break; + } #if LOW_ESP32_LWIP_SPECIALITIES - if(!count) - { - low->web_thread_notinevents = true; - neoniousWebThreadTick(); - low->web_thread_notinevents = false; - } + if(!count) + { + low->web_thread_notinevents = true; + neoniousWebThreadTick(); + low->web_thread_notinevents = false; + } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ #if LOW_INCLUDE_CARES_RESOLVER - if(has_cares) + if(has_cares) + { + pthread_mutex_lock(&low->resolvers_mutex); + for(i = 0; i < low->resolvers.size(); i++) { - pthread_mutex_lock(&low->resolvers_mutex); - for(i = 0; i < low->resolvers.size(); i++) - { - if(!low->resolvers[i]->IsActive()) - continue; - ares_channel &channel = low->resolvers[i]->Channel(); + if(!low->resolvers[i]->IsActive()) + continue; + ares_channel &channel = low->resolvers[i]->Channel(); - ares_process(channel, &read_set1, &write_set1); - } - pthread_mutex_unlock(&low->resolvers_mutex); + ares_process(channel, &read_set1, &write_set1); } + pthread_mutex_unlock(&low->resolvers_mutex); + } #endif /* LOW_INCLUDE_CARES_RESOLVER */ #if !LOW_ESP32_LWIP_SPECIALITIES - if(count > 0 && FD_ISSET(low->web_thread_pipe[0], &read_set1)) + if (count > 0 && FD_ISSET(low->web_thread_pipe[0], &read_set1)) + { + unsigned char s; + read(low->web_thread_pipe[0], &s, 1); + if (s != 0xFF) { - unsigned char s; - read(low->web_thread_pipe[0], &s, 1); - if(s != 0xFF) + LowSignalHandler *signal = new(low_new) LowSignalHandler(low, s); + if (!signal) { - LowSignalHandler *signal = - new(low_new) LowSignalHandler(low, s); - if(!signal) - { - } // not much we can do here ! - } - count--; + } // not much we can do here ! } + count--; + } #endif /* LOW_ESP32_LWIP_SPECIALITIES */ - if(count > 0) + if (count > 0) + { + int firstNone = 0; + for (i = 0; i < fds.size(); i++) { - int firstNone = 0; - for(i = 0; i < fds.size(); i++) + if (fds[i].second >= 0) { - if(fds[i].second >= 0) + int events = (FD_ISSET(fds[i].second, &read_set1) ? POLLIN : 0) | + (FD_ISSET(fds[i].second, &write_set1) ? POLLOUT : 0); + if (events) { - int events = - (FD_ISSET(fds[i].second, &read_set1) ? POLLIN : 0) | - (FD_ISSET(fds[i].second, &write_set1) ? POLLOUT - : 0); - if(events) + if (!fds[i].first->OnEvents(events)) { - if(!fds[i].first->OnEvents(events)) + auto fd = fds[i].first; + + fds[i].second = -1; + if (fd->mFD >= 0) { - auto fd = fds[i].first; + FD_CLR(fd->mFD, &read_set); + FD_CLR(fd->mFD, &write_set); + } - fds[i].second = -1; - if(fd->mFD >= 0) + // Remove from web thread list + pthread_mutex_lock(&low->web_thread_mutex); + if (fd->mNextChanged || low->web_changed_last == fd) + { + if (low->web_changed_first == fd) { - FD_CLR(fd->mFD, &read_set); - FD_CLR(fd->mFD, &write_set); + low->web_changed_first = fd->mNextChanged; } - - // Remove from web thread list - pthread_mutex_lock(&low->web_thread_mutex); - if(fd->mNextChanged || - low->web_changed_last == fd) + else { - if(low->web_changed_first == fd) - low->web_changed_first = - fd->mNextChanged; - else + auto elem = low->web_changed_first; + while (elem) { - auto elem = low->web_changed_first; - while(elem) + if (elem->mNextChanged == fd) { - if(elem->mNextChanged == fd) - { - elem->mNextChanged = - fd->mNextChanged; - break; - } - elem = elem->mNextChanged; + elem->mNextChanged = fd->mNextChanged; + break; } + elem = elem->mNextChanged; } - if(!low->web_changed_first) - low->web_changed_last = NULL; } - fd->mPollIndex = -1; - fd->mNextChanged = NULL; - pthread_mutex_unlock(&low->web_thread_mutex); - - low->web_thread_notinevents = true; - delete fd; - low->web_thread_notinevents = false; + if (!low->web_changed_first) + { + low->web_changed_last = NULL; + } } - count--; + fd->mPollIndex = -1; + fd->mNextChanged = NULL; + pthread_mutex_unlock(&low->web_thread_mutex); + + low->web_thread_notinevents = true; + delete fd; + low->web_thread_notinevents = false; } + count--; } - if(fds[i].second >= 0) - firstNone = i + 1; } - if(firstNone != fds.size()) - fds.resize(firstNone); + if (fds[i].second >= 0) + { + firstNone = i + 1; + } } - - pthread_mutex_lock(&low->web_thread_mutex); - while(low->web_changed_first) + if (firstNone != fds.size()) { - LowFD *fd = low->web_changed_first; - - low->web_changed_first = fd->mNextChanged; - if(!low->web_changed_first) - low->web_changed_last = NULL; - fd->mNextChanged = NULL; + fds.resize(firstNone); + } + } - if(fd->mMarkDelete) - { - if(fd->mPollIndex != -1) - { - FD_CLR(fds[fd->mPollIndex].second, &read_set); - FD_CLR(fds[fd->mPollIndex].second, &write_set); + pthread_mutex_lock(&low->web_thread_mutex); + while (low->web_changed_first) + { + LowFD *fd = low->web_changed_first; - fds[fd->mPollIndex].second = -1; - fd->mPollIndex = -1; - } + low->web_changed_first = fd->mNextChanged; + if (!low->web_changed_first) + { + low->web_changed_last = NULL; + } + fd->mNextChanged = NULL; - low->web_thread_notinevents = true; - pthread_mutex_unlock(&low->web_thread_mutex); - delete fd; - pthread_mutex_lock(&low->web_thread_mutex); - low->web_thread_notinevents = false; - } - else if((fd->mFD < 0 || !fd->mPollEvents) && - fd->mPollIndex != -1) + if (fd->mMarkDelete) + { + if (fd->mPollIndex != -1) { FD_CLR(fds[fd->mPollIndex].second, &read_set); FD_CLR(fds[fd->mPollIndex].second, &write_set); @@ -499,65 +492,88 @@ void *low_web_thread_main(void *arg) fds[fd->mPollIndex].second = -1; fd->mPollIndex = -1; } - else if(fd->mFD >= 0 && fd->mPollEvents) + + low->web_thread_notinevents = true; + pthread_mutex_unlock(&low->web_thread_mutex); + delete fd; + pthread_mutex_lock(&low->web_thread_mutex); + low->web_thread_notinevents = false; + } + else if ((fd->mFD < 0 || !fd->mPollEvents) && fd->mPollIndex != -1) + { + FD_CLR(fds[fd->mPollIndex].second, &read_set); + FD_CLR(fds[fd->mPollIndex].second, &write_set); + + fds[fd->mPollIndex].second = -1; + fd->mPollIndex = -1; + } + else if (fd->mFD >= 0 && fd->mPollEvents) + { + if (fd->mPollIndex == -1) { - if(fd->mPollIndex == -1) + for (int i = 0; i < fds.size(); i++) { - for(int i = 0; i < fds.size(); i++) - { - if(fds[i].second == -1) - { - fd->mPollIndex = i; - fds[i].first = fd; - fds[i].second = fd->mFD; - break; - } - } - if(fd->mPollIndex == -1) + if (fds[i].second == -1) { - fd->mPollIndex = fds.size(); - fds.push_back(pair(fd, fd->mFD)); + fd->mPollIndex = i; + fds[i].first = fd; + fds[i].second = fd->mFD; + break; } } + if (fd->mPollIndex == -1) + { + fd->mPollIndex = fds.size(); + fds.push_back(pair(fd, fd->mFD)); + } + } - if(fd->mPollEvents & POLLIN) - FD_SET(fd->mFD, &read_set); - else - FD_CLR(fd->mFD, &read_set); - if(fd->mPollEvents & POLLOUT) - FD_SET(fd->mFD, &write_set); - else - FD_CLR(fd->mFD, &write_set); + if (fd->mPollEvents & POLLIN) + { + FD_SET(fd->mFD, &read_set); + } + else + { + FD_CLR(fd->mFD, &read_set); + } + if (fd->mPollEvents & POLLOUT) + { + FD_SET(fd->mFD, &write_set); + } + else + { + FD_CLR(fd->mFD, &write_set); } } - - pthread_cond_broadcast(&low->web_thread_done_cond); - pthread_mutex_unlock(&low->web_thread_mutex); } -#if LOW_ESP32_LWIP_SPECIALITIES - pthread_mutex_lock(&low->web_thread_mutex); - low->web_thread_done = true; pthread_cond_broadcast(&low->web_thread_done_cond); + pthread_mutex_unlock(&low->web_thread_mutex); + } + +#if LOW_ESP32_LWIP_SPECIALITIES + pthread_mutex_lock(&low->web_thread_mutex); + low->web_thread_done = true; + pthread_cond_broadcast(&low->web_thread_done_cond); - // Remove the FDs here! - for(int i = 0; i < fds.size(); i++) + // Remove the FDs here! + for(int i = 0; i < fds.size(); i++) + { + if(fds[i].first->mFDClearOnReset && fds[i].second >= 0) { - if(fds[i].first->mFDClearOnReset && fds[i].second >= 0) - { - FD_CLR(fds[i].second, &read_set); - FD_CLR(fds[i].second, &write_set); + FD_CLR(fds[i].second, &read_set); + FD_CLR(fds[i].second, &write_set); - fds[i].second = -1; - fds[i].first->mPollIndex = -1; - } + fds[i].second = -1; + fds[i].first->mPollIndex = -1; } - - while(low->destroying) - pthread_cond_wait(&low->web_thread_done_cond, - &low->web_thread_mutex); - pthread_mutex_unlock(&low->web_thread_mutex); } + + while(low->destroying) + pthread_cond_wait(&low->web_thread_done_cond, + &low->web_thread_mutex); + pthread_mutex_unlock(&low->web_thread_mutex); +} #endif /* LOW_ESP32_LWIP_SPECIALITIES */ #endif /* LOW_HAS_POLL */ @@ -592,16 +608,20 @@ void low_web_set_poll_events(low_main_t *low, LowFD *fd, short events) pthread_mutex_lock(&low->web_thread_mutex); fd->mPollEvents = events; - if(fd->mNextChanged || low->web_changed_last == fd) + if (fd->mNextChanged || low->web_changed_last == fd) { pthread_mutex_unlock(&low->web_thread_mutex); return; } - if(low->web_changed_last) + if (low->web_changed_last) + { low->web_changed_last->mNextChanged = fd; + } else + { low->web_changed_first = fd; + } low->web_changed_last = fd; low_web_thread_break(low); @@ -615,25 +635,28 @@ void low_web_set_poll_events(low_main_t *low, LowFD *fd, short events) void low_web_clear_poll(low_main_t *low, LowFD *fd) { pthread_mutex_lock(&low->web_thread_mutex); - if(fd->mPollIndex == -1 && !fd->mNextChanged && fd != low->web_changed_last) + if (fd->mPollIndex == -1 && !fd->mNextChanged && fd != low->web_changed_last) { - if(!low->web_thread_notinevents && !low->web_thread_done) /* TODO can be even more */ + if (!low->web_thread_notinevents && !low->web_thread_done) /* TODO can be even more */ { low_web_thread_break(low); - pthread_cond_wait(&low->web_thread_done_cond, - &low->web_thread_mutex); + pthread_cond_wait(&low->web_thread_done_cond, &low->web_thread_mutex); } pthread_mutex_unlock(&low->web_thread_mutex); return; } fd->mPollEvents = 0; - if(!low->web_thread_done) + if (!low->web_thread_done) { - if(low->web_changed_last) + if (low->web_changed_last) + { low->web_changed_last->mNextChanged = fd; + } else + { low->web_changed_first = fd; + } low->web_changed_last = fd; low_web_thread_break(low); @@ -651,16 +674,20 @@ void low_web_mark_delete(low_main_t *low, LowFD *fd) pthread_mutex_lock(&low->web_thread_mutex); fd->mMarkDelete = true; - if(fd->mNextChanged || low->web_changed_last == fd) + if (fd->mNextChanged || low->web_changed_last == fd) { pthread_mutex_unlock(&low->web_thread_mutex); return; } - if(low->web_changed_last) + if (low->web_changed_last) + { low->web_changed_last->mNextChanged = fd; + } else + { low->web_changed_first = fd; + } low->web_changed_last = fd; low_web_thread_break(low); diff --git a/src/low_web_thread.h b/src/low_web_thread.h index 24b7c26..5b89879 100644 --- a/src/low_web_thread.h +++ b/src/low_web_thread.h @@ -16,15 +16,16 @@ #define POLLRESET 0xFF struct low_main_t; + class LowFD; void *low_web_thread_main(void *arg); + void low_web_thread_break(low_main_t *low); void low_web_set_poll_events(low_main_t *low, LowFD *fd, short events); -void low_web_clear_poll(low_main_t *low, - LowFD *fd); // only call from not-web thread +void low_web_clear_poll(low_main_t *low, LowFD *fd); // only call from not-web thread void low_web_mark_delete(low_main_t *low, LowFD *fd); #endif /* __LOW_WEB_THREAD_H__ */