Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#) https://grpc.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
20925 Commits
274 Branches
377 Tags
1.2 GiB
 
 
 
 
 
 
Tag: Branch: Tree: c3c1240ad5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c3c1240ad5'
${ noResults }
grpc/test/core/http/parser_test.c

314 lines
11 KiB
Raw Blame History

/*
*
* 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_text, char *expect_method,
grpc_http_version expect_version,
char *expect_path, char *expect_body, ...) {
grpc_http_parser parser;
grpc_slice input_slice = grpc_slice_from_copied_string(request_text);
size_t num_slices;
size_t i;
grpc_slice *slices;
va_list args;
grpc_http_request request;
memset(&request, 0, sizeof(request));
grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
grpc_slice_unref(input_slice);
grpc_http_parser_init(&parser, GRPC_HTTP_REQUEST, &request);
for (i = 0; i < num_slices; i++) {
GPR_ASSERT(grpc_http_parser_parse(&parser, slices[i], NULL) ==
GRPC_ERROR_NONE);
grpc_slice_unref(slices[i]);
}
GPR_ASSERT(grpc_http_parser_eof(&parser) == GRPC_ERROR_NONE);
GPR_ASSERT(GRPC_HTTP_REQUEST == parser.type);
GPR_ASSERT(0 == strcmp(expect_method, request.method));
GPR_ASSERT(0 == strcmp(expect_path, request.path));
GPR_ASSERT(expect_version == request.version);
if (expect_body != NULL) {
GPR_ASSERT(strlen(expect_body) == request.body_length);
GPR_ASSERT(0 == memcmp(expect_body, request.body, request.body_length));
} else {
GPR_ASSERT(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 < request.hdr_count);
expect_value = va_arg(args, char *);
GPR_ASSERT(expect_value);
GPR_ASSERT(0 == strcmp(expect_key, request.hdrs[i].key));
GPR_ASSERT(0 == strcmp(expect_value, request.hdrs[i].value));
i++;
}
va_end(args);
GPR_ASSERT(i == request.hdr_count);
grpc_http_request_destroy(&request);
grpc_http_parser_destroy(&parser);
gpr_free(slices);
}
static void test_succeeds(grpc_slice_split_mode split_mode, char *response_text,
int expect_status, char *expect_body, ...) {
grpc_http_parser parser;
grpc_slice input_slice = grpc_slice_from_copied_string(response_text);
size_t num_slices;
size_t i;
grpc_slice *slices;
va_list args;
grpc_http_response response;
memset(&response, 0, sizeof(response));
grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
grpc_slice_unref(input_slice);
grpc_http_parser_init(&parser, GRPC_HTTP_RESPONSE, &response);
for (i = 0; i < num_slices; i++) {
GPR_ASSERT(grpc_http_parser_parse(&parser, slices[i], NULL) ==
GRPC_ERROR_NONE);
grpc_slice_unref(slices[i]);
}
GPR_ASSERT(grpc_http_parser_eof(&parser) == GRPC_ERROR_NONE);
GPR_ASSERT(GRPC_HTTP_RESPONSE == parser.type);
GPR_ASSERT(expect_status == response.status);
if (expect_body != NULL) {
GPR_ASSERT(strlen(expect_body) == response.body_length);
GPR_ASSERT(0 == memcmp(expect_body, response.body, response.body_length));
} else {
GPR_ASSERT(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 < response.hdr_count);
expect_value = va_arg(args, char *);
GPR_ASSERT(expect_value);
GPR_ASSERT(0 == strcmp(expect_key, response.hdrs[i].key));
GPR_ASSERT(0 == strcmp(expect_value, response.hdrs[i].value));
i++;
}
va_end(args);
GPR_ASSERT(i == response.hdr_count);
grpc_http_response_destroy(&response);
grpc_http_parser_destroy(&parser);
gpr_free(slices);
}
static void test_fails(grpc_slice_split_mode split_mode, char *response_text) {
grpc_http_parser parser;
grpc_slice input_slice = grpc_slice_from_copied_string(response_text);
size_t num_slices;
size_t i;
grpc_slice *slices;
grpc_error *error = GRPC_ERROR_NONE;
grpc_http_response response;
memset(&response, 0, sizeof(response));
grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
grpc_slice_unref(input_slice);
grpc_http_parser_init(&parser, GRPC_HTTP_RESPONSE, &response);
for (i = 0; i < num_slices; i++) {
if (GRPC_ERROR_NONE == error) {
error = grpc_http_parser_parse(&parser, slices[i], NULL);
}
grpc_slice_unref(slices[i]);
}
if (GRPC_ERROR_NONE == error) {
error = grpc_http_parser_eof(&parser);
}
GPR_ASSERT(error != GRPC_ERROR_NONE);
GRPC_ERROR_UNREF(error);
grpc_http_response_destroy(&response);
grpc_http_parser_destroy(&parser);
gpr_free(slices);
}
static void test_request_fails(grpc_slice_split_mode split_mode,
char *request_text) {
grpc_http_parser parser;
grpc_slice input_slice = grpc_slice_from_copied_string(request_text);
size_t num_slices;
size_t i;
grpc_slice *slices;
grpc_error *error = GRPC_ERROR_NONE;
grpc_http_request request;
memset(&request, 0, sizeof(request));
grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
grpc_slice_unref(input_slice);
grpc_http_parser_init(&parser, GRPC_HTTP_REQUEST, &request);
for (i = 0; i < num_slices; i++) {
if (error == GRPC_ERROR_NONE) {
error = grpc_http_parser_parse(&parser, slices[i], NULL);
}
grpc_slice_unref(slices[i]);
}
if (error == GRPC_ERROR_NONE) {
error = grpc_http_parser_eof(&parser);
}
GPR_ASSERT(error != GRPC_ERROR_NONE);
GRPC_ERROR_UNREF(error);
grpc_http_request_destroy(&request);
grpc_http_parser_destroy(&parser);
gpr_free(slices);
}
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(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_succeeds(split_modes[i],
"HTTP/1.1 200 OK\n"
"\n"
"abc",
200, "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_request_succeeds(split_modes[i],
"GET / HTTP/1.0\n"
"\n"
"xyz",
"GET", GRPC_HTTP_HTTP10, "/", "xyz", 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_request_fails(split_modes[i], "GET\r\n");
test_request_fails(split_modes[i], "GET /\r\n");
test_request_fails(split_modes[i], "GET / HTTP/0.0\r\n");
test_request_fails(split_modes[i], "GET / ____/1.0\r\n");
test_request_fails(split_modes[i], "GET / HTTP/1.2\r\n");
test_request_fails(split_modes[i], "GET / HTTP/1.0\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;
}