dany/ant-http
1
0
Fork 0
mirror of https://github.com/lxsang/ant-http synced 2024-11-17 17:08:20 +01:00
Code Issues Actions Projects Releases Wiki Activity

contd.

Browse Source
This commit is contained in:
lxsang 2020-01-30 14:04:07 +01:00
parent dad3b25fc8
commit 80f6aebf37
4 changed files with 129 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
http_server.c
View File

@ -1346,14 +1346,25 @@ void destroy_request(void *data)
dput(rq->request, "REQUEST_HEADER", NULL); dput(rq->request, "REQUEST_HEADER", NULL);
dput(rq->request, "REQUEST_DATA", NULL); dput(rq->request, "REQUEST_DATA", NULL);
dput(rq->request, "COOKIE", NULL); dput(rq->request, "COOKIE", NULL);
#ifdef USE_OPENSSL #ifdef USE_OPENSSL
#if OPENSSL_VERSION_NUMBER >= 0x10002000L #if OPENSSL_VERSION_NUMBER >= 0x10002000L
antd_h2_conn_t* conn = H2_CONN(data); if(rq->client->flags & CLIENT_FL_H2_STREAM)
if(conn)
{ {
//H2_CONNECTION // close the stream
antd_h2_close_conn(conn); antd_h2_stream_t* stream = (antd_h2_stream_t*)rq->client->stream;
dput(rq->request, "H2_CONNECTION", NULL); antd_h2_close_stream(stream);
stream->state = H2_STR_FINALIZED;
}
else
{
antd_h2_conn_t* conn = H2_CONN(data);
if(conn)
{
//H2_CONNECTION
antd_h2_close_conn(conn);
dput(rq->request, "H2_CONNECTION", NULL);
}
} }
#endif #endif
#endif #endif

98
lib/h2.c
View File

