1 /*
2 *
3 * Copyright 2015 gRPC authors.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #include <grpc/support/port_platform.h>
20
21 #include "src/core/lib/http/parser.h"
22
23 #include <stdbool.h>
24 #include <string.h>
25
26 #include <grpc/support/alloc.h>
27 #include <grpc/support/log.h>
28
29 #include "src/core/lib/gpr/useful.h"
30
31 grpc_core::TraceFlag grpc_http1_trace(false, "http1");
32
buf2str(void * buffer,size_t length)33 static char* buf2str(void* buffer, size_t length) {
34 char* out = static_cast<char*>(gpr_malloc(length + 1));
35 memcpy(out, buffer, length);
36 out[length] = 0;
37 return out;
38 }
39
handle_response_line(grpc_http_parser * parser)40 static grpc_error* handle_response_line(grpc_http_parser* parser) {
41 uint8_t* beg = parser->cur_line;
42 uint8_t* cur = beg;
43 uint8_t* end = beg + parser->cur_line_length;
44
45 if (cur == end || *cur++ != 'H')
46 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'H'");
47 if (cur == end || *cur++ != 'T')
48 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'T'");
49 if (cur == end || *cur++ != 'T')
50 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'T'");
51 if (cur == end || *cur++ != 'P')
52 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'P'");
53 if (cur == end || *cur++ != '/')
54 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected '/'");
55 if (cur == end || *cur++ != '1')
56 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected '1'");
57 if (cur == end || *cur++ != '.')
58 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected '.'");
59 if (cur == end || *cur < '0' || *cur++ > '1') {
60 return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
61 "Expected HTTP/1.0 or HTTP/1.1");
62 }
63 if (cur == end || *cur++ != ' ')
64 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected ' '");
65 if (cur == end || *cur < '1' || *cur++ > '9')
66 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected status code");
67 if (cur == end || *cur < '0' || *cur++ > '9')
68 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected status code");
69 if (cur == end || *cur < '0' || *cur++ > '9')
70 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected status code");
71 parser->http.response->status =
72 (cur[-3] - '0') * 100 + (cur[-2] - '0') * 10 + (cur[-1] - '0');
73 if (cur == end || *cur++ != ' ')
74 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected ' '");
75
76 /* we don't really care about the status code message */
77
78 return GRPC_ERROR_NONE;
79 }
80
handle_request_line(grpc_http_parser * parser)81 static grpc_error* handle_request_line(grpc_http_parser* parser) {
82 uint8_t* beg = parser->cur_line;
83 uint8_t* cur = beg;
84 uint8_t* end = beg + parser->cur_line_length;
85 uint8_t vers_major = 0;
86 uint8_t vers_minor = 0;
87
88 while (cur != end && *cur++ != ' ')
89 ;
90 if (cur == end)
91 return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
92 "No method on HTTP request line");
93 parser->http.request->method =
94 buf2str(beg, static_cast<size_t>(cur - beg - 1));
95
96 beg = cur;
97 while (cur != end && *cur++ != ' ')
98 ;
99 if (cur == end)
100 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No path on HTTP request line");
101 parser->http.request->path = buf2str(beg, static_cast<size_t>(cur - beg - 1));
102
103 if (cur == end || *cur++ != 'H')
104 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'H'");
105 if (cur == end || *cur++ != 'T')
106 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'T'");
107 if (cur == end || *cur++ != 'T')
108 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'T'");
109 if (cur == end || *cur++ != 'P')
110 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'P'");
111 if (cur == end || *cur++ != '/')
112 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected '/'");
113 vers_major = static_cast<uint8_t>(*cur++ - '1' + 1);
114 ++cur;
115 if (cur == end)
116 return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
117 "End of line in HTTP version string");
118 vers_minor = static_cast<uint8_t>(*cur++ - '1' + 1);
119
120 if (vers_major == 1) {
121 if (vers_minor == 0) {
122 parser->http.request->version = GRPC_HTTP_HTTP10;
123 } else if (vers_minor == 1) {
124 parser->http.request->version = GRPC_HTTP_HTTP11;
125 } else {
126 return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
127 "Expected one of HTTP/1.0, HTTP/1.1, or HTTP/2.0");
128 }
129 } else if (vers_major == 2) {
130 if (vers_minor == 0) {
131 parser->http.request->version = GRPC_HTTP_HTTP20;
132 } else {
133 return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
134 "Expected one of HTTP/1.0, HTTP/1.1, or HTTP/2.0");
135 }
136 } else {
137 return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
138 "Expected one of HTTP/1.0, HTTP/1.1, or HTTP/2.0");
139 }
140
141 return GRPC_ERROR_NONE;
142 }
143
handle_first_line(grpc_http_parser * parser)144 static grpc_error* handle_first_line(grpc_http_parser* parser) {
145 switch (parser->type) {
146 case GRPC_HTTP_REQUEST:
147 return handle_request_line(parser);
148 case GRPC_HTTP_RESPONSE:
149 return handle_response_line(parser);
150 }
151 GPR_UNREACHABLE_CODE(
152 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Should never reach here"));
153 }
154
add_header(grpc_http_parser * parser)155 static grpc_error* add_header(grpc_http_parser* parser) {
156 uint8_t* beg = parser->cur_line;
157 uint8_t* cur = beg;
158 uint8_t* end = beg + parser->cur_line_length;
159 size_t* hdr_count = nullptr;
160 grpc_http_header** hdrs = nullptr;
161 grpc_http_header hdr = {nullptr, nullptr};
162 grpc_error* error = GRPC_ERROR_NONE;
163
164 GPR_ASSERT(cur != end);
165
166 if (*cur == ' ' || *cur == '\t') {
167 error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
168 "Continued header lines not supported yet");
169 goto done;
170 }
171
172 while (cur != end && *cur != ':') {
173 cur++;
174 }
175 if (cur == end) {
176 error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
177 "Didn't find ':' in header string");
178 goto done;
179 }
180 GPR_ASSERT(cur >= beg);
181 hdr.key = buf2str(beg, static_cast<size_t>(cur - beg));
182 cur++; /* skip : */
183
184 while (cur != end && (*cur == ' ' || *cur == '\t')) {
185 cur++;
186 }
187 GPR_ASSERT((size_t)(end - cur) >= parser->cur_line_end_length);
188 hdr.value = buf2str(
189 cur, static_cast<size_t>(end - cur) - parser->cur_line_end_length);
190
191 switch (parser->type) {
192 case GRPC_HTTP_RESPONSE:
193 hdr_count = &parser->http.response->hdr_count;
194 hdrs = &parser->http.response->hdrs;
195 break;
196 case GRPC_HTTP_REQUEST:
197 hdr_count = &parser->http.request->hdr_count;
198 hdrs = &parser->http.request->hdrs;
199 break;
200 }
201
202 if (*hdr_count == parser->hdr_capacity) {
203 parser->hdr_capacity =
204 GPR_MAX(parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2);
205 *hdrs = static_cast<grpc_http_header*>(
206 gpr_realloc(*hdrs, parser->hdr_capacity * sizeof(**hdrs)));
207 }
208 (*hdrs)[(*hdr_count)++] = hdr;
209
210 done:
211 if (error != GRPC_ERROR_NONE) {
212 gpr_free(hdr.key);
213 gpr_free(hdr.value);
214 }
215 return error;
216 }
217
finish_line(grpc_http_parser * parser,bool * found_body_start)218 static grpc_error* finish_line(grpc_http_parser* parser,
219 bool* found_body_start) {
220 grpc_error* err;
221 switch (parser->state) {
222 case GRPC_HTTP_FIRST_LINE:
223 err = handle_first_line(parser);
224 if (err != GRPC_ERROR_NONE) return err;
225 parser->state = GRPC_HTTP_HEADERS;
226 break;
227 case GRPC_HTTP_HEADERS:
228 if (parser->cur_line_length == parser->cur_line_end_length) {
229 parser->state = GRPC_HTTP_BODY;
230 *found_body_start = true;
231 break;
232 }
233 err = add_header(parser);
234 if (err != GRPC_ERROR_NONE) {
235 return err;
236 }
237 break;
238 case GRPC_HTTP_BODY:
239 GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
240 "Should never reach here"));
241 }
242
243 parser->cur_line_length = 0;
244 return GRPC_ERROR_NONE;
245 }
246
addbyte_body(grpc_http_parser * parser,uint8_t byte)247 static grpc_error* addbyte_body(grpc_http_parser* parser, uint8_t byte) {
248 size_t* body_length = nullptr;
249 char** body = nullptr;
250
251 if (parser->type == GRPC_HTTP_RESPONSE) {
252 body_length = &parser->http.response->body_length;
253 body = &parser->http.response->body;
254 } else if (parser->type == GRPC_HTTP_REQUEST) {
255 body_length = &parser->http.request->body_length;
256 body = &parser->http.request->body;
257 } else {
258 GPR_UNREACHABLE_CODE(
259 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Should never reach here"));
260 }
261
262 if (*body_length == parser->body_capacity) {
263 parser->body_capacity = GPR_MAX(8, parser->body_capacity * 3 / 2);
264 *body =
265 static_cast<char*>(gpr_realloc((void*)*body, parser->body_capacity));
266 }
267 (*body)[*body_length] = static_cast<char>(byte);
268 (*body_length)++;
269
270 return GRPC_ERROR_NONE;
271 }
272
check_line(grpc_http_parser * parser)273 static bool check_line(grpc_http_parser* parser) {
274 if (parser->cur_line_length >= 2 &&
275 parser->cur_line[parser->cur_line_length - 2] == '\r' &&
276 parser->cur_line[parser->cur_line_length - 1] == '\n') {
277 return true;
278 }
279
280 // HTTP request with \n\r line termiantors.
281 else if (parser->cur_line_length >= 2 &&
282 parser->cur_line[parser->cur_line_length - 2] == '\n' &&
283 parser->cur_line[parser->cur_line_length - 1] == '\r') {
284 return true;
285 }
286
287 // HTTP request with only \n line terminators.
288 else if (parser->cur_line_length >= 1 &&
289 parser->cur_line[parser->cur_line_length - 1] == '\n') {
290 parser->cur_line_end_length = 1;
291 return true;
292 }
293
294 return false;
295 }
296
addbyte(grpc_http_parser * parser,uint8_t byte,bool * found_body_start)297 static grpc_error* addbyte(grpc_http_parser* parser, uint8_t byte,
298 bool* found_body_start) {
299 switch (parser->state) {
300 case GRPC_HTTP_FIRST_LINE:
301 case GRPC_HTTP_HEADERS:
302 if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
303 if (grpc_http1_trace.enabled())
304 gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
305 GRPC_HTTP_PARSER_MAX_HEADER_LENGTH);
306 return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
307 "HTTP header max line length exceeded");
308 }
309 parser->cur_line[parser->cur_line_length] = byte;
310 parser->cur_line_length++;
311 if (check_line(parser)) {
312 return finish_line(parser, found_body_start);
313 }
314 return GRPC_ERROR_NONE;
315 case GRPC_HTTP_BODY:
316 return addbyte_body(parser, byte);
317 }
318 GPR_UNREACHABLE_CODE(return GRPC_ERROR_NONE);
319 }
320
grpc_http_parser_init(grpc_http_parser * parser,grpc_http_type type,void * request_or_response)321 void grpc_http_parser_init(grpc_http_parser* parser, grpc_http_type type,
322 void* request_or_response) {
323 memset(parser, 0, sizeof(*parser));
324 parser->state = GRPC_HTTP_FIRST_LINE;
325 parser->type = type;
326 parser->http.request_or_response = request_or_response;
327 parser->cur_line_end_length = 2;
328 }
329
grpc_http_parser_destroy(grpc_http_parser * parser)330 void grpc_http_parser_destroy(grpc_http_parser* parser) {}
331
grpc_http_request_destroy(grpc_http_request * request)332 void grpc_http_request_destroy(grpc_http_request* request) {
333 size_t i;
334 gpr_free(request->body);
335 for (i = 0; i < request->hdr_count; i++) {
336 gpr_free(request->hdrs[i].key);
337 gpr_free(request->hdrs[i].value);
338 }
339 gpr_free(request->hdrs);
340 gpr_free(request->method);
341 gpr_free(request->path);
342 }
343
grpc_http_response_destroy(grpc_http_response * response)344 void grpc_http_response_destroy(grpc_http_response* response) {
345 size_t i;
346 gpr_free(response->body);
347 for (i = 0; i < response->hdr_count; i++) {
348 gpr_free(response->hdrs[i].key);
349 gpr_free(response->hdrs[i].value);
350 }
351 gpr_free(response->hdrs);
352 }
353
grpc_http_parser_parse(grpc_http_parser * parser,grpc_slice slice,size_t * start_of_body)354 grpc_error* grpc_http_parser_parse(grpc_http_parser* parser, grpc_slice slice,
355 size_t* start_of_body) {
356 for (size_t i = 0; i < GRPC_SLICE_LENGTH(slice); i++) {
357 bool found_body_start = false;
358 grpc_error* err =
359 addbyte(parser, GRPC_SLICE_START_PTR(slice)[i], &found_body_start);
360 if (err != GRPC_ERROR_NONE) return err;
361 if (found_body_start && start_of_body != nullptr) *start_of_body = i + 1;
362 }
363 return GRPC_ERROR_NONE;
364 }
365
grpc_http_parser_eof(grpc_http_parser * parser)366 grpc_error* grpc_http_parser_eof(grpc_http_parser* parser) {
367 if (parser->state != GRPC_HTTP_BODY) {
368 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Did not finish headers");
369 }
370 return GRPC_ERROR_NONE;
371 }
372