Websocket frame encoder (#36)

Author: graebm

include/aws/http/http.h

@@ -23,11 +23,11 @@
 enum aws_http_errors {
     AWS_ERROR_HTTP_UNKNOWN = 0x0800,
     AWS_ERROR_HTTP_PARSE,
-    AWS_ERROR_HTTP_INVALID_PARSE_STATE,
     AWS_ERROR_HTTP_CONNECTION_CLOSED,
     AWS_ERROR_HTTP_UNSUPPORTED_PROTOCOL,
     AWS_ERROR_HTTP_REACTION_REQUIRED,
     AWS_ERROR_HTTP_DATA_NOT_AVAILABLE,
+    AWS_ERROR_HTTP_OUTGOING_STREAM_LENGTH_INCORRECT,
     AWS_ERROR_HTTP_END_RANGE = 0x0C00,
 };
 

include/aws/http/private/websocket_decoder.h

@@ -16,28 +16,7 @@
  * permissions and limitations under the License.
  */
 
-#include <aws/http/http.h>
-
-enum aws_websocket_opcode {
-    AWS_WEBSOCKET_OPCODE_CONTINUATION = 0x0,
-    AWS_WEBSOCKET_OPCODE_TEXT = 0x1,
-    AWS_WEBSOCKET_OPCODE_DATA = 0x2,
-    AWS_WEBSOCKET_OPCODE_CLOSE = 0x8,
-    AWS_WEBSOCKET_OPCODE_PING = 0x9,
-    AWS_WEBSOCKET_OPCODE_PONG = 0xA,
-};
-
-/**
- * Full contents of a websocket frame, excluding the payload.
- */
-struct aws_websocket_frame {
-    bool fin;
-    bool rsv[3];
-    bool masked;
-    uint8_t opcode;
-    uint64_t payload_length;
-    uint8_t masking_key[4];
-};
+#include <aws/http/private/websocket_impl.h>
 
 /* Called when the non-payload portion of a frame has been decoded. */
 typedef int(aws_websocket_decoder_frame_fn)(const struct aws_websocket_frame *frame, void *user_data);
@@ -67,21 +46,13 @@ struct aws_websocket_decoder {
 
     struct aws_websocket_frame current_frame; /* Data about current frame being decoded */
 
-    bool expecting_continuation_data_frames; /* True when the next data frame must be CONTINUATION frame */
+    bool expecting_continuation_data_frame; /* True when the next data frame must be CONTINUATION frame */
 
     void *user_data;
     aws_websocket_decoder_frame_fn *on_frame;
     aws_websocket_decoder_payload_fn *on_payload;
 };
 
-/**
- * Return true if opcode is for a data frame, false if opcode if for a control frame.
- */
-AWS_STATIC_IMPL
-bool aws_websocket_is_data_frame(uint8_t opcode) {
-    return !(opcode & 0x08); /* RFC-6455 Section 5.6: Most significant bit of (4 bit) data frame opcode is 0 */
-}
-
 AWS_EXTERN_C_BEGIN
 
 AWS_HTTP_API

include/aws/http/private/websocket_encoder.h

@@ -0,0 +1,67 @@
+#ifndef AWS_HTTP_WEBSOCKET_ENCODER_H
+#define AWS_HTTP_WEBSOCKET_ENCODER_H
+
+/*
+ * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+#include <aws/http/private/websocket_impl.h>
+
+typedef int(aws_websocket_encoder_payload_fn)(struct aws_byte_buf *out_buf, bool *out_done, void *user_data);
+
+enum aws_websocket_encoder_state {
+    AWS_WEBSOCKET_ENCODER_STATE_INIT,
+    AWS_WEBSOCKET_ENCODER_STATE_OPCODE_BYTE,
+    AWS_WEBSOCKET_ENCODER_STATE_LENGTH_BYTE,
+    AWS_WEBSOCKET_ENCODER_STATE_EXTENDED_LENGTH,
+    AWS_WEBSOCKET_ENCODER_STATE_MASKING_KEY_CHECK,
+    AWS_WEBSOCKET_ENCODER_STATE_MASKING_KEY,
+    AWS_WEBSOCKET_ENCODER_STATE_PAYLOAD_CHECK,
+    AWS_WEBSOCKET_ENCODER_STATE_PAYLOAD,
+    AWS_WEBSOCKET_ENCODER_STATE_DONE,
+};
+
+struct aws_websocket_encoder {
+    enum aws_websocket_encoder_state state;
+    uint64_t state_bytes_processed;
+    struct aws_websocket_frame frame;
+    bool is_frame_in_progress;
+
+    /* True when the next data frame must be a CONTINUATION frame */
+    bool expecting_continuation_data_frame;
+
+    void *user_data;
+    aws_websocket_encoder_payload_fn *stream_outgoing_payload;
+};
+
+AWS_EXTERN_C_BEGIN
+
+AWS_HTTP_API
+void aws_websocket_encoder_init(
+    struct aws_websocket_encoder *encoder,
+    aws_websocket_encoder_payload_fn *stream_outgoing_payload,
+    void *user_data);
+
+AWS_HTTP_API
+int aws_websocket_encoder_start_frame(struct aws_websocket_encoder *encoder, const struct aws_websocket_frame *frame);
+
+AWS_HTTP_API
+bool aws_websocket_encoder_is_frame_in_progress(const struct aws_websocket_encoder *encoder);
+
+AWS_HTTP_API
+int aws_websocket_encoder_process(struct aws_websocket_encoder *encoder, struct aws_byte_buf *out_buf);
+
+AWS_EXTERN_C_END
+
+#endif /* AWS_HTTP_WEBSOCKET_ENCODER_H */