@ -192,7 +192,7 @@ antd_h2_stream_t* antd_h2_init_stream(int id, int wsz)
stream->state = H2_STR_IDLE; stream->state = H2_STR_IDLE;
stream->stdin = ALLOC_QUEUE_ROOT(); stream->stdin = ALLOC_QUEUE_ROOT();
stream->stdout = ALLOC_QUEUE_ROOT(); stream->stdout = ALLOC_QUEUE_ROOT();
//stream->flags = 0; stream->flags = 0;
stream->dependency = 0; stream->dependency = 0;
stream->weight = 255; stream->weight = 255;
return stream; return stream;
@ -226,8 +226,33 @@ static void* antd_h2_stream_handle(void* data)
{ {
antd_request_t* rq = (antd_request_t*) data; antd_request_t* rq = (antd_request_t*) data;
antd_h2_stream_t* stream = (antd_h2_stream_t*) rq->client->stream; antd_h2_stream_t* stream = (antd_h2_stream_t*) rq->client->stream;
// transition state here antd_task_t* task = NULL;
// TODO: next day
if(stream->state == H2_STREAM_CLOSED)
{
return antd_empty_task(data, rq->client->last_io);
}
// print header info
antd_h2_frame_t* frame = antd_h2_streamio_get(stream->stdin);
if(!frame)
{
task = antd_create_task(antd_h2_stream_handle,data,NULL,rq->client->last_io);
task->priority++;
return task;
}
// print stream status
printf("End stream: %d\n", stream->flags & H2_END_STREAM_FLG);
printf("Priority %d\n", stream->flags & H2_PRIORITY_FLG );
printf("Exclusive %d\n", stream->flags & H2_EXCLUSIVE_FLG );
printf("dependencies %d\n", stream->dependency);
printf("weight %d\n", stream->weight);
printf("frame end stream %d\n", frame->header.flags & H2_END_STREAM_FLG);
printf("frame end header %d\n", frame->header.flags & H2_END_HEADERS_FLG);
printf("frame padded %d\n", frame->header.flags & H2_PADDED_FLG);
printf("frame priority %d\n", frame->header.flags & H2_PRIORITY_FLG);
return NULL; return NULL;
} }
@ -263,28 +288,59 @@ static int process_header_frame(antd_request_t* rq, antd_h2_frame_header_t* fram
antd_h2_add_stream(conn->streams,stream); antd_h2_add_stream(conn->streams,stream);
is_new_stream = 1; is_new_stream = 1;
} }
if( stream->state == H2_STR_IDLE || stream->state == H2_STR_REV_LOC || stream->state == H2_STR_OPEN || stream->state == H2_STR_HALF_CLOSED_REM )
{ // switch state here
antd_h2_frame_t* frame = (antd_h2_frame_t*) malloc(sizeof(antd_h2_frame_t)); switch (stream->state)
frame->header = *frame_h;
frame->pageload = data;
h2_stream_io_put(stream,frame);
if(is_new_stream)
{
// TODO create new request
// just dump the scheduler when we have a connection
antd_schedule_task( antd_create_task(antd_h2_stream_handle, antd_h2_request_init(rq, stream) , NULL, time(NULL)));
}
return H2_NO_ERROR;
}
else
{ {
case H2_STR_IDLE:
stream->state = H2_STR_OPEN;
break;
case H2_STR_REV_REM:
stream->state = H2_STR_HALF_CLOSED_LOC;
break;
default:
free(data); free(data);
return H2_PROTOCOL_ERROR; return H2_PROTOCOL_ERROR;
} }
antd_h2_frame_t* frame = (antd_h2_frame_t*) malloc(sizeof(antd_h2_frame_t));
frame->header = *frame_h;
frame->pageload = data;
stream->flags = (frame_h->flags & H2_END_STREAM_FLG) | (frame_h->flags & H2_PRIORITY_FLG);
if(frame_h->flags & H2_PRIORITY_FLG)
{
uint8_t* ptr = data;
if(frame_h->flags & H2_PADDED_FLG)
ptr += 1;
// set stream weight + dependencies
memcpy(&stream->dependency, ptr, 4);
printf("%u\n", stream->dependency);
stream->dependency = ntohl(stream->dependency) & 0x7FFFFFFF;
printf("%d\n", *ptr);
if(*(ptr) & 0x80)
{
stream->flags |= H2_EXCLUSIVE_FLG;
}
else
{
stream->flags &= ~H2_EXCLUSIVE_FLG;
}
stream->weight = *(data + 4);
// set flag
}
h2_stream_io_put(stream,frame);
if(is_new_stream)
{
antd_schedule_task( antd_create_task(antd_h2_stream_handle, antd_h2_request_init(rq, stream) , NULL, time(NULL)));
}
return H2_NO_ERROR;
} }
antd_h2_frame_t* h2_streamio_get(struct queue_root* io) antd_h2_frame_t* antd_h2_streamio_get(struct queue_root* io)
{ {
struct queue_head* head = queue_get(io); struct queue_head* head = queue_get(io);
if(!head) return NULL; if(!head) return NULL;
@ -300,11 +356,11 @@ void h2_stream_io_put(antd_h2_stream_t* stream, antd_h2_frame_t* frame)
head->data = (void*)frame; head->data = (void*)frame;
if(frame->header.identifier % 2 == 0) if(frame->header.identifier % 2 == 0)
{ {
queue_put(head, stream->stdin); queue_put(head, stream->stdout);
} }
else else
{ {
queue_put(head, stream->stdout); queue_put(head, stream->stdin);
} }
} }

18
lib/h2.h
View File

