PR comments - #1

Author: anchitj

src/rd.h

@@ -438,4 +438,80 @@ typedef struct rd_chariov_s {
         size_t size;
 } rd_chariov_t;
 
+/**
+ * @brief Read a file in binary mode and return its contents.
+ *        The returned buffer is NULL-terminated if the file is text,
+ *        but the size parameter will contain the actual file size.
+ *
+ * @param file_path Path to the file to read
+ * @param size Pointer to store the file size (excluding NULL terminator if present)
+ * @param max_size Optional maximum file size to read (0 for no limit)
+ *
+ * @returns Newly allocated buffer containing the file contents.
+ *          NULL on error (file not found, too large, etc).
+ *          Caller must free with rd_free().
+ *
+ * @locality Any thread
+ */
+static RD_INLINE RD_UNUSED void *rd_read_file(const char *file_path,
+                                             size_t *size,
+                                             size_t max_size) {
+        FILE *file;
+        void *buf;
+        long file_size;
+        size_t read_size;
+
+        if (!file_path || !size) {
+                return NULL;
+        }
+
+        file = fopen(file_path, "rb");
+        if (!file) {
+                return NULL;
+        }
+
+        if (fseek(file, 0, SEEK_END) != 0) {
+                fclose(file);
+                return NULL;
+        }
+
+        file_size = ftell(file);
+        if (file_size < 0) {
+                fclose(file);
+                return NULL;
+        }
+
+        if (fseek(file, 0, SEEK_SET) != 0) {
+                fclose(file);
+                return NULL;
+        }
+
+        /* Check if file is too large */
+        if (max_size > 0 && (size_t)file_size > max_size) {
+                fclose(file);
+                return NULL;
+        }
+
+        /* Allocate buffer with extra byte for NULL terminator */
+        buf = rd_malloc(file_size + 1);
+        if (!buf) {
+                fclose(file);
+                return NULL;
+        }
+
+        read_size = fread(buf, 1, file_size, file);
+        fclose(file);
+
+        if (read_size != (size_t)file_size) {
+                rd_free(buf);
+                return NULL;
+        }
+
+        /* NULL terminate the buffer */
+        ((char *)buf)[file_size] = '\0';
+        *size = file_size;
+
+        return buf;
+}
+
 #endif /* _RD_H_ */

src/rdbase64.c

@@ -119,6 +119,36 @@ char *rd_base64_encode_str(const rd_chariov_t *in) {
         return out.ptr;
 }
 
+/**
+ * @brief Base64 encode binary input \p in and return a newly allocated,
+ *        base64-encoded string with URL-safe characters.
+ * @returns a newly allocated, base64-encoded string or NULL in case of some
+ *          issue with the conversion or the conversion is not supported.
+ *
+ * @remark Returned string must be freed after use.
+ */
+char *rd_base64_encode_str_urlsafe(const rd_chariov_t *in) {
+        rd_chariov_t out;
+        rd_base64_encode(in, &out);
+
+        /* Replace + with - and / with _ */
+        for (char *p = out.ptr; *p; p++) {
+                if (*p == '+')
+                        *p = '-';
+                else if (*p == '/')
+                        *p = '_';
+        }
+
+        /* Remove padding '=' characters */
+        int newlen = strlen(out.ptr);
+        while (newlen > 0 && out.ptr[newlen - 1] == '=') {
+                out.ptr[newlen - 1] = '\0';
+                newlen--;
+        }
+
+        out.size = newlen;
+        return out.ptr;
+}
 
 /**
  * @brief Base64 decode input string \p in. Ignores leading and trailing

src/rdbase64.h

@@ -36,6 +36,8 @@ void rd_base64_encode(const rd_chariov_t *in, rd_chariov_t *out);
 
 char *rd_base64_encode_str(const rd_chariov_t *in);
 
+char *rd_base64_encode_str_urlsafe(const rd_chariov_t *in);
+
 int rd_base64_decode(const rd_chariov_t *in, rd_chariov_t *out);
 
 #endif /* _RDBASE64_H_ */

src/rdkafka.c

@@ -2434,7 +2434,7 @@ rd_kafka_t *rd_kafka_new(rd_kafka_type_t type,
             !rk->rk_conf.sasl.oauthbearer.token_refresh_cb) {
                 /* Use JWT bearer */
                 if (rk->rk_conf.sasl.oauthbearer.grant_type ==
-                    RD_KAFKA_SASL_OAUTHBEARER_GRANT_TYPE_OIDC) {
+                    RD_KAFKA_SASL_OAUTHBEARER_GRANT_TYPE_CLIENT_CREDENTIALS) {
                         rd_kafka_conf_set_oauthbearer_token_refresh_cb(
                             &rk->rk_conf, rd_kafka_oidc_token_refresh_cb);
                 } else {