Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package aws-c-io for openSUSE:Factory
checked in at 2025-05-07 19:21:08
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/aws-c-io (Old)
and /work/SRC/openSUSE:Factory/.aws-c-io.new.30101 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "aws-c-io"
Wed May 7 19:21:08 2025 rev:22 rq:1275237 version:0.19.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/aws-c-io/aws-c-io.changes 2025-04-20
19:49:58.271886453 +0200
+++ /work/SRC/openSUSE:Factory/.aws-c-io.new.30101/aws-c-io.changes
2025-05-07 19:21:21.427434192 +0200
@@ -1,0 +2,10 @@
+Tue May 6 13:19:42 UTC 2025 - John Paul Adrian Glaubitz
<adrian.glaub...@suse.com>
+
+- Update to version 0.19.0
+ * Make exports consistent by @DmitriyMusatkin in (#720)
+ * Improve docs for aws_future by @graebm in (#724)
+ * Task type_log logging by @sbSteveK in (#726)
+ * AWS_IO_TLS_CIPHER_PREF_PQ_TLSv1_0_2021_05 is not
+ supported now by @TingDaoK in (#727)
+
+-------------------------------------------------------------------
Old:
----
v0.18.1.tar.gz
New:
----
v0.19.0.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ aws-c-io.spec ++++++
--- /var/tmp/diff_new_pack.mzGVbM/_old 2025-05-07 19:21:22.703487417 +0200
+++ /var/tmp/diff_new_pack.mzGVbM/_new 2025-05-07 19:21:22.707487584 +0200
@@ -21,7 +21,7 @@
%define library_version 1.0.0
%define library_soversion 0unstable
Name: aws-c-io
-Version: 0.18.1
+Version: 0.19.0
Release: 0
Summary: I/O and TLS package AWS SDK for C
License: Apache-2.0
++++++ v0.18.1.tar.gz -> v0.19.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-io-0.18.1/.github/workflows/proof-alarm.yml
new/aws-c-io-0.19.0/.github/workflows/proof-alarm.yml
--- old/aws-c-io-0.18.1/.github/workflows/proof-alarm.yml 2025-04-09
16:33:10.000000000 +0200
+++ new/aws-c-io-0.19.0/.github/workflows/proof-alarm.yml 2025-04-30
23:26:13.000000000 +0200
@@ -16,7 +16,7 @@
- name: Check
run: |
TMPFILE=$(mktemp)
- echo "e857a2e5f72ab77a94e56372d89abf99
source/linux/epoll_event_loop.c" > $TMPFILE
+ echo "64a05aa7dfecba86bf4296a08b4cdf3a
source/linux/epoll_event_loop.c" > $TMPFILE
md5sum --check $TMPFILE
# No further steps if successful
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-io-0.18.1/include/aws/io/exports.h
new/aws-c-io-0.19.0/include/aws/io/exports.h
--- old/aws-c-io-0.18.1/include/aws/io/exports.h 2025-04-09
16:33:10.000000000 +0200
+++ new/aws-c-io-0.19.0/include/aws/io/exports.h 2025-04-30
23:26:13.000000000 +0200
@@ -6,7 +6,7 @@
* SPDX-License-Identifier: Apache-2.0.
*/
-#if defined(USE_WINDOWS_DLL_SEMANTICS) || defined(WIN32)
+#if defined(AWS_CRT_USE_WINDOWS_DLL_SEMANTICS) || defined(_WIN32)
# ifdef AWS_IO_USE_IMPORT_EXPORT
# ifdef AWS_IO_EXPORTS
# define AWS_IO_API __declspec(dllexport)
@@ -18,12 +18,12 @@
# endif /* USE_IMPORT_EXPORT */
#else
-# if ((__GNUC__ >= 4) || defined(__clang__)) &&
defined(AWS_IO_USE_IMPORT_EXPORT) && defined(AWS_IO_EXPORTS)
+# if defined(AWS_IO_USE_IMPORT_EXPORT) && defined(AWS_IO_EXPORTS)
# define AWS_IO_API __attribute__((visibility("default")))
# else
# define AWS_IO_API
-# endif /* __GNUC__ >= 4 || defined(__clang__) */
+# endif
-#endif /* defined(USE_WINDOWS_DLL_SEMANTICS) || defined(WIN32) */
+#endif /* defined(AWS_CRT_USE_WINDOWS_DLL_SEMANTICS) || defined(_WIN32) */
#endif /* AWS_IO_EXPORTS_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-io-0.18.1/include/aws/io/future.h
new/aws-c-io-0.19.0/include/aws/io/future.h
--- old/aws-c-io-0.18.1/include/aws/io/future.h 2025-04-09 16:33:10.000000000
+0200
+++ new/aws-c-io-0.19.0/include/aws/io/future.h 2025-04-30 23:26:13.000000000
+0200
@@ -8,31 +8,34 @@
/*
-// THIS IS AN EXPERIMENTAL AND UNSTABLE API
-//
-// An aws_future is used to deliver the result of an asynchronous function.
-//
-// When an async function is called, it creates a future and returns it to the
caller.
-// When the async work is finished, it completes the future by setting an
error or result value.
-// The caller waits until the future is done, checks for error, and then gets
-// the result if everything was OK. Typically, the caller waits by registering
-// a callback that the future invokes when it's done.
-//
-// If result type T has a "destructor" (clean_up(), destroy(), or release()
function),
-// then the future has set_result_by_move() and get_result_by_move() functions
-// that explicitly transfer ownership to and from the future.
-// If the future dies, and still "owns" the resource, it calls the destructor.
-// If T has no destructor, then the future has set_result() and get_result()
-// functions that simply copy T by value.
-//
-// Macros are used to define a type-safe API for each result type T,
-// similar to C++ templates. This makes the API hard to browse, so functions
-// are documented in comments below. The result setter/getter functions
-// are mildly different based on T's destructor type, and are documented later.
-
-//
-// --- API (common to all aws_future<T>) ---
-//
+--------------------------------------------------------------------------------
+INTRO
+--------------------------------------------------------------------------------
+An aws_future is used to deliver the result of an asynchronous function.
+
+When an async function is called, it creates a future and returns it to the
caller.
+When the async work is finished, it completes the future by setting an error
or result value.
+The caller waits until the future is done, checks for error, and then gets
+the result if everything was OK. Typically, the caller waits by registering
+a callback that the future invokes when it's done. There are many different
+ways to register callbacks, depending on what thread you want it to fire on.
+
+If result type T has a "destructor" (clean_up(), destroy(), or release()
function),
+then the future has set_result_by_move() and get_result_by_move() functions
+that explicitly transfer ownership to and from the future.
+If the future dies, and still "owns" the resource, it calls the destructor.
+If T has no destructor, then the future has set_result() and get_result()
+functions that simply copy T by value.
+
+Macros are used to define a type-safe API for each result type T,
+similar to C++ templates. This makes the API hard to browse, so functions
+are documented in comments below.
+
+--------------------------------------------------------------------------------
+API (common to all aws_future<T>)
+ The set/get result functions are mildly different based on T's
+ destructor type, and are documented later.
+--------------------------------------------------------------------------------
// Create a new future, with refcount of 1.
struct aws_future_T *aws_future_T_new(struct aws_allocator *alloc);
@@ -81,8 +84,7 @@
// Or if you are holding a non-recursive mutex, and the callback also
// needs the mutex, and an immediate callback would deadlock.
//
-// WARNING: If a callback is registered, you MUST NOT call this again until
-// the callback has been invoked.
+// WARNING: You MUST NOT register more than one callback.
bool aws_future_T_register_callback_if_not_done(
struct aws_future_T *future,
aws_future_callback_fn *on_done,
@@ -118,67 +120,202 @@
// Wait (up to timeout_ns) for future to complete.
// Returns true if future completes in this time.
-// This blocks the current thread, and is probably only useful for tests and
sample programs.
+// This blocks the current thread. It is dangerous to use anywhere except
+// the main thread of simple programs or tests.
bool aws_future_T_wait(struct aws_future_T *future, uint64_t timeout_ns);
+--------------------------------------------------------------------------------
+AWS_FUTURE_T_BY_VALUE set/get API
+ Where T is stored by value, with no destructor.
+ Use with simple types like bool, size_t, enums, etc.
+--------------------------------------------------------------------------------
+
+// Set the result.
+//
+// If the future is already done this call is ignored.
+void aws_future_T_set_result(const struct aws_future_T *future, T result);
+
+// Get the result of a completed future.
+//
+// WARNING: You MUST NOT call this until the future is done.
+// WARNING: You MUST NOT call this unless get_error() returned 0.
+T aws_future_T_get_result(const struct aws_future_T *future);
+
+--------------------------------------------------------------------------------
+AWS_FUTURE_T_BY_VALUE_WITH_CLEAN_UP set/get API
+ Where T is stored by value, with destructor like: void aws_T_clean_up(T*)
+ Use with types like aws_byte_buf.
+--------------------------------------------------------------------------------
+
+// Set the result, transferring ownership.
+//
+// The memory at `value_address` is memcpy'd into the future,
+// and then zeroed out to help prevent accidental reuse.
+// It is safe to call this multiple times. If the future is already done,
+// the new result is destroyed instead of saved.
+void aws_future_T_set_result_by_move(struct aws_future_T *future, T
*value_address);
+
+// Get the result, transferring ownership.
+//
+// WARNING: You MUST NOT call this until the future is done.
+// WARNING: You MUST NOT call this unless get_error() returned 0.
+// WARNING: You MUST NOT call this multiple times.
+T aws_future_T_get_result_by_move(struct aws_future_T *future);
+
+// Get the result, without transferring ownership.
+//
+// WARNING: You MUST NOT call this until the future is done.
+// WARNING: You MUST NOT call this unless get_error() returned 0.
+// WARNING: You MUST NOT call this multiple times.
+T* aws_future_T_peek_result(const struct aws_future_T *future);
+
+--------------------------------------------------------------------------------
+AWS_FUTURE_T_POINTER_WITH_DESTROY set/get API
+ Where T is stored by pointer, with destructor like: void aws_T_destroy(T*)
+ Use with types like aws_string.
+--------------------------------------------------------------------------------
+
+// Set the result, transferring ownership.
+//
+// The value at `pointer_address` is copied into the future,
+// and then set NULL to prevent accidental reuse.
+// If the future is already done, this new result is destroyed instead of
saved.
+void aws_future_T_set_result_by_move(struct aws_future_T *future, T
**pointer_address);
+
+// Get the result, transferring ownership.
+//
+// WARNING: You MUST NOT call this until the future is done.
+// WARNING: You MUST NOT call this unless get_error() returned 0.
+// WARNING: You MUST NOT call this multiple times.
+T* aws_future_T_get_result_by_move(struct aws_future_T *future);
+
+// Get the result, without transferring ownership.
+//
+// WARNING: You MUST NOT call this until the future is done.
+// WARNING: You MUST NOT call this unless get_error() returned 0.
+// WARNING: You MUST NOT call this multiple times.
+T* aws_future_T_peek_result(const struct aws_future_T *future);
+
+--------------------------------------------------------------------------------
+AWS_FUTURE_T_POINTER_WITH_RELEASE set/get API
+ Where T is stored by pointer, with destructor like: T* aws_T_release(T*)
+ Use with types like aws_http_message
+--------------------------------------------------------------------------------
+
+// Set the result, transferring ownership.
+//
+// The value at `pointer_address` is copied into the future,
+// and then set NULL to prevent accidental reuse.
+// If the future is already done, this new result is destroyed instead of
saved.
+void aws_future_T_set_result_by_move(struct aws_future_T *future, T
**pointer_address);
+
+// Get the result, transferring ownership.
+//
+// WARNING: You MUST NOT call this until the future is done.
+// WARNING: You MUST NOT call this unless get_error() returned 0.
+// WARNING: You MUST NOT call this multiple times.
+T* aws_future_T_get_result_by_move(struct aws_future_T *future);
+
+// Get the result, without transferring ownership.
+//
+// WARNING: You MUST NOT call this until the future is done.
+// WARNING: You MUST NOT call this unless get_error() returned 0.
+// WARNING: You MUST NOT call this multiple times.
+T* aws_future_T_peek_result(const struct aws_future_T *future);
+
+--------------------------------------------------------------------------------
+AWS_FUTURE_T_POINTER set/get API
+ Where T is stored by pointer, with no destructor.
+ No known use cases, but it's here for completeness.
+--------------------------------------------------------------------------------
+
+// Set the result.
+//
+// If the future is already done this call is ignored.
+void aws_future_T_set_result(const struct aws_future_T *future, T *result);
+
+// Get the result of a completed future.
//
-// --- Defining new aws_future types ---
-// TODO UPDATE THESE DOCS
-// To define new types of aws_future<T>, add the appropriate macro to the
appropriate header.
-// The macros are:
-//
-// AWS_DECLARE_FUTURE_T_BY_VALUE(FUTURE, T)
-// For T stored by value, with no destructor.
-// Use with types like bool, size_t, etc
-//
-// AWS_DECLARE_FUTURE_T_BY_VALUE_WITH_CLEAN_UP(FUTURE, T, CLEAN_UP_FN)
-// For T stored by value, with destructor like: void aws_T_clean_up(T*)
-// Use with types like `struct aws_byte_buf`
-//
-// AWS_DECLARE_FUTURE_T_POINTER_WITH_DESTROY(FUTURE, T, DESTROY_FN)
-// For T stored by pointer, with destructor like: void aws_T_destroy(T*)
-// Use with types like `struct aws_string *`
-//
-// AWS_DECLARE_FUTURE_T_POINTER_WITH_RELEASE(FUTURE, T, RELEASE_FN)
-// For T stored by pointer, with destructor like: T* aws_T_release(T*)
-// Use with types like `struct aws_http_message *`
-// Note: if T's release() function doesn't return a pointer, use _WITH_DESTROY
instead of _WITH_RELEASE.
-//
-// This file declares several common types: aws_future<size_t>,
aws_future<void>, etc.
-// But new future types should be declared in the header where that type's API
is declared.
-// For example:
AWS_DECLARE_FUTURE_T_POINTER_WITH_RELEASE(aws_future_http_message, struct
aws_http_message)
-// would go in: aws-c-http/include/aws/http/request_response.h
-//
-// The APIs generated by these macros are identical except for the "setter"
and "getter" functions.
-
-//
-// --- Design (if you're curious) ---
-//
-// This class was developed to give the user more control over how the
completion
-// callback is invoked. In the past, we passed completion callbacks to the
async
-// function. But this could lead to issues when an async function "sometimes"
-// completed synchronously and "sometimes" completed async. The async function
-// would need to stress about how to schedule the callback so it was always
async,
-// or more typically just invoke it whenever and leave the caller to figure it
out.
-//
-// This class is also an experiment with "templates/generics in C".
-// In order to make the class type-safe, we use macros to define a unique
-// API for each result type T we need to store in a future.
-// If we refer to aws_future<struct aws_byte_buf>, we mean a struct named
-// aws_future_byte_buf, which stores an aws_byte_buf by value.
-// This could lead to code bloat, but the type-safety seems worth it.
-//
-// future is defined in aws-c-io, instead of aws-c-common, so it can
-// easily integrate with aws_event_loop and aws_channel.
-//
-// It's legal to call set_error() or set_result() multiple times.
-// If the future is already done, it ignores the call.
-// If result T has a destructor, the new result is immediately freed instead
of saved.
-// This design lets us deal with ambiguity where it's not 100% certain whether
a handoff occurred.
-// For example: if we call from C->Java and an exception is thrown,
-// it's not clear whether Java got the handoff. In this case, we can safely
-// call set_error(), completing the future if necessary,
-// or being ignored if the future was already done.
+// WARNING: You MUST NOT call this until the future is done.
+// WARNING: You MUST NOT call this unless get_error() returned 0.
+T* aws_future_T_get_result(const struct aws_future_T *future);
+
+--------------------------------------------------------------------------------
+DEFINING NEW aws_future<T>
+--------------------------------------------------------------------------------
+
+Macros are used to define a type-safe API for each result type T, similar to
C++ templates.
+
+Use the _DECLARATION() macro in the same header where T's API is declared.
+Use the _IMPLEMENTATION() macro in the corresponding .c file.
+The macros can only be used once for each type T,
+so it makes sense to put it where T is declared.
+If T lives in a single .c file and has no header, you can simply use the
+_IMPLEMENTATION() macro without a _DECLARATION().
+
+You must pick the right macros for your particular T, based on whether T is
stored
+by value or by pointer, and which type of "destructor" function it has:
+
+- AWS_FUTURE_T_BY_VALUE: A future that holds a simple T by value, that needs
no destructor.
+ Use with types like bool, size_t, enums, etc.
+ Example:
+ AWS_FUTURE_T_BY_VALUE_DECLARATION(aws_future_size, size_t, AWS_IO_API)
+ AWS_FUTURE_T_BY_VALUE_IMPLEMENTATION(aws_future_size, size_t)
+
+- AWS_FUTURE_T_BY_VALUE_WITH_CLEAN_UP: A future that holds T by value, with
destructor like: void aws_T_clean_up(T*)
+ Use with types like aws_byte_buf.
+ Example:
+ AWS_FUTURE_T_BY_VALUE_WITH_CLEAN_UP_DECLARATION(aws_future_byte_buf,
aws_byte_buf, AWS_IO_API)
+
AWS_FUTURE_T_BY_VALUE_WITH_CLEAN_UP_IMPLEMENTATION(aws_future_byte_buf,
aws_byte_buf,
+
aws_byte_buf_clean_up);
+- AWS_FUTURE_T_POINTER_WITH_DESTROY: A future that holds T*, with destructor
like: void aws_T_destroy(T*)
+ Use with types like aws_string.
+ Example:
+ AWS_FUTURE_T_POINTER_WITH_DESTROY_DECLARATION(aws_future_string,
aws_string, AWS_IO_API)
+ AWS_FUTURE_T_POINTER_WITH_DESTROY_DECLARATION(aws_future_string,
aws_string, AWS_IO_API)
+
+- AWS_FUTURE_T_POINTER_WITH_RELEASE: A future that holds T*, with destructor
like: T* aws_T_release(T*)
+ Use with types like aws_http_message
+ Example:
+ AWS_FUTURE_T_POINTER_WITH_RELEASE_DECLARATION(aws_future_http_message,
struct aws_http_message,
+ AWS_HTTP_API)
+
AWS_FUTURE_T_POINTER_WITH_RELEASE_IMPLEMENTATION(aws_future_http_message,
struct aws_http_message,
+
aws_http_message_release)
+
+- AWS_FUTURE_T_POINTER: A future that holds T*, with no destructor.
+ No known use cases, but it's here for completeness.
+ Example:
+ AWS_FUTURE_T_POINTER_DECLARATION(aws_future_file. FILE, AWS_IO_API)
+ AWS_FUTURE_T_POINTER_IMPLEMENTATION(aws_future_file. FILE)
+
+--------------------------------------------------------------------------------
+DESIGN (if you're curious)
+--------------------------------------------------------------------------------
+This class was developed to give the user more control over how the completion
+callback is invoked. In the past, we passed completion callbacks to the async
+function. But this could lead to issues when an async function "sometimes"
+completed synchronously and "sometimes" completed async. The async function
+would need to stress about how to schedule the callback so it was always async,
+or more typically just invoke it whenever and leave the caller to figure it
out.
+
+This class is also an experiment with "templates/generics in C".
+In order to make the class type-safe, we use macros to define a unique
+API for each result type T we need to store in a future.
+If we refer to aws_future<struct aws_byte_buf>, we mean a struct named
+aws_future_byte_buf, which stores an aws_byte_buf by value.
+This could lead to code bloat, but the type-safety seems worth it.
+
+future is defined in aws-c-io, instead of aws-c-common, so it can
+easily integrate with aws_event_loop and aws_channel.
+
+It's legal to call set_error() or set_result() multiple times.
+If the future is already done, it ignores the call.
+If result T has a destructor, the new result is immediately freed instead of
saved.
+This design lets us deal with ambiguity where it's not 100% certain whether a
handoff occurred.
+For example: if we call from C->Java and an exception is thrown,
+it's not clear whether Java got the handoff. In this case, we can safely
+call set_error(), completing the future if necessary,
+or being ignored if the future was already done.
*/
@@ -349,21 +486,8 @@
* Declare a future that holds a simple T by value, that needs no destructor.
* Use with types like bool, size_t, etc.
*
- * See top of future.h for most API docs.
- * The result setters and getters are:
-
-// Set the result.
-//
-// If the future is already done this call is ignored.
-void aws_future_T_set_result(const struct aws_future_T *future, T result);
-
-// Get the result of a completed future.
-//
-// WARNING: You MUST NOT call this until the future is done.
-// WARNING: You MUST NOT call this unless get_error() returned 0.
-T aws_future_T_get_result(const struct aws_future_T *future);
-
-*/
+ * See top of future.h for docs.
+ */
#define AWS_FUTURE_T_BY_VALUE_DECLARATION(FUTURE, T, API)
\
AWS_FUTURE_T_DECLARATION_BEGIN(FUTURE, API)
\
API struct FUTURE *FUTURE##_new(struct aws_allocator *alloc);
\
@@ -390,31 +514,7 @@
* Declares a future that holds T by value, with destructor like: void
aws_T_clean_up(T*)
* Use with types like aws_byte_buf.
*
- * See top of future.h for most API docs.
- * The result setters and getters are:
-
-// Set the result, transferring ownership.
-//
-// The memory at `value_address` is memcpy'd into the future,
-// and then zeroed out to help prevent accidental reuse.
-// It is safe to call this multiple times. If the future is already done,
-// the new result is destroyed instead of saved.
-void aws_future_T_set_result_by_move(struct aws_future_T *future, T
*value_address);
-
-// Get the result, transferring ownership.
-//
-// WARNING: You MUST NOT call this until the future is done.
-// WARNING: You MUST NOT call this unless get_error() returned 0.
-// WARNING: You MUST NOT call this multiple times.
-T aws_future_T_get_result_by_move(struct aws_future_T *future);
-
-// Get the result, without transferring ownership.
-//
-// WARNING: You MUST NOT call this until the future is done.
-// WARNING: You MUST NOT call this unless get_error() returned 0.
-// WARNING: You MUST NOT call this multiple times.
-T* aws_future_T_peek_result(const struct aws_future_T *future);
-
+ * See top of future.h for docs.
*/
#define AWS_FUTURE_T_BY_VALUE_WITH_CLEAN_UP_DECLARATION(FUTURE, T, API)
\
AWS_FUTURE_T_DECLARATION_BEGIN(FUTURE, API)
\
@@ -451,6 +551,8 @@
/**
* Declares a future that holds T*, with no destructor.
+ *
+ * See top of future.h for docs.
*/
#define AWS_FUTURE_T_POINTER_DECLARATION(FUTURE, T, API)
\
AWS_FUTURE_T_DECLARATION_BEGIN(FUTURE, API)
\
@@ -480,30 +582,7 @@
* Declares a future that holds T*, with destructor like: void
aws_T_destroy(T*)
* Use with types like aws_string.
*
- * See top of future.h for most API docs.
- * The result setters and getters are:
-
-// Set the result, transferring ownership.
-//
-// The value at `pointer_address` is copied into the future,
-// and then set NULL to prevent accidental reuse.
-// If the future is already done, this new result is destroyed instead of
saved.
-void aws_future_T_set_result_by_move(struct aws_future_T *future, T
**pointer_address);
-
-// Get the result, transferring ownership.
-//
-// WARNING: You MUST NOT call this until the future is done.
-// WARNING: You MUST NOT call this unless get_error() returned 0.
-// WARNING: You MUST NOT call this multiple times.
-T* aws_future_T_get_result_by_move(struct aws_future_T *future);
-
-// Get the result, without transferring ownership.
-//
-// WARNING: You MUST NOT call this until the future is done.
-// WARNING: You MUST NOT call this unless get_error() returned 0.
-// WARNING: You MUST NOT call this multiple times.
-T* aws_future_T_peek_result(const struct aws_future_T *future);
-
+ * See top of future.h for docs.
*/
#define AWS_FUTURE_T_POINTER_WITH_DESTROY_DECLARATION(FUTURE, T, API)
\
AWS_FUTURE_T_DECLARATION_BEGIN(FUTURE, API)
\
@@ -542,30 +621,7 @@
* Declares a future that holds T*, with destructor like: T* aws_T_release(T*)
* Use with types like aws_http_message
*
- * See top of future.h for most API docs.
- * The result setters and getters are:
-
-// Set the result, transferring ownership.
-//
-// The value at `pointer_address` is copied into the future,
-// and then set NULL to prevent accidental reuse.
-// If the future is already done, this new result is destroyed instead of
saved.
-void aws_future_T_set_result_by_move(struct aws_future_T *future, T
**pointer_address);
-
-// Get the result, transferring ownership.
-//
-// WARNING: You MUST NOT call this until the future is done.
-// WARNING: You MUST NOT call this unless get_error() returned 0.
-// WARNING: You MUST NOT call this multiple times.
-T* aws_future_T_get_result_by_move(struct aws_future_T *future);
-
-// Get the result, without transferring ownership.
-//
-// WARNING: You MUST NOT call this until the future is done.
-// WARNING: You MUST NOT call this unless get_error() returned 0.
-// WARNING: You MUST NOT call this multiple times.
-T* aws_future_T_peek_result(const struct aws_future_T *future);
-
+ * See top of future.h for docs.
*/
#define AWS_FUTURE_T_POINTER_WITH_RELEASE_DECLARATION(FUTURE, T, API)
\
AWS_FUTURE_T_DECLARATION_BEGIN(FUTURE, API)
\
@@ -602,16 +658,19 @@
/**
* aws_future<size_t>
+ * See top of future.h for docs.
*/
AWS_FUTURE_T_BY_VALUE_DECLARATION(aws_future_size, size_t, AWS_IO_API)
/**
* aws_future<bool>
+ * See top of future.h for docs.
*/
AWS_FUTURE_T_BY_VALUE_DECLARATION(aws_future_bool, bool, AWS_IO_API)
/**
* aws_future<void>
+ * See top of future.h for docs.
*/
AWS_FUTURE_T_DECLARATION_BEGIN(aws_future_void, AWS_IO_API)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-io-0.18.1/source/bsd/kqueue_event_loop.c
new/aws-c-io-0.19.0/source/bsd/kqueue_event_loop.c
--- old/aws-c-io-0.18.1/source/bsd/kqueue_event_loop.c 2025-04-09
16:33:10.000000000 +0200
+++ new/aws-c-io-0.19.0/source/bsd/kqueue_event_loop.c 2025-04-30
23:26:13.000000000 +0200
@@ -532,7 +532,8 @@
static void s_cancel_task(struct aws_event_loop *event_loop, struct aws_task
*task) {
struct kqueue_loop *kqueue_loop = event_loop->impl_data;
- AWS_LOGF_TRACE(AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling task %p", (void
*)event_loop, (void *)task);
+ AWS_LOGF_TRACE(
+ AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling %s task %p", (void
*)event_loop, task->type_tag, (void *)task);
aws_task_scheduler_cancel_task(&kqueue_loop->thread_data.scheduler, task);
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/aws-c-io-0.18.1/source/darwin/dispatch_queue_event_loop.c
new/aws-c-io-0.19.0/source/darwin/dispatch_queue_event_loop.c
--- old/aws-c-io-0.18.1/source/darwin/dispatch_queue_event_loop.c
2025-04-09 16:33:10.000000000 +0200
+++ new/aws-c-io-0.19.0/source/darwin/dispatch_queue_event_loop.c
2025-04-30 23:26:13.000000000 +0200
@@ -664,8 +664,9 @@
AWS_LOGF_TRACE(
AWS_LS_IO_EVENT_LOOP,
- "id=%p: Scheduling task %p cross-thread for timestamp %llu",
+ "id=%p: Scheduling %s task %p cross-thread for timestamp %llu",
(void *)event_loop,
+ task->type_tag,
(void *)task,
(unsigned long long)run_at_nanos);
@@ -694,7 +695,8 @@
}
static void s_cancel_task(struct aws_event_loop *event_loop, struct aws_task
*task) {
- AWS_LOGF_TRACE(AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling task %p", (void
*)event_loop, (void *)task);
+ AWS_LOGF_TRACE(
+ AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling %s task %p", (void
*)event_loop, task->type_tag, (void *)task);
struct aws_dispatch_loop *dispatch_loop = event_loop->impl_data;
/* First we move all cross thread tasks into the scheduler in case the
task to be cancelled hasn't moved yet. */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-io-0.18.1/source/linux/epoll_event_loop.c
new/aws-c-io-0.19.0/source/linux/epoll_event_loop.c
--- old/aws-c-io-0.18.1/source/linux/epoll_event_loop.c 2025-04-09
16:33:10.000000000 +0200
+++ new/aws-c-io-0.19.0/source/linux/epoll_event_loop.c 2025-04-30
23:26:13.000000000 +0200
@@ -357,8 +357,9 @@
if (s_is_on_callers_thread(event_loop)) {
AWS_LOGF_TRACE(
AWS_LS_IO_EVENT_LOOP,
- "id=%p: scheduling task %p in-thread for timestamp %llu",
+ "id=%p: scheduling %s task %p in-thread for timestamp %llu",
(void *)event_loop,
+ task->type_tag,
(void *)task,
(unsigned long long)run_at_nanos);
if (run_at_nanos == 0) {
@@ -372,8 +373,9 @@
AWS_LOGF_TRACE(
AWS_LS_IO_EVENT_LOOP,
- "id=%p: Scheduling task %p cross-thread for timestamp %llu",
+ "id=%p: Scheduling %s task %p cross-thread for timestamp %llu",
(void *)event_loop,
+ task->type_tag,
(void *)task,
(unsigned long long)run_at_nanos);
task->timestamp = run_at_nanos;
@@ -407,7 +409,8 @@
}
static void s_cancel_task(struct aws_event_loop *event_loop, struct aws_task
*task) {
- AWS_LOGF_TRACE(AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling task %p", (void
*)event_loop, (void *)task);
+ AWS_LOGF_TRACE(
+ AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling %s task %p", (void
*)event_loop, task->type_tag, (void *)task);
struct epoll_loop *epoll_loop = event_loop->impl_data;
aws_task_scheduler_cancel_task(&epoll_loop->scheduler, task);
}
@@ -563,8 +566,9 @@
struct aws_task *task = AWS_CONTAINER_OF(node, struct aws_task, node);
AWS_LOGF_TRACE(
AWS_LS_IO_EVENT_LOOP,
- "id=%p: task %p pulled to event-loop, scheduling now.",
+ "id=%p: task %s %p pulled to event-loop, scheduling now.",
(void *)event_loop,
+ task->type_tag,
(void *)task);
/* Timestamp 0 is used to denote "now" tasks */
if (task->timestamp == 0) {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-io-0.18.1/source/s2n/s2n_tls_channel_handler.c
new/aws-c-io-0.19.0/source/s2n/s2n_tls_channel_handler.c
--- old/aws-c-io-0.18.1/source/s2n/s2n_tls_channel_handler.c 2025-04-09
16:33:10.000000000 +0200
+++ new/aws-c-io-0.19.0/source/s2n/s2n_tls_channel_handler.c 2025-04-30
23:26:13.000000000 +0200
@@ -268,8 +268,6 @@
return true;
/* PQ Crypto no-ops on android for now */
#ifndef ANDROID
- case AWS_IO_TLS_CIPHER_PREF_PQ_TLSv1_0_2021_05:
- return true;
case AWS_IO_TLS_CIPHER_PREF_PQ_TLSV1_2_2024_10:
return true;
case AWS_IO_TLS_CIPHER_PREF_PQ_DEFAULT:
@@ -1541,9 +1539,6 @@
/* The specific PQ policy used here may change over time. */
security_policy = "AWS-CRT-SDK-TLSv1.2-2023-PQ";
break;
- case AWS_IO_TLS_CIPHER_PREF_PQ_TLSv1_0_2021_05:
- security_policy = "PQ-TLS-1-0-2021-05-26";
- break;
case AWS_IO_TLS_CIPHER_PREF_PQ_TLSV1_2_2024_10:
security_policy = "AWS-CRT-SDK-TLSv1.2-2023-PQ";
break;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/aws-c-io-0.18.1/source/windows/iocp/iocp_event_loop.c
new/aws-c-io-0.19.0/source/windows/iocp/iocp_event_loop.c
--- old/aws-c-io-0.18.1/source/windows/iocp/iocp_event_loop.c 2025-04-09
16:33:10.000000000 +0200
+++ new/aws-c-io-0.19.0/source/windows/iocp/iocp_event_loop.c 2025-04-30
23:26:13.000000000 +0200
@@ -467,8 +467,9 @@
if (s_is_event_thread(event_loop)) {
AWS_LOGF_TRACE(
AWS_LS_IO_EVENT_LOOP,
- "id=%p: scheduling task %p in-thread for timestamp %llu",
+ "id=%p: scheduling %s task %p in-thread for timestamp %llu",
(void *)event_loop,
+ task->type_tag,
(void *)task,
(unsigned long long)run_at_nanos);
if (run_at_nanos == 0) {
@@ -481,8 +482,9 @@
AWS_LOGF_TRACE(
AWS_LS_IO_EVENT_LOOP,
- "id=%p: Scheduling task %p cross-thread for timestamp %llu",
+ "id=%p: Scheduling %s task %p cross-thread for timestamp %llu",
(void *)event_loop,
+ task->type_tag,
(void *)task,
(unsigned long long)run_at_nanos);
/* Otherwise, add it to synced_data.tasks_to_schedule and signal the
event-thread to process it */
@@ -519,7 +521,8 @@
}
static void s_cancel_task(struct aws_event_loop *event_loop, struct aws_task
*task) {
- AWS_LOGF_TRACE(AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling task %p", (void
*)event_loop, (void *)task);
+ AWS_LOGF_TRACE(
+ AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling %s task %p", (void
*)event_loop, task->type_tag, (void *)task);
struct iocp_loop *iocp_loop = event_loop->impl_data;
aws_task_scheduler_cancel_task(&iocp_loop->thread_data.scheduler, task);
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-io-0.18.1/tests/vcc/cancel_task.c
new/aws-c-io-0.19.0/tests/vcc/cancel_task.c
--- old/aws-c-io-0.18.1/tests/vcc/cancel_task.c 2025-04-09 16:33:10.000000000
+0200
+++ new/aws-c-io-0.19.0/tests/vcc/cancel_task.c 2025-04-30 23:26:13.000000000
+0200
@@ -17,7 +17,7 @@
#include "preamble.h"
static void s_cancel_task(struct aws_event_loop *event_loop, struct aws_task
*task) {
- AWS_LOGF_TRACE(AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling task %p", (void
*)event_loop, (void *)task);
+ AWS_LOGF_TRACE(AWS_LS_IO_EVENT_LOOP, "id=%p: cancelling %s task %p", (void
*)event_loop, task->type_tag, (void *)task);
struct epoll_loop *epoll_loop = event_loop->impl_data;
aws_task_scheduler_cancel_task(&epoll_loop->scheduler, task);
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-io-0.18.1/tests/vcc/schedule.c
new/aws-c-io-0.19.0/tests/vcc/schedule.c
--- old/aws-c-io-0.18.1/tests/vcc/schedule.c 2025-04-09 16:33:10.000000000
+0200
+++ new/aws-c-io-0.19.0/tests/vcc/schedule.c 2025-04-30 23:26:13.000000000
+0200
@@ -49,8 +49,9 @@
if (s_is_on_callers_thread(event_loop _(ghost c_event_loop))) {
AWS_LOGF_TRACE(
AWS_LS_IO_EVENT_LOOP,
- "id=%p: scheduling task %p in-thread for timestamp %llu",
+ "id=%p: scheduling %s task %p in-thread for timestamp %llu",
(void *)event_loop,
+ task->type_tag,
(void *)task,
(unsigned long long)run_at_nanos);
if (run_at_nanos == 0) {
@@ -64,8 +65,9 @@
AWS_LOGF_TRACE(
AWS_LS_IO_EVENT_LOOP,
- "id=%p: Scheduling task %p cross-thread for timestamp %llu",
+ "id=%p: Scheduling %s task %p cross-thread for timestamp %llu",
(void *)event_loop,
+ task->type_tag,
(void *)task,
(unsigned long long)run_at_nanos);
_(unwrap task)
