@platformatic/rdkafka 4.0.1 → 4.1.0

package/deps/librdkafka/src/rdkafka_request.h

@@ -167,6 +167,14 @@ rd_kafka_topic_partition_list_t *rd_kafka_buf_read_topic_partitions(
     size_t estimated_part_cnt,
     const rd_kafka_topic_partition_field_t *fields);
 
+rd_kafka_topic_partition_list_t *rd_kafka_buf_read_topic_partitions_nullable(
+    rd_kafka_buf_t *rkbuf,
+    rd_bool_t use_topic_id,
+    rd_bool_t use_topic_name,
+    size_t estimated_part_cnt,
+    const rd_kafka_topic_partition_field_t *fields,
+    rd_bool_t *parse_err);
+
 int rd_kafka_buf_write_topic_partitions(
     rd_kafka_buf_t *rkbuf,
     const rd_kafka_topic_partition_list_t *parts,
@@ -237,6 +245,9 @@ void rd_kafka_OffsetForLeaderEpochRequest(
     rd_kafka_resp_cb_t *resp_cb,
     void *opaque);
 
+int rd_kafka_handle_OffsetFetch_err_action(rd_kafka_broker_t *rkb,
+                                           rd_kafka_resp_err_t err,
+                                           rd_kafka_buf_t *request);
 
 rd_kafka_resp_err_t
 rd_kafka_handle_OffsetFetch(rd_kafka_t *rk,
@@ -381,7 +392,8 @@ void rd_kafka_ConsumerGroupHeartbeatRequest(
     const rd_kafkap_str_t *group_instance_id,
     const rd_kafkap_str_t *rack_id,
     int32_t rebalance_timeout_ms,
-    const rd_kafka_topic_partition_list_t *subscribe_topics,
+    const rd_kafka_topic_partition_list_t *subscribed_topics,
+    rd_kafkap_str_t *subscribed_topic_regex,
     const rd_kafkap_str_t *remote_assignor,
     const rd_kafka_topic_partition_list_t *current_assignments,
     rd_kafka_replyq_t replyq,
@@ -394,6 +406,7 @@ rd_kafka_resp_err_t rd_kafka_MetadataRequest(rd_kafka_broker_t *rkb,
                                              const char *reason,
                                              rd_bool_t allow_auto_create_topics,
                                              rd_bool_t cgrp_update,
+                                             int32_t cgrp_subscription_version,
                                              rd_bool_t force_racks,
                                              rd_kafka_op_t *rko);
 
@@ -406,6 +419,7 @@ rd_kafka_resp_err_t rd_kafka_MetadataRequest_resp_cb(
     rd_bool_t include_cluster_authorized_operations,
     rd_bool_t include_topic_authorized_operations,
     rd_bool_t cgrp_update,
+    int32_t cgrp_subscription_version,
     rd_bool_t force_racks,
     rd_kafka_resp_cb_t *resp_cb,
     rd_kafka_replyq_t replyq,
@@ -631,6 +645,15 @@ rd_kafka_resp_err_t rd_kafka_ElectLeadersRequest(
     rd_kafka_resp_cb_t *resp_cb,
     void *opaque);
 
+rd_kafka_error_t *
+rd_kafka_ConsumerGroupDescribeRequest(rd_kafka_broker_t *rkb,
+                                      char **groups,
+                                      size_t group_cnt,
+                                      rd_bool_t include_authorized_operations,
+                                      rd_kafka_replyq_t replyq,
+                                      rd_kafka_resp_cb_t *resp_cb,
+                                      void *opaque);
+
 void rd_kafkap_leader_discovery_tmpabuf_add_alloc_brokers(
     rd_tmpabuf_t *tbuf,
     rd_kafkap_NodeEndpoints_t *NodeEndpoints);

package/deps/librdkafka/src/rdkafka_sasl.c

@@ -172,12 +172,14 @@ int rd_kafka_sasl_io_event(rd_kafka_transport_t *rktrans,
         r = rd_kafka_transport_framed_recv(rktrans, &rkbuf, errstr,
                                            errstr_size);
         if (r == -1) {
-                if (!strcmp(errstr, "Disconnected"))
-                        rd_snprintf(errstr, errstr_size,
-                                    "Disconnected: check client %s credentials "
+                if (rd_kafka_transport_error_disconnected(errstr)) {
+                        int curr_len = strlen(errstr);
+                        rd_snprintf(errstr + curr_len, errstr_size - curr_len,
+                                    ": check client %s credentials "
                                     "and broker logs",
                                     rktrans->rktrans_rkb->rkb_rk->rk_conf.sasl
                                         .mechanisms);
+                }
                 return -1;
         } else if (r == 0) /* not fully received yet */
                 return 0;

package/deps/librdkafka/src/rdkafka_sasl_oauthbearer.c

@@ -124,9 +124,10 @@ struct rd_kafka_sasl_oauthbearer_token {
  * @brief Per-connection state
  */
 struct rd_kafka_sasl_oauthbearer_state {
-        enum { RD_KAFKA_SASL_OAUTHB_STATE_SEND_CLIENT_FIRST_MESSAGE,
-               RD_KAFKA_SASL_OAUTHB_STATE_RECV_SERVER_FIRST_MSG,
-               RD_KAFKA_SASL_OAUTHB_STATE_RECV_SERVER_MSG_AFTER_FAIL,
+        enum {
+                RD_KAFKA_SASL_OAUTHB_STATE_SEND_CLIENT_FIRST_MESSAGE,
+                RD_KAFKA_SASL_OAUTHB_STATE_RECV_SERVER_FIRST_MSG,
+                RD_KAFKA_SASL_OAUTHB_STATE_RECV_SERVER_MSG_AFTER_FAIL,
         } state;
         char *server_error_msg;
 
@@ -1091,8 +1092,8 @@ static void rd_kafka_sasl_oauthbearer_build_client_first_message(
         buf          = out->ptr;
         size_written = 0;
         r            = rd_snprintf(buf, out->size + 1 - size_written,
-                        "%s%sauth=Bearer %s%s", gs2_header, kvsep,
-                        state->token_value, kvsep);
+                                   "%s%sauth=Bearer %s%s", gs2_header, kvsep,
+                                   state->token_value, kvsep);
         rd_assert(r < out->size + 1 - size_written);
         size_written += r;
         buf = out->ptr + size_written;
@@ -1255,8 +1256,13 @@ static int rd_kafka_sasl_oauthbearer_client_new(rd_kafka_transport_t *rktrans,
                 return -1;
         }
 
-        state->token_value       = rd_strdup(handle->token_value);
-        state->md_principal_name = rd_strdup(handle->md_principal_name);
+        state->token_value = rd_strdup(handle->token_value);
+        if (handle->md_principal_name)
+                state->md_principal_name = rd_strdup(handle->md_principal_name);
+        else
+                state->md_principal_name = NULL;
+
+        rd_list_init_copy(&state->extensions, &handle->extensions);
         rd_list_copy_to(&state->extensions, &handle->extensions,
                         rd_strtup_list_copy, NULL);
 
@@ -1332,13 +1338,11 @@ static int rd_kafka_sasl_oauthbearer_init(rd_kafka_t *rk,
 #if WITH_OAUTHBEARER_OIDC
         if (rk->rk_conf.sasl.oauthbearer.method ==
                 RD_KAFKA_SASL_OAUTHBEARER_METHOD_OIDC &&
-            rk->rk_conf.sasl.oauthbearer.token_refresh_cb ==
-                rd_kafka_oidc_token_refresh_cb) {
+            rk->rk_conf.sasl.oauthbearer.builtin_token_refresh_cb) {
                 handle->internal_refresh = rd_true;
                 rd_kafka_sasl_background_callbacks_enable(rk);
         }
 #endif
-
         /* Otherwise enqueue a refresh callback for the application. */
         rd_kafka_oauthbearer_enqueue_token_refresh(handle);