Fix formatting in websocket_to_posix_proxy. NFC (#20255)

Author: sbc100

tools/websocket_to_posix_proxy/CMakeLists.txt

@@ -10,7 +10,7 @@ find_package(Threads)
 target_link_libraries(websocket_to_posix_proxy ${CMAKE_THREAD_LIBS_INIT})
 
 if (WIN32)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-	add_definitions(/wd4200) # "nonstandard extension used: zero-sized array in struct/union"
-	target_link_libraries(websocket_to_posix_proxy Ws2_32.lib)
+  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+  add_definitions(/wd4200) # "nonstandard extension used: zero-sized array in struct/union"
+  target_link_libraries(websocket_to_posix_proxy Ws2_32.lib)
 endif()

tools/websocket_to_posix_proxy/src/main.cpp

@@ -17,14 +17,12 @@
 // #define PROXY_DEEP_DEBUG
 
 static const unsigned char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-static void base64_encode(void *dst, const void *src, size_t len) // thread-safe, re-entrant
-{
+static void base64_encode(void *dst, const void *src, size_t len) { // thread-safe, re-entrant
   assert(dst != src);
   unsigned int *d = (unsigned int *)dst;
   const unsigned char *s = (const unsigned char*)src;
   const unsigned char *end = s + len;
-  while(s < end)
-  {
+  while (s < end) {
     uint32_t e = *s++ << 16;
     if (s < end) e |= *s++ << 8;
     if (s < end) e |= *s++;
@@ -37,23 +35,22 @@ static void base64_encode(void *dst, const void *src, size_t len) // thread-safe
 #define on_error(...) { fprintf(stderr, __VA_ARGS__); fflush(stderr); exit(1); }
 #define MIN(a, b) ((a) <= (b) ? (a) : (b))
 
-// Given a multiline string of HTTP headers, returns a pointer to the beginning of the value of given header inside the string that was passed in.
-static int GetHttpHeader(const char *headers, const char *header, char *out, int maxBytesOut) // thread-safe, re-entrant
-{
+// Given a multiline string of HTTP headers, returns a pointer to the beginning
+// of the value of given header inside the string that was passed in.
+static int GetHttpHeader(const char *headers, const char *header, char *out, int maxBytesOut) { // thread-safe, re-entrant
   const char *pos = strstr(headers, header);
   if (!pos) return 0;
   pos += strlen(header);
   const char *end = pos;
-  while(*end != '\r' && *end != '\n' && *end != '\0') ++end;
+  while (*end != '\r' && *end != '\n' && *end != '\0') ++end;
   int numBytesToWrite = MIN((int)(end-pos), maxBytesOut-1);
   memcpy(out, pos, numBytesToWrite);
   out[numBytesToWrite] = '\0';
   return (int)(end-pos);
 }
 
 // Sends WebSocket handshake back to the given WebSocket connection.
-void SendHandshake(int fd, const char *request)
-{
+void SendHandshake(int fd, const char *request) {
   const char webSocketGlobalGuid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; // 36 characters long
   char key[128+sizeof(webSocketGlobalGuid)];
   GetHttpHeader(request, "Sec-WebSocket-Key: ", key, sizeof(key)/2);
@@ -77,32 +74,30 @@ void SendHandshake(int fd, const char *request)
   printf("Sent handshake:\n%s\n", handshakeMsg);
 }
 
-// Validates if the given, possibly partially received WebSocket message has enough bytes to contain a full WebSocket header.
-static bool WebSocketHasFullHeader(uint8_t *data, uint64_t obtainedNumBytes)
-{
+// Validates if the given, possibly partially received WebSocket message has
+// enough bytes to contain a full WebSocket header.
+static bool WebSocketHasFullHeader(uint8_t *data, uint64_t obtainedNumBytes) {
   if (obtainedNumBytes < 2) return false;
   uint64_t expectedNumBytes = 2;
   WebSocketMessageHeader *header = (WebSocketMessageHeader *)data;
   if (header->mask) expectedNumBytes += 4;
-  switch(header->payloadLength)
-  {
+  switch (header->payloadLength) {
     case 127: return expectedNumBytes += 8; break;
     case 126: return expectedNumBytes += 2; break;
     default: break;
   }
   return obtainedNumBytes >= expectedNumBytes;
 }
 
-// Computes the total number of bytes that the given WebSocket message will take up.
-uint64_t WebSocketFullMessageSize(uint8_t *data, uint64_t obtainedNumBytes)
-{
+// Computes the total number of bytes that the given WebSocket message will take
+// up.
+uint64_t WebSocketFullMessageSize(uint8_t *data, uint64_t obtainedNumBytes) {
   assert(WebSocketHasFullHeader(data, obtainedNumBytes));
 
   uint64_t expectedNumBytes = 2;
   WebSocketMessageHeader *header = (WebSocketMessageHeader *)data;
   if (header->mask) expectedNumBytes += 4;
-  switch(header->payloadLength)
-  {
+  switch (header->payloadLength) {
     case 127: return expectedNumBytes += 8 + ntoh64(*(uint64_t*)(data+2)); break;
     case 126: return expectedNumBytes += 2 + ntohs(*(uint16_t*)(data+2)); break;
     default: expectedNumBytes += header->payloadLength; break;
@@ -111,74 +106,79 @@ uint64_t WebSocketFullMessageSize(uint8_t *data, uint64_t obtainedNumBytes)
 }
 
 // Tests the structure integrity of the websocket message length.
-bool WebSocketValidateMessageSize(uint8_t *data, uint64_t obtainedNumBytes)
-{
+bool WebSocketValidateMessageSize(uint8_t *data, uint64_t obtainedNumBytes) {
   uint64_t expectedNumBytes = WebSocketFullMessageSize(data, obtainedNumBytes);
 
-  if (expectedNumBytes != obtainedNumBytes)
-  {
+  if (expectedNumBytes != obtainedNumBytes) {
     printf("Corrupt WebSocket message size! (got %llu bytes, expected %llu bytes)\n", obtainedNumBytes, expectedNumBytes);
     printf("Received data:");
-    for(size_t i = 0; i < obtainedNumBytes; ++i)
+    for (size_t i = 0; i < obtainedNumBytes; ++i)
       printf(" %02X", data[i]);
     printf("\n");
   }
   return expectedNumBytes == obtainedNumBytes;
 }
 
-uint64_t WebSocketMessagePayloadLength(uint8_t *data, uint64_t numBytes)
-{
+uint64_t WebSocketMessagePayloadLength(uint8_t *data, uint64_t numBytes) {
   WebSocketMessageHeader *header = (WebSocketMessageHeader *)data;
-  switch(header->payloadLength)
-  {
+  switch (header->payloadLength) {
     case 127: return ntoh64(*(uint64_t*)(data+2));
     case 126: return ntohs(*(uint16_t*)(data+2));
     default: return header->payloadLength;
   }
 }
 
-uint32_t WebSocketMessageMaskingKey(uint8_t *data, uint64_t numBytes)
-{
+uint32_t WebSocketMessageMaskingKey(uint8_t *data, uint64_t numBytes) {
   WebSocketMessageHeader *header = (WebSocketMessageHeader *)data;
   if (!header->mask) return 0;
-  switch(header->payloadLength)
-  {
+  switch (header->payloadLength) {
     case 127: return *(uint32_t*)(data+10);
     case 126: return *(uint32_t*)(data+4);
     default: return *(uint32_t*)(data+2);
   }
 }
 
-uint8_t *WebSocketMessageData(uint8_t *data, uint64_t numBytes)
-{
+uint8_t *WebSocketMessageData(uint8_t *data, uint64_t numBytes) {
   WebSocketMessageHeader *header = (WebSocketMessageHeader *)data;
   data += 2; // Two bytes of fixed size header
   if (header->mask) data += 4; // If there is a masking key present in the header, that takes up 4 bytes
-  switch(header->payloadLength)
-  {
+  switch (header->payloadLength) {
     case 127: return data + 8; // 64-bit length
     case 126: return data + 2; // 16-bit length
     default: return data; // 7-bit length that was embedded in fixed size header.
   }
 }
 
-void CloseWebSocket(int client_fd)
-{
+void CloseWebSocket(int client_fd) {
   printf("Closing WebSocket connection %d\n", client_fd);
   CloseAllSocketsByConnection(client_fd);
   shutdown(client_fd, SHUTDOWN_BIDIRECTIONAL);
   CLOSE_SOCKET(client_fd);
 }
 
-const char *WebSocketOpcodeToString(int opcode)
-{
-  static const char *opcodes[] = { "continuation frame (0x0)", "text frame (0x1)", "binary frame (0x2)", "reserved(0x3)", "reserved(0x4)", "reserved(0x5)",
-    "reserved(0x6)", "reserved(0x7)", "connection close (0x8)", "ping (0x9)", "pong (0xA)", "reserved(0xB)", "reserved(0xC)", "reserved(0xD)", "reserved(0xE)", "reserved(0xF)" };
+const char *WebSocketOpcodeToString(int opcode) {
+  static const char *opcodes[] = {
+    "continuation frame (0x0)",
+    "text frame (0x1)",
+    "binary frame (0x2)",
+    "reserved(0x3)",
+    "reserved(0x4)",
+    "reserved(0x5)",
+    "reserved(0x6)",
+    "reserved(0x7)",
+    "connection close (0x8)",
+    "ping (0x9)",
+    "pong (0xA)",
+    "reserved(0xB)",
+    "reserved(0xC)",
+    "reserved(0xD)",
+    "reserved(0xE)",
+    "reserved(0xF)" 
+  };
   return opcodes[opcode];
 }
 
-void DumpWebSocketMessage(uint8_t *data, uint64_t numBytes)
-{
+void DumpWebSocketMessage(uint8_t *data, uint64_t numBytes) {
   bool goodMessageSize = WebSocketValidateMessageSize(data, numBytes);
   if (!goodMessageSize)
     return;
@@ -189,13 +189,11 @@ void DumpWebSocketMessage(uint8_t *data, uint64_t numBytes)
 
   printf("Received: FIN: %d, opcode: %s, mask: 0x%08X, payload length: %llu bytes, unmasked payload:", header->fin, WebSocketOpcodeToString(header->opcode),
     WebSocketMessageMaskingKey(data, numBytes), payloadLength);
-  for(uint64_t i = 0; i < payloadLength; ++i)
-  {
+  for (uint64_t i = 0; i < payloadLength; ++i) {
     if (i%16 == 0) printf("\n");
     if (i%8==0) printf(" ");
     printf(" %02X", payload[i]);
-    if (i >= 63 && payloadLength > 64)
-    {
+    if (i >= 63 && payloadLength > 64) {
       printf("\n   ... (%llu more bytes)", payloadLength-i);
       break;
     }
@@ -204,36 +202,33 @@ void DumpWebSocketMessage(uint8_t *data, uint64_t numBytes)
 }
 
 // connection thread manages a single active proxy connection.
-THREAD_RETURN_T connection_thread(void *arg)
-{
+THREAD_RETURN_T connection_thread(void *arg) {
   int client_fd = (int)(uintptr_t)arg;
-  printf("Established new proxy connection handler thread for incoming connection, at fd=%d\n", client_fd); // TODO: print out getpeername()+getsockname() for more info
+  // TODO: print out getpeername()+getsockname() for more info
+  printf("Established new proxy connection handler thread for incoming connection, at fd=%d\n", client_fd);
 
   // Waiting for connection upgrade handshake
   char buf[BUFFER_SIZE];
   int read = recv(client_fd, buf, BUFFER_SIZE, 0);
 
-  if (!read)
-  {
+  if (!read) {
     CloseWebSocket(client_fd);
     EXIT_THREAD(0);
   }
 
-  if (read < 0)
-  {
+  if (read < 0) {
     fprintf(stderr, "Client read failed\n");
     CloseWebSocket(client_fd);
     EXIT_THREAD(0);
   }
 
 #ifdef PROXY_DEEP_DEBUG
   printf("Received:");
-  for(int i = 0; i < read; ++i)
-  {
+  for (int i = 0; i < read; ++i) {
     printf(" %02X", buf[i]);
   }
   printf("\n");
-//  printf("In text:\n%s\n", buf);
+  //printf("In text:\n%s\n", buf);
 #endif
   SendHandshake(client_fd, buf);
 
@@ -244,21 +239,18 @@ THREAD_RETURN_T connection_thread(void *arg)
   std::vector<uint8_t> fragmentData;
 
   bool connectionAlive = true;
-  while (connectionAlive)
-  {
+  while (connectionAlive) {
     int read = recv(client_fd, buf, BUFFER_SIZE, 0);
 
     if (!read) break; // done reading
-    if (read < 0)
-    {
+    if (read < 0) {
       fprintf(stderr, "Client read failed\n");
       EXIT_THREAD(0);
     }
 
 #ifdef PROXY_DEEP_DEBUG
     printf("Received:");
-    for(int i = 0; i < read; ++i)
-    {
+    for (int i = 0; i < read; ++i) {
       printf(" %02X", ((unsigned char*)buf)[i]);
     }
     printf("\n");
@@ -271,19 +263,16 @@ THREAD_RETURN_T connection_thread(void *arg)
     fragmentData.insert(fragmentData.end(), buf, buf+read);
 
     // Process received fragments until there is not enough data for a full message
-    while(!fragmentData.empty())
-    {
+    while (!fragmentData.empty()) {
       bool hasFullHeader = WebSocketHasFullHeader(&fragmentData[0], fragmentData.size());
-      if (!hasFullHeader)
-      {
+      if (!hasFullHeader) {
 #ifdef PROXY_DEEP_DEBUG
         printf("(not enough for a full WebSocket header)\n");
 #endif
         break;
       }
       uint64_t neededBytes = WebSocketFullMessageSize(&fragmentData[0], fragmentData.size());
-      if (fragmentData.size() < neededBytes)
-      {
+      if (fragmentData.size() < neededBytes) {
 #ifdef PROXY_DEEP_DEBUG
         printf("(not enough for a full WebSocket message, needed %d bytes)\n", (int)neededBytes);
 #endif
@@ -302,8 +291,7 @@ THREAD_RETURN_T connection_thread(void *arg)
         DumpWebSocketMessage(&fragmentData[0], neededBytes);
 #endif
 
-      switch(header->opcode)
-      {
+      switch (header->opcode) {
       case 0x02: /*binary message*/ ProcessWebSocketMessage(client_fd, payload, payloadLength); break;
       case 0x08: connectionAlive = false; break;
       default:
@@ -323,22 +311,22 @@ THREAD_RETURN_T connection_thread(void *arg)
   EXIT_THREAD(0);
 }
 
-// Technically only would need one lock per connection, but this is now one lock per all connections, which would be
-// slightly inefficient if we were handling multiple proxied connections at the same time. (currently that is a rare
-// use case, expected to only be proxying one connection at a time - if this proxy bridge is expected to be used
-// for hundreds of connections simultaneously, this mutex should be refactored to be per-connection)
+// Technically only would need one lock per connection, but this is now one lock
+// per all connections, which would be slightly inefficient if we were handling
+// multiple proxied connections at the same time. (currently that is a rare use
+// case, expected to only be proxying one connection at a time - if this proxy
+// bridge is expected to be used for hundreds of connections simultaneously,
+// this mutex should be refactored to be per-connection)
 MUTEX_T webSocketSendLock;
 MUTEX_T socketRegistryLock;
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
   if (argc < 2) on_error("websocket_to_posix_proxy creates a bridge that allows WebSocket connections on a web page to proxy out to perform TCP/UDP connections.\nUsage: %s [port]\n", argv[0]);
 
 #ifdef _WIN32
   WSADATA wsaData;
   int failed = WSAStartup(MAKEWORD(2,2), &wsaData);
-  if (failed)
-  {
+  if (failed) {
     printf("WSAStartup failed: %d\n", failed);
     return 1;
   }
@@ -369,19 +357,16 @@ int main(int argc, char *argv[])
   CREATE_MUTEX(&webSocketSendLock);
   CREATE_MUTEX(&socketRegistryLock);
 
-  while (1)
-  {
+  while (1) {
     SOCKET_T client_fd = accept(server_fd, 0, 0);
-    if (client_fd < 0)
-    {
+    if (client_fd < 0) {
       fprintf(stderr, "Could not establish new incoming proxy connection\n");
       continue; // Do not quit here, but keep serving any existing proxy connections.
     }
 
     THREAD_T connection;
     CREATE_THREAD_RETURN_T ret = CREATE_THREAD(connection, connection_thread, (void*)(uintptr_t)client_fd);
-    if (!CREATE_THREAD_SUCCEEDED(ret))
-    {
+    if (!CREATE_THREAD_SUCCEEDED(ret)) {
       fprintf(stderr, "Failed to create a connection handler thread for incoming proxy connection!\n");
       continue; // Do not quit here, but keep program alive to manage other existing proxy connections.
     }

tools/websocket_to_posix_proxy/src/posix_sockets.h

@@ -42,14 +42,13 @@
 
 #define GET_SOCKET_ERROR() (WSAGetLastError())
 
-static inline void PRINT_SOCKET_ERROR(int errorCode)
-{
-	void *lpMsgBuf = 0;
-	HRESULT hresult = HRESULT_FROM_WIN32(errorCode);
-	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-		0, hresult, 0 /*Default language*/, (LPTSTR)&lpMsgBuf, 0, 0);
-	printf("Call failed! WSAGetLastError: %s(%d)\n", (char*)lpMsgBuf, errorCode);
-	LocalFree(lpMsgBuf);
+static inline void PRINT_SOCKET_ERROR(int errorCode) {
+  void *lpMsgBuf = 0;
+  HRESULT hresult = HRESULT_FROM_WIN32(errorCode);
+  FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+    0, hresult, 0 /*Default language*/, (LPTSTR)&lpMsgBuf, 0, 0);
+  printf("Call failed! WSAGetLastError: %s(%d)\n", (char*)lpMsgBuf, errorCode);
+  LocalFree(lpMsgBuf);
 }
 
 #endif