void nxd_http_client_proto_start_request(nxd_http_client_proto* hcp, nxweb_http_request* req) {
//nxweb_http_request* resp=&hcp->resp;
hcp->nxb=nxp_alloc(hcp->nxb_pool);
nxb_init(hcp->nxb, NXWEB_CONN_NXB_SIZE);
hcp->req=req;
if (!req->nxb) req->nxb=hcp->nxb;
if (!req->host) req->host=hcp->host;
nxe_loop* loop=hcp->data_in.super.loop;
hcp->req_headers_ptr=_nxweb_prepare_client_request_headers(req);
//nxweb_log_error("REQ: %s", hcp->req_headers_ptr);
if (!hcp->req_body_in.pair && req->content && req->content_length>0) {
nxd_obuffer_init(&hcp->ob, req->content, req->content_length);
nxe_connect_streams(loop, &hcp->ob.data_out, &hcp->req_body_in);
}
if (hcp->state==HCP_IDLE) hcp->state=HCP_SENDING_HEADERS;
nxe_unset_timer(loop, NXWEB_TIMER_KEEP_ALIVE, &hcp->timer_keep_alive);
hcp->req_body_sending_started=0;
hcp->receiving_100_continue=0;
hcp->request_complete=0;
hcp->response_body_complete=0;
hcp->queued_error_message.l=0;
nxe_istream_set_ready(loop, &hcp->data_out);
}
static void rbuffer_data_in_do_read(nxe_ostream* os, nxe_istream* is) {
nxd_rbuffer* rb=(nxd_rbuffer*)((char*)os-offsetof(nxd_rbuffer, data_in));
//nxe_loop* loop=os->super.loop;
nxweb_log_debug("rbuffer_data_in_do_read");
nxe_size_t size;
char* ptr=nxd_rbuffer_get_write_ptr(rb, &size);
assert(size);
/*
if (!size) {
// this should never happen
nxe_ostream_unset_ready(os);
return;
}
*/
nxe_flags_t flags=0;
nxe_ssize_t bytes_received=ISTREAM_CLASS(is)->read(is, os, ptr, size, &flags);
if (bytes_received>0) {
nxd_rbuffer_write(rb, bytes_received);
}
if (flags&NXEF_EOF) {
//nxweb_log_error("rb[%p] received EOF", rb);
rb->eof=1;
nxe_istream_set_ready(os->super.loop, &rb->data_out); // even when no bytes received make sure we signal readiness on EOF
}
}
static nxe_ssize_t req_body_in_write(nxe_ostream* os, nxe_istream* is, int fd, nxe_data ptr, nxe_size_t size, nxe_flags_t* flags) {
//nxweb_log_error("req_body_in_write(%d)", size);
nxd_http_client_proto* hcp=(nxd_http_client_proto*)((char*)os-offsetof(nxd_http_client_proto, req_body_in));
nxe_loop* loop=os->super.loop;
if (hcp->state!=HCP_SENDING_BODY) {
nxe_ostream_unset_ready(os);
nxe_istream_set_ready(loop, &hcp->data_out); // get notified when next_os ready
return 0;
}
hcp->req_body_sending_started=1;
nxe_unset_timer(loop, NXWEB_TIMER_WRITE, &hcp->timer_write);
nxe_ssize_t bytes_sent=0;
if (size>0) {
nxe_ostream* next_os=hcp->data_out.pair;
if (next_os) {
nxe_flags_t wflags=*flags;
if (next_os->ready) bytes_sent=OSTREAM_CLASS(next_os)->write(next_os, &hcp->data_out, 0, (nxe_data)ptr, size, &wflags);
if (!next_os->ready) {
//nxweb_log_error("req_body_in_write(%d) - next_os unready", size);
nxe_ostream_unset_ready(os);
nxe_istream_set_ready(loop, &hcp->data_out); // get notified when next_os becomes ready again
}
}
else {
nxweb_log_error("no connected device for hcp->data_out");
nxe_ostream_unset_ready(os);
}
}
if (*flags&NXEF_EOF && bytes_sent==size) {
// end of request => get response
nxe_ostream_unset_ready(os);
start_receiving_response(hcp, loop);
return bytes_sent;
}
nxe_set_timer(loop, NXWEB_TIMER_WRITE, &hcp->timer_write);
return bytes_sent;
}
void nxd_rbuffer_write(nxd_rbuffer* rb, int size) {
nxweb_log_debug("nxd_rbuffer_write");
if (size) {
rb->write_ptr+=size;
assert(rb->write_ptr <= rb->end_ptr);
if (rb->write_ptr >= rb->end_ptr) rb->write_ptr=rb->start_ptr;
rb->last_write=1;
if (rb->data_out.super.loop) nxe_istream_set_ready(rb->data_out.super.loop, &rb->data_out);
else rb->data_out.ready=1;
if (rb->read_ptr==rb->write_ptr) { // nxd_rbuffer_is_full(rb)
if (rb->data_in.super.loop) nxe_ostream_unset_ready(&rb->data_in);
else rb->data_in.ready=0;
}
}
}
static void data_error_on_message(nxe_subscriber* sub, nxe_publisher* pub, nxe_data data) {
nxd_http_client_proto* hcp=(nxd_http_client_proto*)((char*)sub-offsetof(nxd_http_client_proto, data_error));
nxe_loop* loop=sub->super.loop;
if ((data.i==NXE_HUP || data.i==NXE_RDHUP || data.i==NXE_RDCLOSED)
&& (hcp->resp.content_length<0 && !hcp->resp.chunked_encoding)
&& (hcp->state!=HCP_IDLE)) {
// content-length = until-close
//request_complete(hcp, loop);
hcp->response_body_complete=1;
nxe_istream_set_ready(loop, &hcp->resp_body_out); // signal readiness for EOF
return;
}
else if (hcp->response_body_complete && !hcp->request_complete && data.i<0) {
// queue error message until request is complete
hcp->queued_error_message=data;
return;
}
nxe_publish(&hcp->events_pub, data);
}
static void data_in_do_read(nxe_ostream* os, nxe_istream* is) {
nxd_http_client_proto* hcp=(nxd_http_client_proto*)((char*)os-offsetof(nxd_http_client_proto, data_in));
nxe_loop* loop=os->super.loop;
if (hcp->state==HCP_WAITING_FOR_RESPONSE) {
nxe_unset_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read);
nxe_unset_timer(loop, NXWEB_TIMER_100CONTINUE, &hcp->timer_100_continue);
nxe_set_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read);
nxb_make_room(hcp->nxb, NXWEB_MAX_REQUEST_HEADERS_SIZE);
hcp->state=HCP_RECEIVING_HEADERS;
}
if (hcp->state==HCP_RECEIVING_HEADERS) {
int size;
nxe_flags_t flags=0;
void* ptr=nxb_get_room(hcp->nxb, &size);
int bytes_received=ISTREAM_CLASS(is)->read(is, os, ptr, size, &flags);
if (bytes_received) {
nxb_blank_fast(hcp->nxb, bytes_received);
int read_buf_size;
char* read_buf=nxb_get_unfinished(hcp->nxb, &read_buf_size);
char* end_of_headers;
char* start_of_body;
if ((end_of_headers=_nxweb_find_end_of_http_headers(read_buf, read_buf_size, &start_of_body))) {
nxb_finish_stream(hcp->nxb, 0);
memset(&hcp->resp, 0, sizeof(hcp->resp));
hcp->resp.nxb=hcp->nxb;
hcp->resp.cdstate.monitor_only=hcp->chunked_do_not_decode;
if (_nxweb_parse_http_response(&hcp->resp, read_buf, end_of_headers)) {
// bad response
nxe_unset_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read);
nxe_ostream_unset_ready(os);
nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_BAD_RESPONSE);
return;
}
if (hcp->receiving_100_continue) {
hcp->receiving_100_continue=0;
if (hcp->resp.status_code==100) {
// back to sending request body
nxe_ostream_unset_ready(&hcp->data_in);
nxe_unset_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read);
nxe_set_timer(loop, NXWEB_TIMER_WRITE, &hcp->timer_write);
nxe_istream_set_ready(loop, &hcp->data_out);
hcp->state=HCP_SENDING_BODY;
return;
}
else {
nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_NO_100CONTINUE);
}
}
char* read_buf_end=read_buf+read_buf_size;
if (start_of_body<read_buf_end) {
hcp->first_body_chunk=start_of_body;
hcp->first_body_chunk_end=read_buf_end;
nxe_size_t first_body_chunk_size=hcp->first_body_chunk_end-hcp->first_body_chunk;
if (hcp->resp.chunked_encoding) {
int r=_nxweb_decode_chunked_stream(&hcp->resp.cdstate, hcp->first_body_chunk, &first_body_chunk_size);
hcp->first_body_chunk_end=hcp->first_body_chunk+first_body_chunk_size;
if (r<0) nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_RESPONSE_CHUNKED_ENCODING_ERROR);
else if (r>0) hcp->response_body_complete=1;
}
else if (first_body_chunk_size >= hcp->resp.content_length && hcp->resp.content_length>=0) {
hcp->response_body_complete=1;
}
}
else {
hcp->first_body_chunk=0;
hcp->first_body_chunk_end=0;
}
nxe_ostream_unset_ready(os);
nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_RESPONSE_RECEIVED);
if (hcp->resp.content_length && !hcp->req->head_method) { // is body expected?
hcp->state=HCP_RECEIVING_BODY;
nxe_istream_set_ready(loop, &hcp->resp_body_out);
if (hcp->resp_body_out.pair) {
nxe_ostream_set_ready(loop, os);
}
}
else {
// rearm connection
request_complete(hcp, loop);
}
}
else {
if (read_buf_size>=NXWEB_MAX_REQUEST_HEADERS_SIZE) {
// bad response (headers too large)
nxe_unset_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read);
nxe_ostream_unset_ready(os);
nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_BAD_RESPONSE);
return;
}
}
}
}
else if (hcp->state==HCP_RECEIVING_BODY) {
nxe_ostream* next_os=hcp->resp_body_out.pair;
if (next_os) {
if (next_os->ready) OSTREAM_CLASS(next_os)->do_read(next_os, &hcp->resp_body_out);
if (!next_os->ready) {
nxe_ostream_unset_ready(os);
nxe_istream_set_ready(loop, &hcp->resp_body_out); // get notified when next_os becomes ready again
}
}
else {
nxweb_log_error("no connected device for hcp->resp_body_out");
nxe_ostream_unset_ready(os);
}
}
}
