opal-up 0.0.4 → 0.0.5

data/ext/up_ext/WebSocketExtensions.h

@@ -21,14 +21,15 @@
 /* There is a new, huge bug scenario that needs to be fixed:
  * pub/sub does not support being in DEDICATED_COMPRESSOR-mode while having
  * some clients downgraded to SHARED_COMPRESSOR - we cannot allow the client to
- * demand a downgrade to SHARED_COMPRESSOR (yet) until we fix that scenario in pub/sub */
+ * demand a downgrade to SHARED_COMPRESSOR (yet) until we fix that scenario in
+ * pub/sub */
 // #define UWS_ALLOW_SHARED_AND_DEDICATED_COMPRESSOR_MIX
 
 /* We forbid negotiating 8 windowBits since Zlib has a bug with this */
 // #define UWS_ALLOW_8_WINDOW_BITS
 
-#include <climits>
 #include <cctype>
+#include <climits>
 #include <string>
 #include <string_view>
 #include <tuple>
@@ -36,221 +37,236 @@
 namespace uWS {
 
 enum ExtensionTokens {
-    /* Standard permessage-deflate tokens */
-    TOK_PERMESSAGE_DEFLATE = 1838,
-    TOK_SERVER_NO_CONTEXT_TAKEOVER = 2807,
-    TOK_CLIENT_NO_CONTEXT_TAKEOVER = 2783,
-    TOK_SERVER_MAX_WINDOW_BITS = 2372,
-    TOK_CLIENT_MAX_WINDOW_BITS = 2348,
-    /* Non-standard alias for Safari */
-    TOK_X_WEBKIT_DEFLATE_FRAME = 2149,
-    TOK_NO_CONTEXT_TAKEOVER = 2049,
-    TOK_MAX_WINDOW_BITS = 1614
+  /* Standard permessage-deflate tokens */
+  TOK_PERMESSAGE_DEFLATE = 1838,
+  TOK_SERVER_NO_CONTEXT_TAKEOVER = 2807,
+  TOK_CLIENT_NO_CONTEXT_TAKEOVER = 2783,
+  TOK_SERVER_MAX_WINDOW_BITS = 2372,
+  TOK_CLIENT_MAX_WINDOW_BITS = 2348,
+  /* Non-standard alias for Safari */
+  TOK_X_WEBKIT_DEFLATE_FRAME = 2149,
+  TOK_NO_CONTEXT_TAKEOVER = 2049,
+  TOK_MAX_WINDOW_BITS = 1614
 
 };
 
 struct ExtensionsParser {
 private:
-    int *lastInteger = nullptr;
+  int *lastInteger = nullptr;
 
 public:
-    /* Standard */
-    bool perMessageDeflate = false;
-    bool serverNoContextTakeover = false;
-    bool clientNoContextTakeover = false;
-    int serverMaxWindowBits = 0;
-    int clientMaxWindowBits = 0;
-
-    /* Non-standard Safari */
-    bool xWebKitDeflateFrame = false;
-    bool noContextTakeover = false;
-    int maxWindowBits = 0;
-
-    int getToken(const char *&in, const char *stop) {
-        while (in != stop && !isalnum(*in)) {
-            in++;
-        }
+  /* Standard */
+  bool perMessageDeflate = false;
+  bool serverNoContextTakeover = false;
+  bool clientNoContextTakeover = false;
+  int serverMaxWindowBits = 0;
+  int clientMaxWindowBits = 0;
+
+  /* Non-standard Safari */
+  bool xWebKitDeflateFrame = false;
+  bool noContextTakeover = false;
+  int maxWindowBits = 0;
+
+  int getToken(const char *&in, const char *stop) {
+    while (in != stop && !isalnum(*in)) {
+      in++;
+    }
 
-        /* Don't care more than this for now */
-        static_assert(SHRT_MIN > INT_MIN, "Integer overflow fix is invalid for this platform, report this as a bug!");
-
-        int hashedToken = 0;
-        while (in != stop && (isalnum(*in) || *in == '-' || *in == '_')) {
-            if (isdigit(*in)) {
-                /* This check is a quick and incorrect fix for integer overflow
-                 * in oss-fuzz but we don't care as it doesn't matter either way */
-                if (hashedToken > SHRT_MIN && hashedToken < SHRT_MAX) {
-                    hashedToken = hashedToken * 10 - (*in - '0');
-                }
-            } else {
-                hashedToken += *in;
-            }
-            in++;
+    /* Don't care more than this for now */
+    static_assert(SHRT_MIN > INT_MIN, "Integer overflow fix is invalid for "
+                                      "this platform, report this as a bug!");
+
+    int hashedToken = 0;
+    while (in != stop && (isalnum(*in) || *in == '-' || *in == '_')) {
+      if (isdigit(*in)) {
+        /* This check is a quick and incorrect fix for integer overflow
+         * in oss-fuzz but we don't care as it doesn't matter either way */
+        if (hashedToken > SHRT_MIN && hashedToken < SHRT_MAX) {
+          hashedToken = hashedToken * 10 - (*in - '0');
         }
-        return hashedToken;
+      } else {
+        hashedToken += *in;
+      }
+      in++;
     }
-
-    ExtensionsParser(const char *data, size_t length) {
-        const char *stop = data + length;
-        int token = 1;
-
-        /* Ignore anything before permessage-deflate or x-webkit-deflate-frame */
-        for (; token && token != TOK_PERMESSAGE_DEFLATE && token != TOK_X_WEBKIT_DEFLATE_FRAME; token = getToken(data, stop));
-
-        /* What protocol are we going to use? */
-        perMessageDeflate = (token == TOK_PERMESSAGE_DEFLATE);
-        xWebKitDeflateFrame = (token == TOK_X_WEBKIT_DEFLATE_FRAME);
-
-        while ((token = getToken(data, stop))) {
-            switch (token) {
-            case TOK_X_WEBKIT_DEFLATE_FRAME:
-                /* Duplicates not allowed/supported */
-                return;
-            case TOK_NO_CONTEXT_TAKEOVER:
-                noContextTakeover = true;
-                break;
-            case TOK_MAX_WINDOW_BITS:
-                maxWindowBits = 1;
-                lastInteger = &maxWindowBits;
-                break;
-            case TOK_PERMESSAGE_DEFLATE:
-                /* Duplicates not allowed/supported */
-                return;
-            case TOK_SERVER_NO_CONTEXT_TAKEOVER:
-                serverNoContextTakeover = true;
-                break;
-            case TOK_CLIENT_NO_CONTEXT_TAKEOVER:
-                clientNoContextTakeover = true;
-                break;
-            case TOK_SERVER_MAX_WINDOW_BITS:
-                serverMaxWindowBits = 1;
-                lastInteger = &serverMaxWindowBits;
-                break;
-            case TOK_CLIENT_MAX_WINDOW_BITS:
-                clientMaxWindowBits = 1;
-                lastInteger = &clientMaxWindowBits;
-                break;
-            default:
-                if (token < 0 && lastInteger) {
-                    *lastInteger = -token;
-                }
-                break;
-            }
+    return hashedToken;
+  }
+
+  ExtensionsParser(const char *data, size_t length) {
+    const char *stop = data + length;
+    int token = 1;
+
+    /* Ignore anything before permessage-deflate or x-webkit-deflate-frame */
+    for (; token && token != TOK_PERMESSAGE_DEFLATE &&
+           token != TOK_X_WEBKIT_DEFLATE_FRAME;
+         token = getToken(data, stop))
+      ;
+
+    /* What protocol are we going to use? */
+    perMessageDeflate = (token == TOK_PERMESSAGE_DEFLATE);
+    xWebKitDeflateFrame = (token == TOK_X_WEBKIT_DEFLATE_FRAME);
+
+    while ((token = getToken(data, stop))) {
+      switch (token) {
+      case TOK_X_WEBKIT_DEFLATE_FRAME:
+        /* Duplicates not allowed/supported */
+        return;
+      case TOK_NO_CONTEXT_TAKEOVER:
+        noContextTakeover = true;
+        break;
+      case TOK_MAX_WINDOW_BITS:
+        maxWindowBits = 1;
+        lastInteger = &maxWindowBits;
+        break;
+      case TOK_PERMESSAGE_DEFLATE:
+        /* Duplicates not allowed/supported */
+        return;
+      case TOK_SERVER_NO_CONTEXT_TAKEOVER:
+        serverNoContextTakeover = true;
+        break;
+      case TOK_CLIENT_NO_CONTEXT_TAKEOVER:
+        clientNoContextTakeover = true;
+        break;
+      case TOK_SERVER_MAX_WINDOW_BITS:
+        serverMaxWindowBits = 1;
+        lastInteger = &serverMaxWindowBits;
+        break;
+      case TOK_CLIENT_MAX_WINDOW_BITS:
+        clientMaxWindowBits = 1;
+        lastInteger = &clientMaxWindowBits;
+        break;
+      default:
+        if (token < 0 && lastInteger) {
+          *lastInteger = -token;
         }
+        break;
+      }
     }
+  }
 };
 
 /* Takes what we (the server) wants, returns what we got */
-static inline std::tuple<bool, int, int, std::string_view> negotiateCompression(bool wantCompression, int wantedCompressionWindow, int wantedInflationWindow, std::string_view offer) {
+static inline std::tuple<bool, int, int, std::string_view>
+negotiateCompression(bool wantCompression, int wantedCompressionWindow,
+                     int wantedInflationWindow, std::string_view offer) {
 
-    /* If we don't want compression then we are done here */
-    if (!wantCompression) {
-        return {false, 0, 0, ""};
-    }
+  /* If we don't want compression then we are done here */
+  if (!wantCompression) {
+    return {false, 0, 0, ""};
+  }
 
-    ExtensionsParser ep(offer.data(), offer.length());
+  ExtensionsParser ep(offer.data(), offer.length());
 
-    static thread_local std::string response;
-    response = "";
+  static thread_local std::string response;
+  response = "";
 
-    int compressionWindow = wantedCompressionWindow;
-    int inflationWindow = wantedInflationWindow;
-    bool compression = false;
+  int compressionWindow = wantedCompressionWindow;
+  int inflationWindow = wantedInflationWindow;
+  bool compression = false;
 
-    if (ep.xWebKitDeflateFrame) {
-        /* We now have compression */
-        compression = true;
-        response = "x-webkit-deflate-frame";
+  if (ep.xWebKitDeflateFrame) {
+    /* We now have compression */
+    compression = true;
+    response = "x-webkit-deflate-frame";
 
-        /* If the other peer has DEMANDED us no sliding window,
-         * we cannot compress with anything other than shared compressor */
-        if (ep.noContextTakeover) {
-            /* We must fail here right now (fix pub/sub) */
+    /* If the other peer has DEMANDED us no sliding window,
+     * we cannot compress with anything other than shared compressor */
+    if (ep.noContextTakeover) {
+      /* We must fail here right now (fix pub/sub) */
 #ifndef UWS_ALLOW_SHARED_AND_DEDICATED_COMPRESSOR_MIX
-            if (wantedCompressionWindow != 0) {
-                return {false, 0, 0, ""};
-            }
+      if (wantedCompressionWindow != 0) {
+        return {false, 0, 0, ""};
+      }
 #endif
 
-            compressionWindow = 0;
-        }
+      compressionWindow = 0;
+    }
 
-        /* If the other peer has DEMANDED us to use a limited sliding window,
-         * we have to limit out compression sliding window */
-        if (ep.maxWindowBits && ep.maxWindowBits < compressionWindow) {
-            compressionWindow = ep.maxWindowBits;
+    /* If the other peer has DEMANDED us to use a limited sliding window,
+     * we have to limit out compression sliding window */
+    if (ep.maxWindowBits && ep.maxWindowBits < compressionWindow) {
+      compressionWindow = ep.maxWindowBits;
 #ifndef UWS_ALLOW_8_WINDOW_BITS
-            /* We cannot really deny this, so we have to disable compression in this case */
-            if (compressionWindow == 8) {
-                return {false, 0, 0, ""};
-            }
+      /* We cannot really deny this, so we have to disable compression in this
+       * case */
+      if (compressionWindow == 8) {
+        return {false, 0, 0, ""};
+      }
 #endif
-        }
+    }
 
-        /* We decide our own inflation sliding window (and their compression sliding window) */
-        if (wantedInflationWindow < 15) {
-            if (!wantedInflationWindow) {
-                response += "; no_context_takeover";
-            } else {
-                response += "; max_window_bits=" + std::to_string(wantedInflationWindow);
-            }
-        }
-    } else if (ep.perMessageDeflate) {
-        /* We now have compression */
-        compression = true;
-        response = "permessage-deflate";
-
-        if (ep.clientNoContextTakeover) {
-            inflationWindow = 0;
-        } else if (ep.clientMaxWindowBits && ep.clientMaxWindowBits != 1) {
-            inflationWindow = std::min<int>(ep.clientMaxWindowBits, inflationWindow);
-        }
+    /* We decide our own inflation sliding window (and their compression sliding
+     * window) */
+    if (wantedInflationWindow < 15) {
+      if (!wantedInflationWindow) {
+        response += "; no_context_takeover";
+      } else {
+        response +=
+            "; max_window_bits=" + std::to_string(wantedInflationWindow);
+      }
+    }
+  } else if (ep.perMessageDeflate) {
+    /* We now have compression */
+    compression = true;
+    response = "permessage-deflate";
+
+    if (ep.clientNoContextTakeover) {
+      inflationWindow = 0;
+    } else if (ep.clientMaxWindowBits && ep.clientMaxWindowBits != 1) {
+      inflationWindow = std::min<int>(ep.clientMaxWindowBits, inflationWindow);
+    }
 
-        /* Whatever we have now, write */
-        if (inflationWindow < 15) {
-            if (!inflationWindow || !ep.clientMaxWindowBits) {
-                response += "; client_no_context_takeover";
-                inflationWindow = 0;
-            } else {
-                response += "; client_max_window_bits=" + std::to_string(inflationWindow);
-            }
-        }
+    /* Whatever we have now, write */
+    if (inflationWindow < 15) {
+      if (!inflationWindow || !ep.clientMaxWindowBits) {
+        response += "; client_no_context_takeover";
+        inflationWindow = 0;
+      } else {
+        response +=
+            "; client_max_window_bits=" + std::to_string(inflationWindow);
+      }
+    }
 
-        /* This block basically lets the client lower it */
-        if (ep.serverNoContextTakeover) {
-        /* This is an important (temporary) fix since we haven't allowed
-         * these two modes to mix, and pub/sub will not handle this case (yet) */
+    /* This block basically lets the client lower it */
+    if (ep.serverNoContextTakeover) {
+      /* This is an important (temporary) fix since we haven't allowed
+       * these two modes to mix, and pub/sub will not handle this case (yet) */
 #ifdef UWS_ALLOW_SHARED_AND_DEDICATED_COMPRESSOR_MIX
-            compressionWindow = 0;
+      compressionWindow = 0;
 #endif
-        } else if (ep.serverMaxWindowBits) {
-            compressionWindow = std::min<int>(ep.serverMaxWindowBits, compressionWindow);
+    } else if (ep.serverMaxWindowBits) {
+      compressionWindow =
+          std::min<int>(ep.serverMaxWindowBits, compressionWindow);
 #ifndef UWS_ALLOW_8_WINDOW_BITS
-            /* Zlib cannot do windowBits=8, memLevel=1 so we raise it up to 9 minimum */
-            if (compressionWindow == 8) {
-                compressionWindow = 9;
-            }
+      /* Zlib cannot do windowBits=8, memLevel=1 so we raise it up to 9 minimum
+       */
+      if (compressionWindow == 8) {
+        compressionWindow = 9;
+      }
 #endif
-        }
-
-        /* Whatever we have now, write */
-        if (compressionWindow < 15) {
-            if (!compressionWindow) {
-                response += "; server_no_context_takeover";
-            } else {
-                response += "; server_max_window_bits=" + std::to_string(compressionWindow);
-            }
-        }
     }
 
-    /* A final sanity check (this check does not actually catch too high values!) */
-    if ((compressionWindow && compressionWindow < 8) || compressionWindow > 15 || (inflationWindow && inflationWindow < 8) || inflationWindow > 15) {
-        return {false, 0, 0, ""};
+    /* Whatever we have now, write */
+    if (compressionWindow < 15) {
+      if (!compressionWindow) {
+        response += "; server_no_context_takeover";
+      } else {
+        response +=
+            "; server_max_window_bits=" + std::to_string(compressionWindow);
+      }
     }
+  }
 
-    return {compression, compressionWindow, inflationWindow, response};
-}
+  /* A final sanity check (this check does not actually catch too high values!)
+   */
+  if ((compressionWindow && compressionWindow < 8) || compressionWindow > 15 ||
+      (inflationWindow && inflationWindow < 8) || inflationWindow > 15) {
+    return {false, 0, 0, ""};
+  }
 
+  return {compression, compressionWindow, inflationWindow, response};
 }
 
+} // namespace uWS
+
 #endif // UWS_WEBSOCKETEXTENSIONS_H