grpc/test/core/http/parser_test.c

/*
 *
 * Copyright 2015, Google Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "src/core/lib/http/parser.h"

#include <stdarg.h>
#include <string.h>

#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/string_util.h>
#include <grpc/support/useful.h>
#include "test/core/util/slice_splitter.h"
#include "test/core/util/test_config.h"

static void test_request_succeeds(grpc_slice_split_mode split_mode,
                                  char *request, char *expect_method,
                                  grpc_http_version expect_version,
                                  char *expect_path, char *expect_body, ...) {
  grpc_http_parser parser;
  gpr_slice input_slice = gpr_slice_from_copied_string(request);
  size_t num_slices;
  size_t i;
  gpr_slice *slices;
  va_list args;

  grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
  gpr_slice_unref(input_slice);

  grpc_http_parser_init(&parser);

  for (i = 0; i < num_slices; i++) {
    GPR_ASSERT(grpc_http_parser_parse(&parser, slices[i]));
    gpr_slice_unref(slices[i]);
  }
  GPR_ASSERT(grpc_http_parser_eof(&parser));

  GPR_ASSERT(GRPC_HTTP_REQUEST == parser.type);
  GPR_ASSERT(0 == strcmp(expect_method, parser.http.request.method));
  GPR_ASSERT(0 == strcmp(expect_path, parser.http.request.path));
  GPR_ASSERT(expect_version == parser.http.request.version);

  if (expect_body != NULL) {
    GPR_ASSERT(strlen(expect_body) == parser.http.request.body_length);
    GPR_ASSERT(0 == memcmp(expect_body, parser.http.request.body,
                           parser.http.request.body_length));
  } else {
    GPR_ASSERT(parser.http.request.body_length == 0);
  }

  va_start(args, expect_body);
  i = 0;
  for (;;) {
    char *expect_key;
    char *expect_value;
    expect_key = va_arg(args, char *);
    if (!expect_key) break;
    GPR_ASSERT(i < parser.http.request.hdr_count);
    expect_value = va_arg(args, char *);
    GPR_ASSERT(expect_value);
    GPR_ASSERT(0 == strcmp(expect_key, parser.http.request.hdrs[i].key));
    GPR_ASSERT(0 == strcmp(expect_value, parser.http.request.hdrs[i].value));
    i++;
  }
  va_end(args);
  GPR_ASSERT(i == parser.http.request.hdr_count);

  grpc_http_parser_destroy(&parser);
  gpr_free(slices);
}

static void test_succeeds(grpc_slice_split_mode split_mode, char *response,
                          int expect_status, char *expect_body, ...) {
  grpc_http_parser parser;
  gpr_slice input_slice = gpr_slice_from_copied_string(response);
  size_t num_slices;
  size_t i;
  gpr_slice *slices;
  va_list args;

  grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
  gpr_slice_unref(input_slice);

  grpc_http_parser_init(&parser);

  for (i = 0; i < num_slices; i++) {
    GPR_ASSERT(grpc_http_parser_parse(&parser, slices[i]));
    gpr_slice_unref(slices[i]);
  }
  GPR_ASSERT(grpc_http_parser_eof(&parser));

  GPR_ASSERT(GRPC_HTTP_RESPONSE == parser.type);
  GPR_ASSERT(expect_status == parser.http.response.status);
  if (expect_body != NULL) {
    GPR_ASSERT(strlen(expect_body) == parser.http.response.body_length);
    GPR_ASSERT(0 == memcmp(expect_body, parser.http.response.body,
                           parser.http.response.body_length));
  } else {
    GPR_ASSERT(parser.http.response.body_length == 0);
  }

  va_start(args, expect_body);
  i = 0;
  for (;;) {
    char *expect_key;
    char *expect_value;
    expect_key = va_arg(args, char *);
    if (!expect_key) break;
    GPR_ASSERT(i < parser.http.response.hdr_count);
    expect_value = va_arg(args, char *);
    GPR_ASSERT(expect_value);
    GPR_ASSERT(0 == strcmp(expect_key, parser.http.response.hdrs[i].key));
    GPR_ASSERT(0 == strcmp(expect_value, parser.http.response.hdrs[i].value));
    i++;
  }
  va_end(args);
  GPR_ASSERT(i == parser.http.response.hdr_count);

  grpc_http_parser_destroy(&parser);
  gpr_free(slices);
}

static void test_fails(grpc_slice_split_mode split_mode, char *response) {
  grpc_http_parser parser;
  gpr_slice input_slice = gpr_slice_from_copied_string(response);
  size_t num_slices;
  size_t i;
  gpr_slice *slices;
  int done = 0;

  grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
  gpr_slice_unref(input_slice);

  grpc_http_parser_init(&parser);

  for (i = 0; i < num_slices; i++) {
    if (!done && !grpc_http_parser_parse(&parser, slices[i])) {
      done = 1;
    }
    gpr_slice_unref(slices[i]);
  }
  if (!done && !grpc_http_parser_eof(&parser)) {
    done = 1;
  }
  GPR_ASSERT(done);

  grpc_http_parser_destroy(&parser);
  gpr_free(slices);
}

static const uint8_t failed_test1[] = {
    0x9e, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x4a,
    0x48, 0x54, 0x54, 0x30, 0x32, 0x16, 0xa,  0x2f, 0x48, 0x20,
    0x31, 0x2e, 0x31, 0x20, 0x32, 0x30, 0x31, 0x54, 0x54, 0xb9,
    0x32, 0x31, 0x2e, 0x20, 0x32, 0x30, 0x20,
};

typedef struct {
  const char *name;
  const uint8_t *data;
  size_t length;
} failed_test;

#define FAILED_TEST(name) \
  { #name, name, sizeof(name) }

failed_test failed_tests[] = {
    FAILED_TEST(failed_test1),
};

static void test_doesnt_crash(failed_test t) {
  gpr_log(GPR_DEBUG, "Run previously failed test: %s", t.name);
  grpc_http_parser p;
  grpc_http_parser_init(&p);
  gpr_slice slice =
      gpr_slice_from_copied_buffer((const char *)t.data, t.length);
  grpc_http_parser_parse(&p, slice);
  gpr_slice_unref(slice);
  grpc_http_parser_destroy(&p);
}

int main(int argc, char **argv) {
  size_t i;
  const grpc_slice_split_mode split_modes[] = {GRPC_SLICE_SPLIT_IDENTITY,
                                               GRPC_SLICE_SPLIT_ONE_BYTE};
  char *tmp1, *tmp2;

  grpc_test_init(argc, argv);

  for (i = 0; i < GPR_ARRAY_SIZE(failed_tests); i++) {
    test_doesnt_crash(failed_tests[i]);
  }

  for (i = 0; i < GPR_ARRAY_SIZE(split_modes); i++) {
    test_succeeds(split_modes[i],
                  "HTTP/1.0 200 OK\r\n"
                  "xyz: abc\r\n"
                  "\r\n"
                  "hello world!",
                  200, "hello world!", "xyz", "abc", NULL);
    test_succeeds(split_modes[i],
                  "HTTP/1.0 404 Not Found\r\n"
                  "\r\n",
                  404, NULL, NULL);
    test_succeeds(split_modes[i],
                  "HTTP/1.1 200 OK\r\n"
                  "xyz: abc\r\n"
                  "\r\n"
                  "hello world!",
                  200, "hello world!", "xyz", "abc", NULL);
    test_request_succeeds(split_modes[i],
                          "GET / HTTP/1.0\r\n"
                          "\r\n",
                          "GET", GRPC_HTTP_HTTP10, "/", NULL, NULL);
    test_request_succeeds(split_modes[i],
                          "GET / HTTP/1.0\r\n"
                          "\r\n"
                          "xyz",
                          "GET", GRPC_HTTP_HTTP10, "/", "xyz", NULL);
    test_request_succeeds(split_modes[i],
                          "GET / HTTP/1.1\r\n"
                          "\r\n"
                          "xyz",
                          "GET", GRPC_HTTP_HTTP11, "/", "xyz", NULL);
    test_request_succeeds(split_modes[i],
                          "GET / HTTP/2.0\r\n"
                          "\r\n"
                          "xyz",
                          "GET", GRPC_HTTP_HTTP20, "/", "xyz", NULL);
    test_request_succeeds(split_modes[i],
                          "GET / HTTP/1.0\r\n"
                          "xyz: abc\r\n"
                          "\r\n"
                          "xyz",
                          "GET", GRPC_HTTP_HTTP10, "/", "xyz", "xyz", "abc",
                          NULL);
    test_fails(split_modes[i], "HTTP/1.0\r\n");
    test_fails(split_modes[i], "HTTP/1.2\r\n");
    test_fails(split_modes[i], "HTTP/1.0 000 XYX\r\n");
    test_fails(split_modes[i], "HTTP/1.0 200 OK\n");
    test_fails(split_modes[i], "HTTP/1.0 200 OK\r\n");
    test_fails(split_modes[i], "HTTP/1.0 200 OK\r\nFoo x\r\n");
    test_fails(split_modes[i],
               "HTTP/1.0 200 OK\r\n"
               "xyz: abc\r\n"
               "  def\r\n"
               "\r\n"
               "hello world!");
    test_fails(split_modes[i], "GET\r\n");
    test_fails(split_modes[i], "GET /\r\n");
    test_fails(split_modes[i], "GET / HTTP/0.0\r\n");
    test_fails(split_modes[i], "GET / ____/1.0\r\n");
    test_fails(split_modes[i], "GET / HTTP/1.2\r\n");

    tmp1 = gpr_malloc(2 * GRPC_HTTP_PARSER_MAX_HEADER_LENGTH);
    memset(tmp1, 'a', 2 * GRPC_HTTP_PARSER_MAX_HEADER_LENGTH - 1);
    tmp1[2 * GRPC_HTTP_PARSER_MAX_HEADER_LENGTH - 1] = 0;
    gpr_asprintf(&tmp2, "HTTP/1.0 200 OK\r\nxyz: %s\r\n\r\n", tmp1);
    test_fails(split_modes[i], tmp2);
    gpr_free(tmp1);
    gpr_free(tmp2);
  }

  return 0;
}