include/aws/http/private/websocket_impl.h

@@ -0,0 +1,76 @@
+#ifndef AWS_HTTP_WEBSOCKET_IMPL_H
+#define AWS_HTTP_WEBSOCKET_IMPL_H
+
+/*
+ * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+#include <aws/http/http.h>
+
+enum aws_websocket_opcode {
+    AWS_WEBSOCKET_OPCODE_CONTINUATION = 0x0,
+    AWS_WEBSOCKET_OPCODE_TEXT = 0x1,
+    AWS_WEBSOCKET_OPCODE_BINARY = 0x2,
+    AWS_WEBSOCKET_OPCODE_CLOSE = 0x8,
+    AWS_WEBSOCKET_OPCODE_PING = 0x9,
+    AWS_WEBSOCKET_OPCODE_PONG = 0xA,
+};
+
+/* RFC-6455 Section 5.2 Base Framing Protocol
+ * Payload length:  7 bits, 7+16 bits, or 7+64 bits
+ *
+ * The length of the "Payload data", in bytes: if 0-125, that is the
+ * payload length.  If 126, the following 2 bytes interpreted as a
+ * 16-bit unsigned integer are the payload length.  If 127, the
+ * following 8 bytes interpreted as a 64-bit unsigned integer (the
+ * most significant bit MUST be 0) are the payload length.  Multibyte
+ * length quantities are expressed in network byte order.  Note that
+ * in all cases, the minimal number of bytes MUST be used to encode
+ * the length, for example, the length of a 124-byte-long string
+ * can't be encoded as the sequence 126, 0, 124.  The payload length
+ * is the length of the "Extension data" + the length of the
+ * "Application data".  The length of the "Extension data" may be
+ * zero, in which case the payload length is the length of the
+ * "Application data".
+ */
+#define AWS_WEBSOCKET_7BIT_VALUE_FOR_2BYTE_EXTENDED_LENGTH 126
+#define AWS_WEBSOCKET_7BIT_VALUE_FOR_8BYTE_EXTENDED_LENGTH 127
+
+#define AWS_WEBSOCKET_2BYTE_EXTENDED_LENGTH_MIN_VALUE AWS_WEBSOCKET_7BIT_VALUE_FOR_2BYTE_EXTENDED_LENGTH
+#define AWS_WEBSOCKET_2BYTE_EXTENDED_LENGTH_MAX_VALUE 0x000000000000FFFF
+
+#define AWS_WEBSOCKET_8BYTE_EXTENDED_LENGTH_MIN_VALUE 0x0000000000010000
+#define AWS_WEBSOCKET_8BYTE_EXTENDED_LENGTH_MAX_VALUE 0x7FFFFFFFFFFFFFFF
+
+/**
+ * Full contents of a websocket frame, excluding the payload.
+ */
+struct aws_websocket_frame {
+    bool fin;
+    bool rsv[3];
+    bool masked;
+    uint8_t opcode;
+    uint64_t payload_length;
+    uint8_t masking_key[4];
+};
+
+/**
+ * Return true if opcode is for a data frame, false if opcode if for a control frame.
+ */
+AWS_STATIC_IMPL
+bool aws_websocket_is_data_frame(uint8_t opcode) {
+    return !(opcode & 0x08); /* RFC-6455 Section 5.6: Most significant bit of (4 bit) data frame opcode is 0 */
+}
+
+#endif /* AWS_HTTP_WEBSOCKET_IMPL_H */

