From 5b4ff7a00067e2122cce8041b1368dbb34f34d73 Mon Sep 17 00:00:00 2001
From: Nishant Kumar <workynishant09@gmail.com>
Date: Sun, 24 Mar 2024 00:51:15 +0530
Subject: [PATCH] printing out response code and body

---
 lib/codegen/C/curl.dart              |  42 +-
 test/codegen/cCurl_codegen_test.dart | 756 +++++++++++++++++++++++++++
 2 files changed, 794 insertions(+), 4 deletions(-)

diff --git a/lib/codegen/C/curl.dart b/lib/codegen/C/curl.dart
index 266a2ba1..7019cfee 100644
--- a/lib/codegen/C/curl.dart
+++ b/lib/codegen/C/curl.dart
@@ -10,7 +10,27 @@ class cCurlCodeGen {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\\n\");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -54,11 +74,20 @@ int main() {
 """;
   String kTemplateQueryParam = """""";
 
-  String kTemplateRequest = """{% if method != "GET" and method != "POST" %}\n    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "{{method}}");{% endif %}""";
+  String kTemplateRequest =
+      """{% if method != "GET" and method != "POST" %}\n    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "{{method}}");{% endif %}""";
 
   final String kTemplateEnd = """
 {% if formdata %}curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);{% endif %}
