Chore: run clang-format

```bash
find . -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.hpp" \) ! -path "src/3rdparty/*" -print0 | xargs -0 clang-format -i
```

src/common/impl/networking_linux.c

@@ -16,132 +16,137 @@
 #include <errno.h>
 #include <fcntl.h>
 
-static const char* tryNonThreadingFastPath(FFNetworkingState* state)
-{
-    #if defined(TCP_FASTOPEN) || __APPLE__
+static const char* tryNonThreadingFastPath(FFNetworkingState* state) {
+#if defined(TCP_FASTOPEN) || __APPLE__
 
-        if (!state->tfo)
-        {
-            #if __linux__ || __GNU__
-            // Linux doesn't support sendto() on unconnected sockets
-            FF_DEBUG("TCP Fast Open disabled, skipping");
-            return "TCP Fast Open disabled";
-            #endif
-        }
-        else
-        {
-            FF_DEBUG("Attempting to use TCP Fast Open to connect");
+    if (!state->tfo) {
+#    if __linux__ || __GNU__
+        // Linux doesn't support sendto() on unconnected sockets
+        FF_DEBUG("TCP Fast Open disabled, skipping");
+        return "TCP Fast Open disabled";
+#    endif
+    } else {
+        FF_DEBUG("Attempting to use TCP Fast Open to connect");
 
-            #ifndef __APPLE__ // On macOS, TCP_FASTOPEN doesn't seem to be needed
-            // Set TCP Fast Open
-            int flag = 1;
-            if (setsockopt(state->sockfd, IPPROTO_TCP,
-                #ifdef __APPLE__
+#    ifndef __APPLE__ // On macOS, TCP_FASTOPEN doesn't seem to be needed
+        // Set TCP Fast Open
+        int flag = 1;
+        if (setsockopt(state->sockfd, IPPROTO_TCP,
+#        ifdef __APPLE__
                 // https://github.com/rust-lang/libc/pull/3135
                 0x218 // TCP_FASTOPEN_FORCE_ENABLE
-                #else
+#        else
                 TCP_FASTOPEN
-                #endif
-                , &flag, sizeof(flag)) != 0) {
-                FF_DEBUG("Failed to set TCP_FASTOPEN option: %s", strerror(errno));
-                return "setsockopt(TCP_FASTOPEN) failed";
-            } else {
-                #if __linux__ || __GNU__
-                FF_DEBUG("Successfully set TCP_FASTOPEN option, queue length: %d", flag);
-                #elif defined(__APPLE__)
-                FF_DEBUG("Successfully set TCP_FASTOPEN_FORCE_ENABLE option");
-                #else
-                FF_DEBUG("Successfully set TCP_FASTOPEN option");
-                #endif
-            }
-            #endif
+#        endif
+                ,
+                &flag,
+                sizeof(flag)) != 0) {
+            FF_DEBUG("Failed to set TCP_FASTOPEN option: %s", strerror(errno));
+            return "setsockopt(TCP_FASTOPEN) failed";
+        } else {
+#        if __linux__ || __GNU__
+            FF_DEBUG("Successfully set TCP_FASTOPEN option, queue length: %d", flag);
+#        elif defined(__APPLE__)
+            FF_DEBUG("Successfully set TCP_FASTOPEN_FORCE_ENABLE option");
+#        else
+            FF_DEBUG("Successfully set TCP_FASTOPEN option");
+#        endif
         }
+#    endif
+    }
 
-        #ifndef __APPLE__
-        FF_DEBUG("Using sendto() + MSG_DONTWAIT to send %u bytes of data", state->command.length);
-        ssize_t sent = sendto(state->sockfd,
-                                state->command.chars,
-                                state->command.length,
-            #ifdef MSG_FASTOPEN
-                                MSG_FASTOPEN |
-            #endif
-            #ifdef MSG_NOSIGNAL
-                                MSG_NOSIGNAL |
-            #endif
-                                MSG_DONTWAIT,
-                                state->addr->ai_addr,
-                                state->addr->ai_addrlen);
-        #else
-        if (fcntl(state->sockfd, F_SETFL, O_NONBLOCK) == -1) {
-            FF_DEBUG("fcntl(F_SETFL) failed: %s", strerror(errno));
-            return "fcntl(F_SETFL) failed";
-        }
-        FF_DEBUG("Using connectx() to send %u bytes of data", state->command.length);
-        // Use connectx to establish connection and send data in one call
-        size_t sent;
-        if (connectx(state->sockfd,
+#    ifndef __APPLE__
+    FF_DEBUG("Using sendto() + MSG_DONTWAIT to send %u bytes of data", state->command.length);
+    ssize_t sent = sendto(state->sockfd,
+        state->command.chars,
+        state->command.length,
+#        ifdef MSG_FASTOPEN
+        MSG_FASTOPEN |
+#        endif
+#        ifdef MSG_NOSIGNAL
+            MSG_NOSIGNAL |
+#        endif
+            MSG_DONTWAIT,
+        state->addr->ai_addr,
+        state->addr->ai_addrlen);
+#    else
+    if (fcntl(state->sockfd, F_SETFL, O_NONBLOCK) == -1) {
+        FF_DEBUG("fcntl(F_SETFL) failed: %s", strerror(errno));
+        return "fcntl(F_SETFL) failed";
+    }
+    FF_DEBUG("Using connectx() to send %u bytes of data", state->command.length);
+    // Use connectx to establish connection and send data in one call
+    size_t sent;
+    if (connectx(state->sockfd,
             &(sa_endpoints_t) {
                 .sae_dstaddr = state->addr->ai_addr,
                 .sae_dstaddrlen = state->addr->ai_addrlen,
             },
-            SAE_ASSOCID_ANY, state->tfo ? CONNECT_DATA_IDEMPOTENT : 0,
+            SAE_ASSOCID_ANY,
+            state->tfo ? CONNECT_DATA_IDEMPOTENT : 0,
             &(struct iovec) {
                 .iov_base = state->command.chars,
                 .iov_len = state->command.length,
-            }, 1, &sent, NULL) != 0) sent = 0;
-        if (fcntl(state->sockfd, F_SETFL, 0) == -1) {
-            FF_DEBUG("fcntl(F_SETFL) failed: %s", strerror(errno));
-            return "fcntl(F_SETFL) failed";
-        }
-        #endif
-        if (sent > 0 || (errno == EAGAIN || errno == EWOULDBLOCK
-            #ifdef __APPLE__
-            // On macOS EINPROGRESS means the connection cannot be completed immediately
-            // On Linux, it means the TFO cookie is not available locally
-            || errno == EINPROGRESS
-            #endif
-        ))
-        {
-            FF_DEBUG(
-                #ifdef __APPLE__
-                "connectx()"
-                #else
-                "sendto()"
-                #endif
-                " %s (sent=%zd, %s)", errno == 0 ? "succeeded" : "was in progress", sent, strerror(errno));
-            freeaddrinfo(state->addr);
-            state->addr = NULL;
-            ffStrbufDestroy(&state->command);
-            return NULL;
-        }
-
+            },
+            1,
+            &sent,
+            NULL) != 0) {
+        sent = 0;
+    }
+    if (fcntl(state->sockfd, F_SETFL, 0) == -1) {
+        FF_DEBUG("fcntl(F_SETFL) failed: %s", strerror(errno));
+        return "fcntl(F_SETFL) failed";
+    }
+#    endif
+    if (sent > 0 || (errno == EAGAIN || errno == EWOULDBLOCK
+#    ifdef __APPLE__
+                        // On macOS EINPROGRESS means the connection cannot be completed immediately
+                        // On Linux, it means the TFO cookie is not available locally
+                        || errno == EINPROGRESS
+#    endif
+                        )) {
         FF_DEBUG(
-            #ifdef __APPLE__
+#    ifdef __APPLE__
             "connectx()"
-            #else
+#    else
             "sendto()"
-            #endif
-            " failed: %s", strerror(errno));
-        #ifdef __APPLE__
-        return "connectx() failed";
-        #else
-        return "sendto() failed";
-        #endif
-    #else
-        FF_UNUSED(state);
-        return "TFO support is not available";
-    #endif
+#    endif
+            " %s (sent=%zd, %s)",
+            errno == 0 ? "succeeded" : "was in progress",
+            sent,
+            strerror(errno));
+        freeaddrinfo(state->addr);
+        state->addr = NULL;
+        ffStrbufDestroy(&state->command);
+        return NULL;
+    }
+
+    FF_DEBUG(
+#    ifdef __APPLE__
+        "connectx()"
+#    else
+        "sendto()"
+#    endif
+        " failed: %s",
+        strerror(errno));
+#    ifdef __APPLE__
+    return "connectx() failed";
+#    else
+    return "sendto() failed";
+#    endif
+#else
+    FF_UNUSED(state);
+    return "TFO support is not available";
+#endif
 }
 
 // Traditional connect and send function
