Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package aws-crt-cpp for openSUSE:Factory checked in at 2026-07-13 14:28:14 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/aws-crt-cpp (Old) and /work/SRC/openSUSE:Factory/.aws-crt-cpp.new.1991 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "aws-crt-cpp" Mon Jul 13 14:28:14 2026 rev:56 rq:1365264 version:0.41.0 Changes: -------- --- /work/SRC/openSUSE:Factory/aws-crt-cpp/aws-crt-cpp.changes 2026-07-10 17:46:38.264093284 +0200 +++ /work/SRC/openSUSE:Factory/.aws-crt-cpp.new.1991/aws-crt-cpp.changes 2026-07-13 14:28:58.449277997 +0200 @@ -1,0 +2,9 @@ +Fri Jul 10 07:30:24 UTC 2026 - John Paul Adrian Glaubitz <[email protected]> + +- Update to version 0.41.0 + * noCertificateRevocation option binding by @sbSteveK in (#866) + * Fix TLS options by @sfod in (#854) + * Regression Labeler Fix by @azkrishpy in (#870) + * Fix sending auto-PUBACK for QOS1 publishes by @sfod in (#873) + +------------------------------------------------------------------- Old: ---- v0.40.1.tar.gz New: ---- v0.41.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ aws-crt-cpp.spec ++++++ --- /var/tmp/diff_new_pack.fwlTou/_old 2026-07-13 14:28:59.725321618 +0200 +++ /var/tmp/diff_new_pack.fwlTou/_new 2026-07-13 14:28:59.729321754 +0200 @@ -20,7 +20,7 @@ %define library_soversion 1 Name: aws-crt-cpp -Version: 0.40.1 +Version: 0.41.0 Release: 0 Summary: AWS C++ wrapper for AWS SDK C libraries License: Apache-2.0 ++++++ v0.40.1.tar.gz -> v0.41.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-crt-cpp-0.40.1/.github/workflows/issue-regression-labeler.yml new/aws-crt-cpp-0.41.0/.github/workflows/issue-regression-labeler.yml --- old/aws-crt-cpp-0.40.1/.github/workflows/issue-regression-labeler.yml 2026-06-11 22:18:31.000000000 +0200 +++ new/aws-crt-cpp-0.41.0/.github/workflows/issue-regression-labeler.yml 2026-07-06 19:44:56.000000000 +0200 @@ -24,9 +24,12 @@ - name: Manage regression label env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + IS_REGRESSION: ${{ steps.check_regression.outputs.is_regression }} + ISSUE_NUMBER: ${{ github.event.issue.number }} + REPO: ${{ github.repository }} run: | - if [ "${{ steps.check_regression.outputs.is_regression }}" == "true" ]; then - gh issue edit ${{ github.event.issue.number }} --add-label "potential-regression" -R ${{ github.repository }} + if [ "$IS_REGRESSION" == "true" ]; then + gh issue edit "$ISSUE_NUMBER" --add-label "potential-regression" -R "$REPO" else - gh issue edit ${{ github.event.issue.number }} --remove-label "potential-regression" -R ${{ github.repository }} + gh issue edit "$ISSUE_NUMBER" --remove-label "potential-regression" -R "$REPO" fi diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-crt-cpp-0.40.1/VERSION new/aws-crt-cpp-0.41.0/VERSION --- old/aws-crt-cpp-0.40.1/VERSION 2026-06-11 22:18:31.000000000 +0200 +++ new/aws-crt-cpp-0.41.0/VERSION 2026-07-06 19:44:56.000000000 +0200 @@ -1 +1 @@ -0.40.1 +0.41.0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-crt-cpp-0.40.1/include/aws/crt/io/TlsOptions.h new/aws-crt-cpp-0.41.0/include/aws/crt/io/TlsOptions.h --- old/aws-crt-cpp-0.40.1/include/aws/crt/io/TlsOptions.h 2026-06-11 22:18:31.000000000 +0200 +++ new/aws-crt-cpp-0.41.0/include/aws/crt/io/TlsOptions.h 2026-07-06 19:44:56.000000000 +0200 @@ -173,6 +173,21 @@ void SetVerifyPeer(bool verifyPeer) noexcept; /** + * Set to true to disable certificate revocation checking during TLS negotiation. + * + * On Windows (SChannel), this prevents the TLS handshake from making outbound network calls + * to CRL/OCSP revocation endpoints, which can block for minutes when the endpoints are unreachable + * (e.g., in private subnets without internet access). + * + * On Linux (s2n), this disables validation of OCSP stapled responses provided by the server. + * + * On Apple platforms, this is a no-op as revocation checking is not enabled by default. + * + * @param noCertificateRevocation: Set true to disable revocation checking. + */ + void SetNoCertificateRevocation(bool noCertificateRevocation) noexcept; + + /** * Sets the minimum TLS version allowed. * @param minimumTlsVersion: The minimum TLS version. */ @@ -201,11 +216,14 @@ bool OverrideDefaultTrustStore(const ByteCursor &ca) noexcept; /// @private - const aws_tls_ctx_options *GetUnderlyingHandle() const noexcept { return &m_options; } + const aws_tls_ctx_options *GetUnderlyingHandle() const noexcept + { + return m_isInit ? &m_options : nullptr; + } private: aws_tls_ctx_options m_options; - bool m_isInit; + bool m_isInit = false; }; /** @@ -327,17 +345,18 @@ /// @private const aws_tls_connection_options *GetUnderlyingHandle() const noexcept { - return &m_tls_connection_options; + return m_isInit ? &m_tls_connection_options : nullptr; } private: bool isValid() const noexcept { return m_isInit; } TlsConnectionOptions(aws_tls_ctx *ctx, Allocator *allocator) noexcept; + aws_tls_connection_options m_tls_connection_options; - aws_allocator *m_allocator; - int m_lastError; - bool m_isInit; + aws_allocator *m_allocator = nullptr; + int m_lastError = AWS_ERROR_SUCCESS; + bool m_isInit = false; friend class TlsContext; }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-crt-cpp-0.40.1/source/io/TlsOptions.cpp new/aws-crt-cpp-0.41.0/source/io/TlsOptions.cpp --- old/aws-crt-cpp-0.40.1/source/io/TlsOptions.cpp 2026-06-11 22:18:31.000000000 +0200 +++ new/aws-crt-cpp-0.41.0/source/io/TlsOptions.cpp 2026-07-06 19:44:56.000000000 +0200 @@ -24,7 +24,7 @@ } } - TlsContextOptions::TlsContextOptions() noexcept : m_isInit(false) + TlsContextOptions::TlsContextOptions() noexcept { AWS_ZERO_STRUCT(m_options); } @@ -164,6 +164,12 @@ aws_tls_ctx_options_set_verify_peer(&m_options, verify_peer); } + void TlsContextOptions::SetNoCertificateRevocation(bool no_certificate_revocation) noexcept + { + AWS_ASSERT(m_isInit); + aws_tls_ctx_options_set_no_certificate_revocation(&m_options, no_certificate_revocation); + } + void TlsContextOptions::SetMinimumTlsVersion(aws_tls_versions minimumTlsVersion) { AWS_ASSERT(m_isInit); @@ -268,10 +274,13 @@ return options; } - TlsConnectionOptions::TlsConnectionOptions() noexcept : m_lastError(AWS_ERROR_SUCCESS), m_isInit(false) {} + TlsConnectionOptions::TlsConnectionOptions() noexcept + { + AWS_ZERO_STRUCT(m_tls_connection_options); + } TlsConnectionOptions::TlsConnectionOptions(aws_tls_ctx *ctx, Allocator *allocator) noexcept - : m_allocator(allocator), m_lastError(AWS_ERROR_SUCCESS), m_isInit(true) + : m_allocator(allocator), m_isInit(true) { aws_tls_connection_options_init_from_ctx(&m_tls_connection_options, ctx); } @@ -287,7 +296,6 @@ TlsConnectionOptions::TlsConnectionOptions(const TlsConnectionOptions &options) noexcept { - m_isInit = false; AWS_ZERO_STRUCT(m_tls_connection_options); if (options.m_isInit) @@ -338,6 +346,8 @@ TlsConnectionOptions::TlsConnectionOptions(TlsConnectionOptions &&options) noexcept : m_isInit(options.m_isInit) { + AWS_ZERO_STRUCT(m_tls_connection_options); + if (options.m_isInit) { m_tls_connection_options = options.m_tls_connection_options; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-crt-cpp-0.40.1/source/mqtt/Mqtt5ClientCore.cpp new/aws-crt-cpp-0.41.0/source/mqtt/Mqtt5ClientCore.cpp --- old/aws-crt-cpp-0.40.1/source/mqtt/Mqtt5ClientCore.cpp 2026-06-11 22:18:31.000000000 +0200 +++ new/aws-crt-cpp-0.41.0/source/mqtt/Mqtt5ClientCore.cpp 2026-07-06 19:44:56.000000000 +0200 @@ -262,7 +262,7 @@ * InvokePublishAcknowledgement() later. */ uint64_t publishAcknowledgementId = 0; - PublishAcknowledgementFunctor functor; + std::shared_ptr<PublishAcknowledgementFunctor> sharedFunctor; if (publish->qos == AWS_MQTT5_QOS_AT_LEAST_ONCE) { /* Eagerly acquire the publish acknowledgement control before invoking the user callback. */ @@ -271,14 +271,13 @@ if (publishAcknowledgementId != 0) { - functor.handle = s_createPublishAcknowledgementHandle( - client_core->m_allocator, publishAcknowledgementId); - /* std::function requires a copyable callable so we wrap the move only functor + /* std::function requires a copyable callable so we wrap the move-only functor * into a shared_ptr so the lambda can be copyable. */ - auto sharedFunctor = + sharedFunctor = Aws::Crt::MakeShared<PublishAcknowledgementFunctor>(client_core->m_allocator); sharedFunctor->callbackThreadId = std::this_thread::get_id(); - sharedFunctor->handle = std::move(functor.handle); + sharedFunctor->handle = s_createPublishAcknowledgementHandle( + client_core->m_allocator, publishAcknowledgementId); eventData.acquirePublishAcknowledgement = [sharedFunctor]() -> ScopedResource<PublishAcknowledgementHandle> { return (*sharedFunctor)(); }; @@ -296,17 +295,17 @@ client_core->onPublishReceived(eventData); /* Detect whether the user called acquirePublishAcknowledgement() during the callback: - * - If they called it, the functor moved its ScopedResource out, so functor.handle is null. - * - If they did NOT call it, functor.handle is still non-null here. + * - If they called it, the functor moved its handle out, so sharedFunctor->handle is null. + * - If they did NOT call it, sharedFunctor->handle is still non-null here. * * If the handle is still in the functor (user did not take control), auto-invoke the - * publish acknowledgement. The functor's handle going out of scope will free the + * publish acknowledgement. The sharedFunctor's handle going out of scope will free the * PublishAcknowledgementHandle regardless. * * We also check client_core->m_client because it's possible (through insanity) that the * user has killed the client in the onPublishReceived callback. The recursive mutex * protects this check. */ - bool userDidNotTakeControl = publishAcknowledgementId != 0 && functor.handle != nullptr; + bool userDidNotTakeControl = sharedFunctor != nullptr && sharedFunctor->handle != nullptr; if (userDidNotTakeControl && client_core->m_client != nullptr) { aws_mqtt5_client_invoke_publish_acknowledgement( diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-crt-cpp-0.40.1/tests/CMakeLists.txt new/aws-crt-cpp-0.41.0/tests/CMakeLists.txt --- old/aws-crt-cpp-0.40.1/tests/CMakeLists.txt 2026-06-11 22:18:31.000000000 +0200 +++ new/aws-crt-cpp-0.41.0/tests/CMakeLists.txt 2026-07-06 19:44:56.000000000 +0200 @@ -257,6 +257,7 @@ add_net_test_case(Mqtt5NullUnsubscribe) add_net_test_case(Mqtt5ReuseUnsubscribePacket) add_net_test_case(Mqtt5QoS1SubPub) + add_net_test_case(Mqtt5QoS1AutoPubackNoDuplicate) add_net_test_case(Mqtt5RetainSetAndClear) add_net_test_case(Mqtt5ManualPubackHold) add_net_test_case(Mqtt5ManualPubackInvoke) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-crt-cpp-0.40.1/tests/Mqtt5ClientTest.cpp new/aws-crt-cpp-0.41.0/tests/Mqtt5ClientTest.cpp --- old/aws-crt-cpp-0.40.1/tests/Mqtt5ClientTest.cpp 2026-06-11 22:18:31.000000000 +0200 +++ new/aws-crt-cpp-0.41.0/tests/Mqtt5ClientTest.cpp 2026-07-06 19:44:56.000000000 +0200 @@ -19,6 +19,9 @@ using namespace Aws::Crt; using namespace Aws::Crt::Mqtt5; +/* How long to wait for the broker to re-deliver an unacknowledged QoS 1 publish. */ +static const int BROKER_PUBACK_RETRY_WAIT_SECONDS = 60; + ////////////////////////////////////////////////////////// // Creation Test Cases [New-UC] (runs regardless of byo-crypto) ////////////////////////////////////////////////////////// @@ -2056,6 +2059,103 @@ } AWS_TEST_CASE(Mqtt5QoS1SubPub, s_TestMqtt5QoS1SubPub) +/* + * [QoS1-UC1b] Verify auto-PUBACK: subscribe QoS 1, do NOT call acquirePublishAcknowledgement() in the callback, + * wait a few seconds and assert no duplicate delivery. If the auto-PUBACK path is broken, the broker will resend. + */ +static int s_TestMqtt5QoS1AutoPubackNoDuplicate(Aws::Crt::Allocator *allocator, void *) +{ + ApiHandle apiHandle(allocator); + + const String TEST_TOPIC = "test/s_TestMqtt5QoS1AutoPubackNoDuplicate" + Aws::Crt::UUID().ToString(); + std::atomic<int> receiveCount(0); + std::promise<void> firstReceived; + std::promise<void> duplicateReceived; + + Mqtt5TestContext subscriberContext = createTestContext( + allocator, + MQTT5CONNECT_DIRECT_IOT_CORE, + [&receiveCount, &firstReceived, &duplicateReceived, &TEST_TOPIC]( + Mqtt5ClientOptions &options, const Mqtt5TestEnvVars &, Mqtt5TestContext &) + { + options.WithPublishReceivedCallback( + [&receiveCount, &firstReceived, &duplicateReceived, &TEST_TOPIC]( + const PublishReceivedEventData &eventData) + { + String topic = eventData.publishPacket->getTopic(); + if (topic == TEST_TOPIC) + { + int count = ++receiveCount; + if (count == 1) + { + firstReceived.set_value(); + } + else if (count == 2) + { + duplicateReceived.set_value(); + } + } + }); + + return AWS_OP_SUCCESS; + }); + if (subscriberContext.testDirective == AWS_OP_SKIP) + { + return AWS_OP_SKIP; + } + + std::shared_ptr<Mqtt5Client> subscriberClient = subscriberContext.client; + ASSERT_TRUE(subscriberClient); + + Mqtt5TestContext publisherContext = createTestContext(allocator, MQTT5CONNECT_DIRECT_IOT_CORE); + if (publisherContext.testDirective == AWS_OP_SKIP) + { + return AWS_OP_SKIP; + } + + std::shared_ptr<Mqtt5Client> publisherClient = publisherContext.client; + ASSERT_TRUE(publisherClient); + + ASSERT_TRUE(publisherClient->Start()); + ASSERT_TRUE(publisherContext.connectionPromise.get_future().get()); + + ASSERT_TRUE(subscriberClient->Start()); + ASSERT_TRUE(subscriberContext.connectionPromise.get_future().get()); + + Mqtt5::Subscription subscription(TEST_TOPIC, Mqtt5::QOS::AWS_MQTT5_QOS_AT_LEAST_ONCE, allocator); + std::shared_ptr<Mqtt5::SubscribePacket> subscribe = Aws::Crt::MakeShared<Mqtt5::SubscribePacket>(allocator); + subscribe->WithSubscription(std::move(subscription)); + + std::promise<void> subscribed; + ASSERT_TRUE(subscriberClient->Subscribe( + subscribe, [&subscribed](int, std::shared_ptr<Mqtt5::SubAckPacket>) { subscribed.set_value(); })); + subscribed.get_future().get(); + + /* Publish a single QoS 1 message */ + std::shared_ptr<Mqtt5::PublishPacket> publish = Aws::Crt::MakeShared<Mqtt5::PublishPacket>( + allocator, TEST_TOPIC, ByteCursorFromCString("hello"), Mqtt5::QOS::AWS_MQTT5_QOS_AT_LEAST_ONCE, allocator); + ASSERT_TRUE(publisherClient->Publish(publish)); + + /* Wait for the first delivery */ + firstReceived.get_future().get(); + + /* Wait for the broker to potentially resend if PUBACK was never sent. + * Fail fast if a duplicate arrives; otherwise wait for the broker retry interval to pass. */ + auto duplicateFuture = duplicateReceived.get_future(); + auto waitResult = duplicateFuture.wait_for(std::chrono::seconds(BROKER_PUBACK_RETRY_WAIT_SECONDS)); + + /* If auto-PUBACK worked, we should have received exactly 1 message (timeout = no duplicate = success) */ + ASSERT_TRUE(waitResult == std::future_status::timeout); + + ASSERT_TRUE(subscriberClient->Stop()); + subscriberContext.stoppedPromise.get_future().get(); + ASSERT_TRUE(publisherClient->Stop()); + publisherContext.stoppedPromise.get_future().get(); + + return AWS_OP_SUCCESS; +} +AWS_TEST_CASE(Mqtt5QoS1AutoPubackNoDuplicate, s_TestMqtt5QoS1AutoPubackNoDuplicate) + ///* // * TODO: // * [QoS1-UC2] Happy path. No drop in connection, no retry, no reconnect. @@ -2162,9 +2262,10 @@ firstDeliveryPromise.get_future().get(); ASSERT_TRUE(capturedHandle != nullptr); - /* Wait up to 60 seconds for the broker to re-deliver the message (no PUBACK was sent) */ + /* Wait for the broker to re-deliver the message (no PUBACK was sent) */ auto redeliveryFuture = redeliveryPromise.get_future(); - ASSERT_TRUE(redeliveryFuture.wait_for(std::chrono::seconds(60)) == std::future_status::ready); + ASSERT_TRUE( + redeliveryFuture.wait_for(std::chrono::seconds(BROKER_PUBACK_RETRY_WAIT_SECONDS)) == std::future_status::ready); /* Release the held PUBACK now that we've confirmed re-delivery */ ASSERT_TRUE(mqtt5Client->InvokePublishAcknowledgement(*capturedHandle)); @@ -2277,9 +2378,10 @@ /* Immediately invoke the PUBACK using the acquired handle */ ASSERT_TRUE(mqtt5Client->InvokePublishAcknowledgement(*capturedHandle)); - /* Wait 60 seconds and confirm the broker does NOT re-deliver the message */ + /* Wait and confirm the broker does NOT re-deliver the message */ auto redeliveryFuture = unexpectedRedeliveryPromise.get_future(); - bool redelivered = redeliveryFuture.wait_for(std::chrono::seconds(60)) == std::future_status::ready; + bool redelivered = + redeliveryFuture.wait_for(std::chrono::seconds(BROKER_PUBACK_RETRY_WAIT_SECONDS)) == std::future_status::ready; ASSERT_FALSE(redelivered); ASSERT_TRUE(mqtt5Client->Stop());