@ -117,6 +117,15 @@ field value other than 0 MUST be treated as a connection error
#define H2_SETTINGS_MAX_HEADER_LIST_SIZE 0x6 #define H2_SETTINGS_MAX_HEADER_LIST_SIZE 0x6
/*header flag*/
#define H2_END_STREAM_FLG 0x1
#define H2_END_HEADERS_FLG 0x4
#define H2_PADDED_FLG 0x8
#define H2_PRIORITY_FLG 0x20
#define H2_EXCLUSIVE_FLG 0x40
// stream state // stream state
typedef enum { typedef enum {
H2_STR_IDLE, H2_STR_IDLE,
@ -125,7 +134,8 @@ typedef enum {
H2_STR_REV_REM, H2_STR_REV_REM,
H2_STR_HALF_CLOSED_LOC, H2_STR_HALF_CLOSED_LOC,
H2_STR_HALF_CLOSED_REM, H2_STR_HALF_CLOSED_REM,
H2_STR_CLOSED H2_STR_CLOSED,
H2_STR_FINALIZED
} antd_h2_stream_state_t; } antd_h2_stream_state_t;
typedef struct{ typedef struct{
@ -162,8 +172,8 @@ typedef struct {
struct queue_root* stdout; struct queue_root* stdout;
int win_sz; int win_sz;
antd_h2_stream_state_t state; antd_h2_stream_state_t state;
//uint8_t flags; uint8_t flags;
int dependency; uint32_t dependency;
uint8_t weight; uint8_t weight;
int id; int id;
} antd_h2_stream_t; } antd_h2_stream_t;
@ -200,7 +210,7 @@ void antd_h2_del_stream(antd_h2_stream_list_t*, int);
void antd_h2_close_all_streams(antd_h2_stream_list_t*); void antd_h2_close_all_streams(antd_h2_stream_list_t*);
void antd_h2_update_streams_win_sz(antd_h2_stream_list_t streams, int offset); void antd_h2_update_streams_win_sz(antd_h2_stream_list_t streams, int offset);
void h2_stream_io_put(antd_h2_stream_t*, antd_h2_frame_t*); void h2_stream_io_put(antd_h2_stream_t*, antd_h2_frame_t*);
antd_h2_frame_t* h2_streamio_get(struct queue_root*); antd_h2_frame_t* antd_h2_streamio_get(struct queue_root*);
antd_request_t* antd_h2_request_init(antd_request_t*, antd_h2_stream_t*); antd_request_t* antd_h2_request_init(antd_request_t*, antd_h2_stream_t*);

36
lib/handle.c
View File

@ -1,4 +1,5 @@
#include "handle.h" #include "handle.h"
#define HTML_TPL "<HTML><HEAD><TITLE>%s</TITLE></HEAD><BODY><h2>%s</h2></BODY></HTML>" #define HTML_TPL "<HTML><HEAD><TITLE>%s</TITLE></HEAD><BODY><h2>%s</h2></BODY></HTML>"
static const char* S_100 = "Continue"; static const char* S_100 = "Continue";
@ -661,21 +662,28 @@ int antd_close(void* src)
} }
#endif #endif
#ifdef USE_OPENSSL #ifdef USE_OPENSSL
if(source->stream){ #if OPENSSL_VERSION_NUMBER >= 0x10002000L
//printf("SSL:Shutdown ssl\n"); if(!(source->flags & CLIENT_FL_H2_STREAM))
//SSL_shutdown((SSL*) source->ssl); {
SSL_set_shutdown((SSL*) source->stream, SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN); #endif
//printf("SSL:Free ssl\n"); if(source->stream){
SSL_free((SSL*) source->stream); //printf("SSL:Shutdown ssl\n");
//SSL_shutdown((SSL*) source->ssl);
//EVP_cleanup(); SSL_set_shutdown((SSL*) source->stream, SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
//ENGINE_cleanup(); //printf("SSL:Free ssl\n");
CRYPTO_cleanup_all_ex_data(); SSL_free((SSL*) source->stream);
ERR_remove_state(0);
ERR_free_strings(); //EVP_cleanup();
source->stream = NULL; //ENGINE_cleanup();
//LOG("Freeing SSL\n"); CRYPTO_cleanup_all_ex_data();
ERR_remove_state(0);
ERR_free_strings();
source->stream = NULL;
//LOG("Freeing SSL\n");
}
#if OPENSSL_VERSION_NUMBER >= 0x10002000L
} }
#endif
#endif #endif
//printf("Close sock %d\n", source->sock); //printf("Close sock %d\n", source->sock);
int ret = close(source->id); int ret = close(source->id);