-static const char* connectAndSend(FFNetworkingState* state)
-{
+static const char* connectAndSend(FFNetworkingState* state) {
     const char* ret = NULL;
     FF_DEBUG("Using traditional connection method to connect");
 
     FF_DEBUG("Attempting connect() to server...");
-    if(connect(state->sockfd, state->addr->ai_addr, state->addr->ai_addrlen) == -1)
-    {
+    if (connect(state->sockfd, state->addr->ai_addr, state->addr->ai_addrlen) == -1) {
         FF_DEBUG("connect() failed: %s", strerror(errno));
         ret = "connect() failed";
         goto error;
@@ -149,8 +154,7 @@ static const char* connectAndSend(FFNetworkingState* state)
     FF_DEBUG("connect() succeeded");
 
     FF_DEBUG("Attempting to send %u bytes of data...", state->command.length);
-    if(send(state->sockfd, state->command.chars, state->command.length, 0) < 0)
-    {
+    if (send(state->sockfd, state->command.chars, state->command.length, 0) < 0) {
         FF_DEBUG("send() failed: %s", strerror(errno));
         ret = "send() failed";
         goto error;
@@ -176,8 +180,7 @@ exit:
 FF_THREAD_ENTRY_DECL_WRAPPER(connectAndSend, FFNetworkingState*);
 
 // Parallel DNS resolution and socket creation
-static const char* initNetworkingState(FFNetworkingState* state, const char* host, const char* path, const char* headers)
-{
+static const char* initNetworkingState(FFNetworkingState* state, const char* host, const char* path, const char* headers) {
     FF_DEBUG("Initializing network connection state: host=%s, path=%s", host, path);
 
     // Initialize command and host information
@@ -197,25 +200,23 @@ static const char* initNetworkingState(FFNetworkingState* state, const char* hos
     ffStrbufAppendS(&state->command, headers);
     ffStrbufAppendS(&state->command, "\r\n");
 
-    #ifdef FF_HAVE_THREADS
+#ifdef FF_HAVE_THREADS
     state->thread = 0;
     FF_DEBUG("Thread ID initialized to 0");
-    #endif
+#endif
 
     const char* ret = NULL;
 
     struct addrinfo hints = {
         .ai_family = state->ipv6 ? AF_INET6 : AF_INET,
         .ai_socktype = SOCK_STREAM,
-        .ai_flags = AI_NUMERICSERV
-    };
+        .ai_flags = AI_NUMERICSERV};
 
     FF_DEBUG("Resolving address: %s (%s)", host, state->ipv6 ? "IPv6" : "IPv4");
     // Use AI_NUMERICSERV flag to indicate the service is a numeric port, reducing parsing time
 
     int gaiRes = getaddrinfo(host, "80", &hints, &state->addr);
-    if(gaiRes != 0)
-    {
+    if (gaiRes != 0) {
         FF_DEBUG("getaddrinfo() failed: %s (res=%d)", gai_strerror(gaiRes), gaiRes);
         ret = "getaddrinfo() failed";
         goto error;
@@ -224,8 +225,7 @@ static const char* initNetworkingState(FFNetworkingState* state, const char* hos
 
     FF_DEBUG("Creating socket");
     state->sockfd = socket(state->addr->ai_family, state->addr->ai_socktype, state->addr->ai_protocol);
-    if(state->sockfd == -1)
-    {
+    if (state->sockfd == -1) {
         FF_DEBUG("socket() failed: %s", strerror(errno));
         ret = "socket() failed";
         goto error;
@@ -233,57 +233,56 @@ static const char* initNetworkingState(FFNetworkingState* state, const char* hos
     FF_DEBUG("Socket creation successful: fd=%d", state->sockfd);
 
     int flag = 1;
-    #ifdef TCP_NODELAY
+#ifdef TCP_NODELAY
     // Disable Nagle's algorithm to reduce small packet transmission delay
     if (setsockopt(state->sockfd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag)) != 0) {
         FF_DEBUG("Failed to set TCP_NODELAY: %s", strerror(errno));
     } else {
         FF_DEBUG("Successfully disabled Nagle's algorithm");
     }
-    #endif
+#endif
 
-    #ifdef TCP_QUICKACK
+#ifdef TCP_QUICKACK
     // Set TCP_QUICKACK option to avoid delayed acknowledgments
     if (setsockopt(state->sockfd, IPPROTO_TCP, TCP_QUICKACK, &flag, sizeof(flag)) != 0) {
         FF_DEBUG("Failed to set TCP_QUICKACK: %s", strerror(errno));
     } else {
         FF_DEBUG("Successfully enabled TCP quick acknowledgment");
     }
-    #endif
+#endif
 
-    if (state->timeout > 0)
-    {
+    if (state->timeout > 0) {
         FF_DEBUG("Setting connection timeout: %u ms", state->timeout);
         FF_MAYBE_UNUSED uint32_t sec = state->timeout / 1000;
-        if (sec == 0) sec = 1;
+        if (sec == 0) {
+            sec = 1;
+        }
 
-        #ifdef TCP_CONNECTIONTIMEOUT
+#ifdef TCP_CONNECTIONTIMEOUT
         FF_DEBUG("Using TCP_CONNECTIONTIMEOUT: %u seconds", sec);
         setsockopt(state->sockfd, IPPROTO_TCP, TCP_CONNECTIONTIMEOUT, &sec, sizeof(sec));
-        #elif defined(TCP_KEEPINIT)
+#elif defined(TCP_KEEPINIT)
         FF_DEBUG("Using TCP_KEEPINIT: %u seconds", sec);
         setsockopt(state->sockfd, IPPROTO_TCP, TCP_KEEPINIT, &sec, sizeof(sec));
-        #elif defined(TCP_USER_TIMEOUT)
+#elif defined(TCP_USER_TIMEOUT)
         FF_DEBUG("Using TCP_USER_TIMEOUT: %u milliseconds", state->timeout);
         setsockopt(state->sockfd, IPPROTO_TCP, TCP_USER_TIMEOUT, &state->timeout, sizeof(state->timeout));
-        #else
+#else
         FF_DEBUG("Current platform does not support TCP connection timeout");
-        #endif
+#endif
     }
 
     return NULL;
 
 error:
     FF_DEBUG("Error occurred during initialization");
-    if (state->addr != NULL)
-    {
+    if (state->addr != NULL) {
         FF_DEBUG("Releasing address information");
         freeaddrinfo(state->addr);
         state->addr = NULL;
     }
 
-    if (state->sockfd > 0)
-    {
+    if (state->sockfd > 0) {
         FF_DEBUG("Closing socket: fd=%d", state->sockfd);
         close(state->sockfd);
         state->sockfd = -1;
@@ -291,31 +290,26 @@ error:
     return ret;
 }
 
-const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
-{
+const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers) {
     FF_DEBUG("Preparing to send HTTP request: host=%s, path=%s", host, path);
 
-    if (state->compression)
-    {
+    if (state->compression) {
         FF_DEBUG("Compression enabled, checking if zlib is available");
 
-        #ifdef FF_HAVE_ZLIB
+#ifdef FF_HAVE_ZLIB
         const char* zlibError = ffNetworkingLoadZlibLibrary();
         // Only enable compression if zlib library is successfully loaded
-        if (zlibError == NULL)
-        {
+        if (zlibError == NULL) {
             FF_DEBUG("Successfully loaded zlib library, compression enabled");
         } else {
             FF_DEBUG("Failed to load zlib library, compression disabled: %s", zlibError);
             state->compression = false;
         }
-        #else
+#else
         FF_DEBUG("zlib not supported at build time, compression disabled");
         state->compression = false;
-        #endif
-    }
-    else
-    {
+#endif
+    } else {
         FF_DEBUG("Compression disabled");
     }
 
@@ -333,33 +327,30 @@ const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* ho
     }
     FF_DEBUG("TryNonThreadingFastPath() failed: %s, trying traditional connection", tfoResult);
 
-    #ifdef FF_HAVE_THREADS
-    if (instance.config.general.multithreading)
-    {
+#ifdef FF_HAVE_THREADS
+    if (instance.config.general.multithreading) {
         FF_DEBUG("Multithreading mode enabled, creating connection thread");
         state->thread = ffThreadCreate(connectAndSendThreadMain, state);
         if (state->thread) {
-            FF_DEBUG("Thread creation successful: thread=%p", (void*)(uintptr_t)state->thread);
+            FF_DEBUG("Thread creation successful: thread=%p", (void*) (uintptr_t) state->thread);
             return NULL;
         }
         FF_DEBUG("Thread creation failed");
     } else {
         FF_DEBUG("Multithreading mode disabled, connecting in main thread");
     }
-    #endif
+#endif
 
     return connectAndSend(state);
 }
 
-const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer)
-{
+const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer) {
     assert(buffer->allocated > 0);
     FF_DEBUG("Preparing to receive HTTP response");
     uint32_t timeout = state->timeout;
 
-    #ifdef FF_HAVE_THREADS
-    if (state->thread)
-    {
+#ifdef FF_HAVE_THREADS
+    if (state->thread) {
         FF_DEBUG("Connection thread is running, waiting for it to complete (timeout=%u ms)", timeout);
         if (!ffThreadJoin(state->thread, timeout)) {
             FF_DEBUG("Thread join failed or timed out");
@@ -368,10 +359,9 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
         FF_DEBUG("Thread completed successfully");
         state->thread = 0;
     }
-    #endif
+#endif
 
-    if(state->sockfd == -1)
-    {
+    if (state->sockfd == -1) {
         FF_DEBUG("Invalid socket, HTTP request might have failed");
         return "ffNetworkingSendHttpRequest() failed";
     }
@@ -380,24 +370,22 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
     int rcvbuf = 65536; // 64KB
     setsockopt(state->sockfd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));
 
-    #ifdef __APPLE__
+#ifdef __APPLE__
     // poll for the socket to be readable.
     // Because of the non-blocking connectx() call, the connection might not be established yet
     FF_DEBUG("Using poll() to check if socket is readable");
     {
         int pollRes = poll(&(struct pollfd) {
-            .fd = state->sockfd,
-            .events = POLLIN
-        }, 1, timeout > 0 ? (int) timeout : -1);
-        if (pollRes == 0)
-        {
+                               .fd = state->sockfd,
+                               .events = POLLIN},
+            1,
+            timeout > 0 ? (int) timeout : -1);
+        if (pollRes == 0) {
             FF_DEBUG("poll() timed out after %u ms", timeout);
             close(state->sockfd);
             state->sockfd = -1;
             return "poll() timeout";
-        }
-        else if (pollRes == -1)
-        {
+        } else if (pollRes == -1) {
             FF_DEBUG("poll() failed: %s", strerror(errno));
             close(state->sockfd);
             state->sockfd = -1;
@@ -405,19 +393,17 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
         }
     }
     FF_DEBUG("Socket is readable, proceeding to receive data");
-    #else
-    if(timeout > 0)
-    {
+#else
+    if (timeout > 0) {
         FF_DEBUG("Setting receive timeout: %u ms", timeout);
         struct timeval timev;
         timev.tv_sec = timeout / 1000;
-        timev.tv_usec = (__typeof__(timev.tv_usec)) ((timeout % 1000) * 1000); //milliseconds to microseconds
+        timev.tv_usec = (__typeof__(timev.tv_usec)) ((timeout % 1000) * 1000); // milliseconds to microseconds
         setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
     }
-    #endif
+#endif
 
-    if (shutdown(state->sockfd, SHUT_WR) == -1)
-    {
+    if (shutdown(state->sockfd, SHUT_WR) == -1) {
         FF_DEBUG("Failed to shutdown socket send: %s", strerror(errno));
         // Not a critical error, continue anyway
     }
@@ -429,7 +415,9 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
 
     do {
         FF_DEBUG("Data reception loop #%d, current buffer size: %u, available space: %u",
-                 ++recvCount, buffer->length, ffStrbufGetFree(buffer));
+            ++recvCount,
+            buffer->length,
+            ffStrbufGetFree(buffer));
 
         // We set `Connection: close`, so the server will close the connection when done.
         // Thus we can use MSG_WAITALL to wait until the buffer is full or the connection is closed.
@@ -453,7 +441,7 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
         if (headerEnd == 0) {
             char* pHeaderEnd = memmem(buffer->chars, buffer->length, "\r\n\r\n", 4);
             if (pHeaderEnd) {
-                headerEnd = (uint32_t)(pHeaderEnd - buffer->chars);
+                headerEnd = (uint32_t) (pHeaderEnd - buffer->chars);
                 FF_DEBUG("Found HTTP header end marker, position: %u", headerEnd);
 
                 // Check for Content-Length header to pre-allocate enough memory
@@ -496,8 +484,8 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
         return "Invalid response";
     }
 
-    // If compression was used, try to decompress
-    #ifdef FF_HAVE_ZLIB
+// If compression was used, try to decompress
+#ifdef FF_HAVE_ZLIB
     if (state->compression) {
         FF_DEBUG("Content received, checking if compressed");
         if (!ffNetworkingDecompressGzip(buffer, buffer->chars + headerEnd)) {
@@ -507,7 +495,7 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
             FF_DEBUG("Decompression successful or no decompression needed, total length after decompression: %u bytes", buffer->length);
         }
     }
-    #endif
+#endif
 
     return NULL;
 }