#include <string.h>

#include <stdlib.h>

#ifndef HTTPSERVER_IMPL

#include "common.h"

#include "parser.h"

#endif

#define HSH_P_FLAG_CHUNKED 0x1

#define HSH_P_FLAG_TOKEN_READY 0x2

#define HSH_P_FLAG_DONE 0x4

#define HSH_ENTER_TOKEN(tok_type, max_len) \

parser->token.type = tok_type; \

parser->token.index = p - buffer->buf; \

parser->token.flags = 0; \

parser->limit_count = 0; \

parser->limit_max = max_len;

%%{

machine hsh_http;

action method { HSH_ENTER_TOKEN(HSH_TOK_METHOD, 32) }

action target { HSH_ENTER_TOKEN(HSH_TOK_TARGET, 1024) }

action version { HSH_ENTER_TOKEN(HSH_TOK_VERSION, 16) }

action header_key { HSH_ENTER_TOKEN(HSH_TOK_HEADER_KEY, 256) }

action header_value { HSH_ENTER_TOKEN(HSH_TOK_HEADER_VALUE, 4096) }

action body {

parser->token.type = HSH_TOK_BODY;

parser->token.flags = 0;

parser->token.index = p - buffer->buf;

}

action emit_token {

parser->token.len = p - (buffer->buf + parser->token.index);

// hsh_token_array_push(&parser->tokens, parser->token);

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY);

fbreak;

}

action content_length_digit {

parser->content_length *= 10;

parser->content_length += fc - '0';

}

action transfer_encoding {

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_CHUNKED);

}

action reset_count {

parser->limit_count = 0;

parser->limit_max = 256;

}

action inc_count {

parser->limit_count++;

if (parser->limit_count > parser->limit_max) {

// parser->rc = (int8_t)HSH_PARSER_ERR;

fbreak;

}

}

action done_headers {

buffer->after_headers_index = p - buffer->buf + 1;

parser->content_remaining = parser->content_length;

parser->token = (struct hsh_token_s){ };

parser->token.type = HSH_TOK_HEADERS_DONE;

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY);

if (HTTP_FLAG_CHECK(parser->flags, HSH_P_FLAG_CHUNKED)) {

HTTP_FLAG_SET(parser->token.flags, HSH_TOK_FLAG_STREAMED_BODY);

fnext chunked_body;

fbreak;

} else if (parser->content_length == 0) {

HTTP_FLAG_SET(parser->token.flags, HSH_TOK_FLAG_NO_BODY);

fbreak;

// The body won't fit into the buffer at maximum capacity.

} else if (parser->content_length > max_buf_capacity - buffer->after_headers_index) {

HTTP_FLAG_SET(parser->token.flags, HSH_TOK_FLAG_STREAMED_BODY);

fnext large_body;

fbreak;

} else {

// Resize the buffer to hold the full body

if (parser->content_length + buffer->after_headers_index > buffer->capacity) {

buffer->buf = (char*)realloc(buffer->buf, parser->content_length + buffer->after_headers_index);

buffer->capacity = parser->content_length + buffer->after_headers_index;

}

fnext small_body;

fbreak;

}

}

action chunk_start {

parser->content_length = 0;

}

action chunk_size {

if (fc >= 'A' && fc <= 'F') {

parser->content_length *= 0x10;

parser->content_length += fc - 55;

} else if (fc >= 'a' && fc <= 'f') {

parser->content_length *= 0x10;

parser->content_length += fc - 87;

} else if (fc >= '0' && fc <= '9') {

parser->content_length *= 0x10;

parser->content_length += fc - '0';

}

}

action chunk_read {

char* last_body_byte = buffer->buf + parser->token.index + parser->content_length - 1;

if (pe >= last_body_byte) {

p = last_body_byte;

parser->token.len = parser->content_length;

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY);

fnext chunk_end;

fbreak;

// The current chunk is at the end of the buffer and the buffer cannot be expanded.

// Move the remaining contents of the buffer to just after the headers to free up

// capacity in the buffer.

} else if (p - buffer->buf + parser->content_length > max_buf_capacity) {

memcpy(buffer->buf + buffer->after_headers_index, p, pe - p);

buffer->length = buffer->after_headers_index + pe - p;

p = buffer->buf + buffer->after_headers_index;

parser->token.index = buffer->after_headers_index;

parser->sequence_id = buffer->sequence_id;

fhold;

fbreak;

}

}