source/connection_h1.c

@@ -1297,7 +1297,7 @@ static int s_handler_process_read_message(
                 "connection.",
                 (void *)&connection->base);
 
-            aws_raise_error(AWS_ERROR_HTTP_INVALID_PARSE_STATE);
+            aws_raise_error(AWS_ERROR_INVALID_STATE);
             goto error;
         }
 

source/http.c

@@ -37,9 +37,6 @@ static struct aws_error_info s_errors[] = {
     AWS_DEFINE_ERROR_INFO_HTTP(
         AWS_ERROR_HTTP_PARSE,
         "Encountered an unexpected form when parsing an http message."),
-    AWS_DEFINE_ERROR_INFO_HTTP(
-        AWS_ERROR_HTTP_INVALID_PARSE_STATE,
-        "Decoding/parsing was ran while the decoder object was in a poor state -- make sure to properly check for error codes before running the decoder."),
     AWS_DEFINE_ERROR_INFO_HTTP(
         AWS_ERROR_HTTP_UNSUPPORTED_PROTOCOL,
         "An unsupported protocol was encountered."),
@@ -55,6 +52,9 @@ static struct aws_error_info s_errors[] = {
     AWS_DEFINE_ERROR_INFO_HTTP(
         AWS_ERROR_HTTP_CONNECTION_CLOSED,
         "Message not sent, as the connection has closed."),
+    AWS_DEFINE_ERROR_INFO_HTTP(
+        AWS_ERROR_HTTP_OUTGOING_STREAM_LENGTH_INCORRECT,
+        "Amount of data streamed out does not match the previously declared length."),
 };
 /* clang-format on */
 

source/websocket_decoder.c

@@ -15,9 +15,7 @@
 
 #include <aws/http/private/websocket_decoder.h>
 
-/* If 7bit payload length has these values, then the next few bytes contain the real payload length */
-#define VALUE_FOR_2BYTE_EXTENDED_LENGTH 126
-#define VALUE_FOR_8BYTE_EXTENDED_LENGTH 127
+/* TODO: decoder logging */
 
 typedef int(state_fn)(struct aws_websocket_decoder *decoder, struct aws_byte_cursor *data);
 
@@ -47,6 +45,20 @@ static int s_state_opcode_byte(struct aws_websocket_decoder *decoder, struct aws
     /* next 4 bits are opcode */
     decoder->current_frame.opcode = byte & 0x0F;
 
+    /* RFC-6455 Section 5.2 - Opcode
+     * If an unknown opcode is received, the receiving endpoint MUST _Fail the WebSocket Connection_. */
+    switch (decoder->current_frame.opcode) {
+        case AWS_WEBSOCKET_OPCODE_CONTINUATION:
+        case AWS_WEBSOCKET_OPCODE_TEXT:
+        case AWS_WEBSOCKET_OPCODE_BINARY:
+        case AWS_WEBSOCKET_OPCODE_CLOSE:
+        case AWS_WEBSOCKET_OPCODE_PING:
+        case AWS_WEBSOCKET_OPCODE_PONG:
+            break;
+        default:
+            return aws_raise_error(AWS_ERROR_HTTP_PARSE);
+    }
+
     /* RFC-6455 Section 5.2 Fragmentation
      *
      * Data frames with the FIN bit clear are considered fragmented and must be followed by
@@ -58,11 +70,11 @@ static int s_state_opcode_byte(struct aws_websocket_decoder *decoder, struct aws
     if (aws_websocket_is_data_frame(decoder->current_frame.opcode)) {
         bool is_continuation_frame = AWS_WEBSOCKET_OPCODE_CONTINUATION == decoder->current_frame.opcode;
 
-        if (decoder->expecting_continuation_data_frames != is_continuation_frame) {
+        if (decoder->expecting_continuation_data_frame != is_continuation_frame) {
             return aws_raise_error(AWS_ERROR_HTTP_PARSE);
         }
 
-        decoder->expecting_continuation_data_frames = !decoder->current_frame.fin;
+        decoder->expecting_continuation_data_frame = !decoder->current_frame.fin;
 
     } else {
         /* Control frames themselves MUST NOT be fragmented. */
@@ -90,7 +102,7 @@ static int s_state_length_byte(struct aws_websocket_decoder *decoder, struct aws
     /* remaining 7 bits are payload length */
     decoder->current_frame.payload_length = byte & 0x7F;
 
-    if (decoder->current_frame.payload_length >= VALUE_FOR_2BYTE_EXTENDED_LENGTH) {
+    if (decoder->current_frame.payload_length >= AWS_WEBSOCKET_7BIT_VALUE_FOR_2BYTE_EXTENDED_LENGTH) {
         /* If 7bit payload length has a high value, then the next few bytes contain the real payload length */
         decoder->state_bytes_processed = 0;
         decoder->state = AWS_WEBSOCKET_DECODER_STATE_EXTENDED_LENGTH;
@@ -108,27 +120,21 @@ static int s_state_extended_length(struct aws_websocket_decoder *decoder, struct
         return AWS_OP_SUCCESS;
     }
 
-    /* RFC-6455 Section 5.2 Base Framing Protocol - Payload length
-     * 1) It is a crime to use more bytes than necessary to encode length.
-     *      > in all cases, the minimal number of bytes MUST be used to encode
-     *      > the length, for example, the length of a 124-byte-long string
-     *      > can't be encoded as the sequence 126, 0, 124
-     * 2) It is a crime to use most-significant bit on 8 byte payloads.
-     *      > If 127, the following 8 bytes interpreted as a 64-bit unsigned integer
-     *      > (the most significant bit MUST be 0) are the payload length */
+    /* The 7bit payload value loaded during the previous state indicated that
+     * actual payload length is encoded across the next 2 or 8 bytes. */
     uint8_t total_bytes_extended_length;
     uint64_t min_acceptable_value;
     uint64_t max_acceptable_value;
-    if (decoder->current_frame.payload_length == VALUE_FOR_2BYTE_EXTENDED_LENGTH) {
+    if (decoder->current_frame.payload_length == AWS_WEBSOCKET_7BIT_VALUE_FOR_2BYTE_EXTENDED_LENGTH) {
         total_bytes_extended_length = 2;
-        min_acceptable_value = VALUE_FOR_2BYTE_EXTENDED_LENGTH;
-        max_acceptable_value = UINT16_MAX;
+        min_acceptable_value = AWS_WEBSOCKET_2BYTE_EXTENDED_LENGTH_MIN_VALUE;
+        max_acceptable_value = AWS_WEBSOCKET_2BYTE_EXTENDED_LENGTH_MAX_VALUE;
     } else {
-        assert(decoder->current_frame.payload_length == VALUE_FOR_8BYTE_EXTENDED_LENGTH);
+        assert(decoder->current_frame.payload_length == AWS_WEBSOCKET_7BIT_VALUE_FOR_8BYTE_EXTENDED_LENGTH);
 
         total_bytes_extended_length = 8;
-        min_acceptable_value = UINT16_MAX + 1;
-        max_acceptable_value = 0x7FFFFFFFFFFFFFFFULL;
+        min_acceptable_value = AWS_WEBSOCKET_8BYTE_EXTENDED_LENGTH_MIN_VALUE;
+        max_acceptable_value = AWS_WEBSOCKET_8BYTE_EXTENDED_LENGTH_MAX_VALUE;
     }
 
     /* Copy bytes of extended-length to state_cache, we'll process them later.*/