Fix crashes when limit is not in correct range. (#28)

Co-authored-by: PUBNUB\jakub.grzesiowski <[email protected]>
Co-authored-by: Mateusz Dahlke <[email protected]>

Author: 3 people

CMakeLists.txt

@@ -54,6 +54,7 @@ set(USE_CALLBACK_API ON)
 set(USE_SET_DNS_SERVERS ON)
 set(USE_IPV6 ON)
 set(USE_SUBSCRIBE_EVENT_ENGINE ON)
+set(USE_NTF_RUNTIME_SELECTION ON)
 
 if(WIN32 OR WIN64 OR MSVC)
     set(CUSTOM_BOOL_TYPE _Bool)
@@ -62,7 +63,7 @@ endif()
 FetchContent_Declare(
   pubnub
   GIT_REPOSITORY https://github.com/pubnub/c-core.git
-  GIT_TAG feat/ee-listener-void
+  GIT_TAG feat/runtime-api-enforcement
   GIT_SHALLOW TRUE
   GIT_PROGRESS ON
   SYSTEM
@@ -85,11 +86,11 @@ endif()
 
 # TODO: this flag is okay until we release the Cpp-Chat as an independent library
 if(${ENABLE_C_ABI})
-    target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unity/0.4.2\")
+    target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unity/0.4.3\")
 else()
     target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unreal/0.3.0\")
 endif()
-target_compile_options(pubnub PUBLIC -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SYNC_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1)
+target_compile_options(pubnub PUBLIC -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1)
 
 FetchContent_Declare(
   json
@@ -211,19 +212,19 @@ set(SOURCES
 
 add_library(pubnub-chat SHARED ${SOURCES})
 
-target_compile_options(pubnub-chat PRIVATE -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SYNC_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1)
+target_compile_options(pubnub-chat PRIVATE -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1)
 
 target_link_libraries(pubnub-chat PRIVATE -lpthread pubnub)
 
 # TODO: kept for debugging purposes - should be deleted before release
 add_executable(pubnub-chat-example example/main.cpp)
-target_compile_options(pubnub-chat-example PRIVATE -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SYNC_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1)
+target_compile_options(pubnub-chat-example PRIVATE -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1)
 target_link_libraries(pubnub-chat-example PUBLIC -lpthread pubnub-chat)
 
 if(${COMPILE_EXAMPLES})
     function(example name)
         add_executable(pubnub_${name} example/${name}.cpp)
-        target_compile_options(pubnub_${name} PRIVATE -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SYNC_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1)
+        target_compile_options(pubnub_${name} PRIVATE -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1)
         target_link_libraries(pubnub_${name} PRIVATE pubnub-chat)
     endfunction()
 

src/application/channel_service.cpp

@@ -146,6 +146,11 @@ Channel ChannelService::get_channel(const String& channel_id) const {
 }
 
 std::tuple<std::vector<Pubnub::Channel>, Pubnub::Page, int> ChannelService::get_channels(const Pubnub::String &filter, const Pubnub::String &sort, int limit, const Pubnub::Page &page) const {
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get channels, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+    
     Pubnub::String include = "custom,totalCount,channel";
     auto channels_response = [this, include, limit, filter, sort, page] {
         auto pubnub_handle = this->pubnub->lock();
@@ -451,6 +456,11 @@ void ChannelService::emit_user_mention(const Pubnub::String &channel_id, const P
 
 std::vector<Pubnub::Channel> ChannelService::get_channel_suggestions(Pubnub::String text, int limit) const
 {
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get channel suggestions, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+
     auto chat_shared = this->chat_service.lock();
 
     if(!chat_shared)
@@ -475,6 +485,11 @@ std::vector<Pubnub::Channel> ChannelService::get_channel_suggestions(Pubnub::Str
 
 std::vector<Pubnub::Membership> ChannelService::get_user_suggestions_for_channel(const String& channel_id, ChannelDAO& channel_data, Pubnub::String text, int limit) const
 {
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get users suggestions, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+
     auto chat_shared = this->chat_service.lock();
 
     if(!chat_shared)

src/application/chat_service.hpp

@@ -1,6 +1,8 @@
 #ifndef PN_CHAT_CHAT_SERVICE_HPP
 #define PN_CHAT_CHAT_SERVICE_HPP
 
+#define PN_MAX_LIMIT 100
+
 #include "application/subscription.hpp"
 #include "chat.hpp"
 #include "infra/sync.hpp"

src/application/membership_service.cpp

@@ -28,6 +28,12 @@ MembershipService::MembershipService(ThreadSafePtr<PubNub> pubnub, std::weak_ptr
 {}
 
 std::tuple<std::vector<Pubnub::Membership>, Pubnub::Page, int, Pubnub::String> MembershipService::get_channel_members(const String& channel_id, const ChannelDAO& channel_data, const Pubnub::String &filter, const Pubnub::String &sort, int limit, const Pubnub::Page &page) const {
+
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get members, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+
     String include_string = "custom,channel,totalCount,customChannel";
 
     auto get_channel_members_response = [this, channel_id, include_string, limit, filter, sort, page] {
@@ -70,6 +76,11 @@ std::tuple<std::vector<Pubnub::Membership>, Pubnub::Page, int, Pubnub::String> M
 }
 
 std::tuple<std::vector<Pubnub::Membership>, Pubnub::Page, int, Pubnub::String> MembershipService::get_user_memberships(const String& user_id, const UserDAO& user_data, const Pubnub::String &filter, const Pubnub::String &sort, int limit, const Pubnub::Page &page) const {
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get memberships, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+
     String include_string = "totalCount,custom,channel,customChannel,channelType,status,channelStatus";
 
     auto get_memberships_response = [this, user_id, include_string, filter, sort,  limit, page] {
@@ -272,6 +283,12 @@ int MembershipService::get_unread_messages_count_one_channel(const Membership& m
 }
 
 std::vector<std::tuple<Pubnub::Channel, Pubnub::Membership, int>> MembershipService::get_all_unread_messages_counts(const Pubnub::String &filter, const Pubnub::String &sort, int limit, const Pubnub::Page &page) const {
+    
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get unread messages counts, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+    
     auto chat_service_shared = chat_service.lock();
     std::vector<std::tuple<Pubnub::Channel, Pubnub::Membership, int>> return_tuples;
 
@@ -318,6 +335,11 @@ std::vector<std::tuple<Pubnub::Channel, Pubnub::Membership, int>> MembershipServ
 
 std::tuple<Pubnub::Page, int, int, std::vector<Pubnub::Membership>> MembershipService::mark_all_messages_as_read(const Pubnub::String &filter, const Pubnub::String &sort, int limit, const Pubnub::Page& page) const
 {
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't mark all messages as read, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+
     auto chat_service_shared = chat_service.lock();
     std::tuple<Pubnub::Page, int, int, std::vector<Pubnub::Membership>> return_tuple;
 

src/application/restrictions_service.cpp

@@ -121,6 +121,11 @@ Restriction RestrictionsService::get_user_restrictions(const String& user_id, co
 
 std::tuple<std::vector<Pubnub::UserRestriction>, Pubnub::Page, int, Pubnub::String> RestrictionsService::get_users_restrictions(const Pubnub::String &channel_id, const Pubnub::String &sort, int limit, const Pubnub::Page &page) const
 {
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get users restrictions, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+
     String full_channel_id = INTERNAL_MODERATION_PREFIX + channel_id;
 
     auto get_restrictions_response = [this, limit, sort, page, full_channel_id] {
@@ -132,7 +137,7 @@ std::tuple<std::vector<Pubnub::UserRestriction>, Pubnub::Page, int, Pubnub::Stri
 
     if(response_json.is_null())
     {
-        throw std::runtime_error("can't get channel restrictions, response is incorrect");
+        throw std::runtime_error("can't get users restrictions, response is incorrect");
     }
 
     Json response_data_json = response_json["data"];
@@ -168,6 +173,11 @@ std::tuple<std::vector<Pubnub::UserRestriction>, Pubnub::Page, int, Pubnub::Stri
 }
 
 Restriction RestrictionsService::get_channel_restrictions(const String& user_id, const String& channel_id, const Pubnub::String &sort, int limit, const Pubnub::Page &page) const {
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get channels restrictions, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+    
     String full_channel_id = INTERNAL_MODERATION_PREFIX + channel_id;
 
     auto get_restrictions_response = [this, full_channel_id, limit, sort, page] {

src/application/user_service.cpp

@@ -92,7 +92,11 @@ User UserService::get_user(const String& user_id) const
 }
 
 std::tuple<std::vector<Pubnub::User>, Pubnub::Page, int> UserService::get_users(const Pubnub::String &filter, const Pubnub::String &sort, int limit, const Pubnub::Page &page) const {
-    
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get users, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+
     Pubnub::String include = "custom,totalCount";
     auto users_response = [this, include, limit, filter, sort, page] {
         auto pubnub_handle = this->pubnub->lock();
@@ -187,6 +191,11 @@ std::shared_ptr<SubscriptionSet> UserService::stream_updates_on(Pubnub::User cal
 
 std::vector<Pubnub::User> UserService::get_users_suggestions(Pubnub::String text, int limit) const
 {
+    if(limit < 0 || limit > PN_MAX_LIMIT)
+    {
+        throw std::invalid_argument("can't get users suggestions, limit has to be within 0 - " + std::to_string(PN_MAX_LIMIT) + " range");
+    }
+
     auto chat_shared = this->chat_service.lock();
 
     if(!chat_shared)

src/infra/pubnub.cpp

@@ -568,6 +568,10 @@ Pubnub::String PubNub::fetch_history(
 
     auto fetch_history_response = pubnub_get_fetch_history(this->main_context.get());
 
+    //Force to clear the buffer, looks like pubnub_get_fetch_history doesn't clear it properly
+    // TODO: werify if it is the real root cause. 
+    auto _message = pubnub_get(this->main_context.get());
+
     if(!fetch_history_response.ptr)
     {
         throw std::runtime_error("Fetch history response is invalid");