-    res = curl_easy_perform(curl);{% if formdata %}\n    curl_mime_free(mime);{% endif %}{% if headers %}\n    curl_slist_free_all(headers);{% endif %}
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
+    res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\\n\", response_code);
+    printf("Response body: %s\\n\", response_data.data);
+    free(response_data.data);{% if formdata %}\n    curl_mime_free(mime);{% endif %}{% if headers %}\n    curl_slist_free_all(headers);{% endif %}
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -99,7 +128,10 @@ int main() {
       );
 
       var headersList = requestModel.enabledRequestHeaders;
-      if (headersList != null || requestModel.hasBody || requestModel.hasTextData || requestModel.hasJsonData) {
+      if (headersList != null ||
+          requestModel.hasBody ||
+          requestModel.hasTextData ||
+          requestModel.hasJsonData) {
         var headers = requestModel.enabledHeadersMap;
         // if (requestModel.hasFormData) {
         //   headers.putIfAbsent("Content-Type", () => "multipart/form-data");
@@ -144,7 +176,9 @@ int main() {
           }
         }
         var headers = requestModel.enabledHeadersMap;
-        bool allow = headers.isNotEmpty || requestModel.hasTextData || requestModel.hasJsonData;
+        bool allow = headers.isNotEmpty ||
+            requestModel.hasTextData ||
+            requestModel.hasJsonData;
         var templateEnd = jj.Template(kTemplateEnd);
         result += templateEnd.render({
           "formdata": requestModel.hasFormData,
diff --git a/test/codegen/cCurl_codegen_test.dart b/test/codegen/cCurl_codegen_test.dart
index 6f5b47cc..20023220 100644
--- a/test/codegen/cCurl_codegen_test.dart
+++ b/test/codegen/cCurl_codegen_test.dart
@@ -12,14 +12,42 @@ void main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
   curl = curl_easy_init();
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.apidash.dev");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -35,14 +63,42 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
   curl = curl_easy_init();
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.apidash.dev/country/data?code=US");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -58,14 +114,42 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
   curl = curl_easy_init();
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.apidash.dev/country/data?code=IND");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -81,14 +165,42 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
   curl = curl_easy_init();
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.apidash.dev/humanize/social?num=8700000&digits=3&system=SS&add_space=true&trailing_zeros=true");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -104,7 +216,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -115,7 +247,15 @@ int main() {
     headers = curl_slist_append(headers,"User-Agent: Test Agent");
   
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -132,7 +272,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -143,7 +303,15 @@ int main() {
     headers = curl_slist_append(headers,"User-Agent: Test Agent");
   
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -160,14 +328,42 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
   curl = curl_easy_init();
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.apidash.dev");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -183,7 +379,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -194,7 +410,15 @@ int main() {
     headers = curl_slist_append(headers,"User-Agent: Test Agent");
   
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -211,14 +435,42 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
   curl = curl_easy_init();
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.apidash.dev/humanize/social?num=8700000&add_space=true");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -234,7 +486,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -245,7 +517,15 @@ int main() {
     headers = curl_slist_append(headers,"User-Agent: Test Agent");
   
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -265,7 +545,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -276,7 +576,15 @@ int main() {
     headers = curl_slist_append(headers,"User-Agent: Test Agent");
   
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -293,14 +601,42 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
   curl = curl_easy_init();
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.apidash.dev/humanize/social");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -318,7 +654,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -326,7 +682,15 @@ int main() {
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "HEAD");
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.apidash.dev");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -342,7 +706,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -350,7 +734,15 @@ int main() {
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "HEAD");
     curl_easy_setopt(curl, CURLOPT_URL, "http://api.apidash.dev");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -368,7 +760,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -383,7 +795,15 @@ int main() {
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
     
 
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -400,7 +820,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -415,7 +855,15 @@ int main() {
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
     
 
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -432,7 +880,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -448,7 +916,15 @@ int main() {
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
     
 
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -465,7 +941,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -491,7 +987,15 @@ int main() {
     curl_mime_data(part, "3", CURL_ZERO_TERMINATED);
     
     curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_mime_free(mime);
   }
   curl_easy_cleanup(curl);
@@ -508,7 +1012,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -538,7 +1062,15 @@ int main() {
     curl_mime_data(part, "3", CURL_ZERO_TERMINATED);
     
     curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_mime_free(mime);
     curl_slist_free_all(headers);
   }
@@ -556,7 +1088,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -577,7 +1129,15 @@ int main() {
     curl_mime_filedata(part, "/Documents/up/1.png");
     
     curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_mime_free(mime);
   }
   curl_easy_cleanup(curl);
@@ -594,7 +1154,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -615,7 +1195,15 @@ int main() {
     curl_mime_filedata(part, "/Documents/up/1.png");
     
     curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_mime_free(mime);
   }
   curl_easy_cleanup(curl);
@@ -632,7 +1220,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -658,7 +1266,15 @@ int main() {
     curl_mime_data(part, "3", CURL_ZERO_TERMINATED);
     
     curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_mime_free(mime);
   }
   curl_easy_cleanup(curl);
@@ -675,7 +1291,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -701,7 +1337,15 @@ int main() {
     curl_mime_filedata(part, "/Documents/up/1.png");
     
     curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_mime_free(mime);
     curl_slist_free_all(headers);
   }
@@ -721,7 +1365,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -737,7 +1401,15 @@ int main() {
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
     
 
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -756,7 +1428,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -772,7 +1464,15 @@ int main() {
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
     
 
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);
@@ -791,7 +1491,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -799,7 +1519,15 @@ int main() {
   if(curl) {
     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
     curl_easy_setopt(curl, CURLOPT_URL, "https://reqres.in/api/users/2");
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
   }
   curl_easy_cleanup(curl);
   return 0;
@@ -815,7 +1543,27 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>
+struct ResponseData {
+    char *data;
+    size_t size;
+};
 
+size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
+    struct ResponseData *response_data = (struct ResponseData *)userdata;
+    size_t real_size = size * nmemb;
+
+    response_data->data = realloc(response_data->data, response_data->size + real_size + 1);
+    if (response_data->data == NULL) {
+        fprintf(stderr, "Memory allocation failed\n");
+        return 0;
+    }
+
+    memcpy(&(response_data->data[response_data->size]), ptr, real_size);
+    response_data->size += real_size;
+    response_data->data[response_data->size] = 0;
+
+    return real_size;
+}
 int main() {
   CURL *curl;
   CURLcode res;
@@ -831,7 +1579,15 @@ int main() {
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
     
 
+    struct ResponseData response_data = {0};
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);
     res = curl_easy_perform(curl);
+    long response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    printf("Response code: %ld\n", response_code);
+    printf("Response body: %s\n", response_data.data);
+    free(response_data.data);
     curl_slist_free_all(headers);
   }
   curl_easy_cleanup(curl);