action end_stream {

// write 0 byte body to tokens

parser->token.type = HSH_TOK_BODY;

parser->token.index = 0;

parser->token.len = 0;

parser->token.flags = HSH_TOK_FLAG_BODY_FINAL;

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY);

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_DONE);

fbreak;

}

action small_body_read {

parser->token.index = buffer->after_headers_index;

parser->token.len = parser->content_length;

HTTP_FLAG_SET(parser->token.flags, HSH_TOK_FLAG_SMALL_BODY);

char* last_body_byte = buffer->buf + parser->token.index + parser->content_length - 1;

if (pe >= last_body_byte) {

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY);

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_DONE);

}

p = pe;

fhold;

fbreak;

}

action large_body_read {

parser->token.index = buffer->after_headers_index;

char* last_body_byte = buffer->buf + buffer->after_headers_index + parser->content_remaining - 1;

if (pe >= last_body_byte) {

parser->token.flags = HSH_TOK_FLAG_BODY_FINAL;

parser->token.len = parser->content_remaining;

parser->content_remaining = 0;

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY);

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_DONE);

} else {

parser->token.len = pe - p;

parser->content_remaining -= parser->token.len;

HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY);

p = buffer->buf + buffer->after_headers_index;

buffer->length = buffer->after_headers_index;

parser->sequence_id = buffer->sequence_id;

}

fhold;

fbreak;

}

action error {

// parser->rc = (int8_t)HSH_PARSER_ERR;

fbreak;

}

token = ^[()<>@,;:\\"/\[\]?={} \t]+ >reset_count @inc_count;

crlf = '\r\n';

lws = crlf [ \t]+;

ows = [ \t]+;

method = [a-zA-Z]+ @inc_count ' ';

target = [^ ]+ @inc_count ' ';

version = 'HTTP/1.' [01] '\r';

request_line = (

method >method @emit_token

target >target @emit_token

version >version @emit_token '\n'

);

generic_header = (

( token ':' ) >header_key @emit_token

ows ( ^[ \t]? @inc_count ^[\r\n]* @inc_count '\r' ) >header_value @emit_token '\n'

);

content_length = (

( 'Content-Length'i ':' ) >header_key @emit_token

ows digit+ $content_length_digit ows crlf

);

transfer_encoding = (

( 'Transfer-Encoding'i ':' ) >header_key @emit_token

ows 'chunked' @transfer_encoding ows crlf

);

header = content_length | transfer_encoding | generic_header;

headers = ( header+ >reset_count @inc_count crlf ) @done_headers;

chunk = (

( ^[0] xdigit* ) >chunk_start $chunk_size crlf any+ >body $chunk_read

);

zero_chunk = '0' crlf @end_stream;

chunk_end := ( crlf ( chunk | zero_chunk ) ) $!error;

chunked_body := ( chunk* zero_chunk ) $!error;

small_body := any+ >body $small_body_read;

large_body := any+ >body $large_body_read;

main :=

request_line $!error

headers $!error;

}%%

%% write data;

void hsh_parser_init(struct hsh_parser_s* parser) {

memset(parser, 0, sizeof(struct hsh_parser_s));

parser->state = hsh_http_start;

}

struct hsh_token_s hsh_parser_exec(struct hsh_parser_s* parser, struct hsh_buffer_s* buffer, int max_buf_capacity) {

struct hsh_token_s none = {};

none.type = HSH_TOK_NONE;

if (HTTP_FLAG_CHECK(parser->flags, HSH_P_FLAG_DONE) || parser->sequence_id == buffer->sequence_id) {

return none;

}

int cs = parser->state;

char* eof = NULL;

char *p = buffer->buf + buffer->index;

char *pe = buffer->buf + buffer->length;

%% write exec;

parser->state = cs;

buffer->index = p - buffer->buf;

if (HTTP_FLAG_CHECK(parser->flags, HSH_P_FLAG_TOKEN_READY)) {

HTTP_FLAG_CLEAR(parser->flags, HSH_P_FLAG_TOKEN_READY);

return parser->token;

} else {

parser->sequence_id = buffer->sequence_id;

return none;

}

}