static void fwbuffer_data_in_do_read(nxe_ostream* os, nxe_istream* is) { nxd_fwbuffer* fwb=OBJ_PTR_FROM_FLD_PTR(nxd_fwbuffer, data_in, os); char buf[16384]; nxe_size_t max_bytes_to_store=fwb->max_size > fwb->size ? fwb->max_size-fwb->size : 0; if (max_bytes_to_store>sizeof(buf)) max_bytes_to_store=sizeof(buf); // NB: continue reading even after reaching max_size; just swallow the input nxe_flags_t flags=0; nxe_ssize_t bytes_received=ISTREAM_CLASS(is)->read(is, os, buf, sizeof(buf), &flags); if (bytes_received>0) { fwb->size+=bytes_received; size_t bytes_to_store; if (fwb->error) { bytes_to_store=0; } else if (bytes_received>max_bytes_to_store) { // max_size reached fwb->error=EFBIG; bytes_to_store=max_bytes_to_store; } else { bytes_to_store=bytes_received; } if (bytes_to_store) { if (write(fwb->fd, buf, bytes_to_store)!=bytes_to_store) { fwb->error=errno; } } } if (flags&NXEF_EOF) { nxe_ostream_unset_ready(os); } }
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 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); } } }
static nxe_size_t resp_body_out_read(nxe_istream* is, nxe_ostream* os, void* ptr, nxe_size_t size, nxe_flags_t* flags) { nxd_http_client_proto* hcp=(nxd_http_client_proto*)((char*)is-offsetof(nxd_http_client_proto, resp_body_out)); nxe_loop* loop=is->super.loop; if (hcp->request_complete) { nxweb_log_error("hcp->request_complete - resp_body_out_read() should not be called"); *flags|=NXEF_EOF; nxe_istream_unset_ready(is); return 0; } if (hcp->state!=HCP_RECEIVING_BODY) { nxe_istream_unset_ready(is); nxe_ostream_set_ready(loop, &hcp->data_in); // get notified when prev_is ready return 0; } nxe_size_t bytes_received=0; if (hcp->first_body_chunk) { nxe_size_t first_body_chunk_size=hcp->first_body_chunk_end-hcp->first_body_chunk; if (first_body_chunk_size<=size) { bytes_received=first_body_chunk_size; memcpy(ptr, hcp->first_body_chunk, bytes_received); hcp->first_body_chunk=0; hcp->first_body_chunk_end=0; } else { bytes_received=size; memcpy(ptr, hcp->first_body_chunk, size); hcp->first_body_chunk+=size; } hcp->resp.content_received+=bytes_received; if (hcp->response_body_complete) { // rearm connection request_complete(hcp, loop); nxe_istream_unset_ready(is); *flags|=NXEF_EOF; return bytes_received; } ptr+=bytes_received; size-=bytes_received; } if (size>0) { nxe_istream* prev_is=hcp->data_in.pair; if (prev_is) { nxe_size_t bytes_received2=0; nxe_flags_t rflags=0; if (prev_is->ready) bytes_received2=ISTREAM_CLASS(prev_is)->read(prev_is, &hcp->data_in, ptr, size, &rflags); if (!prev_is->ready) { nxe_istream_unset_ready(is); nxe_ostream_set_ready(loop, &hcp->data_in); // get notified when prev_is becomes ready again } if (hcp->resp.chunked_encoding) { int r=_nxweb_decode_chunked_stream(&hcp->resp.cdstate, ptr, &bytes_received2); hcp->resp.content_received+=bytes_received2; bytes_received+=bytes_received2; 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 { hcp->resp.content_received+=bytes_received2; bytes_received+=bytes_received2; if (hcp->resp.content_received >= hcp->resp.content_length && hcp->resp.content_length>=0) { hcp->response_body_complete=1; } } if (hcp->response_body_complete) { // rearm connection request_complete(hcp, loop); nxe_istream_unset_ready(is); *flags|=NXEF_EOF; return bytes_received; } } else { if (!prev_is) nxweb_log_error("no connected device for hcp->data_in"); nxe_istream_unset_ready(is); } } return bytes_received; }
static void data_out_do_write(nxe_istream* is, nxe_ostream* os) { nxd_http_client_proto* hcp=(nxd_http_client_proto*)((char*)is-offsetof(nxd_http_client_proto, data_out)); nxe_loop* loop=is->super.loop; nxe_unset_timer(loop, NXWEB_TIMER_WRITE, &hcp->timer_write); nxe_set_timer(loop, NXWEB_TIMER_WRITE, &hcp->timer_write); if (hcp->state==HCP_CONNECTING) { nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_CONNECTED); if (hcp->req) hcp->state=HCP_SENDING_HEADERS; else { hcp->state=HCP_IDLE; nxe_set_timer(loop, NXWEB_TIMER_KEEP_ALIVE, &hcp->timer_keep_alive); nxe_istream_unset_ready(is); return; } } if (hcp->state==HCP_SENDING_HEADERS) { if (hcp->req_headers_ptr && *hcp->req_headers_ptr) { int size=strlen(hcp->req_headers_ptr); nxe_flags_t flags=0; int bytes_sent=OSTREAM_CLASS(os)->write(os, is, 0, (nxe_data)hcp->req_headers_ptr, size, &flags); hcp->req_headers_ptr+=bytes_sent; if (bytes_sent<size) return; } // all headers sent hcp->req_headers_ptr=0; if (!hcp->req->content_length) { // no request body => get response start_receiving_response(hcp, loop); return; } if (hcp->req->expect_100_continue) { nxe_istream_unset_ready(is); wait_for_100_continue(hcp, loop); return; } hcp->state=HCP_SENDING_BODY; } if (hcp->state==HCP_SENDING_BODY) { hcp->req_body_sending_started=1; nxe_istream* prev_is=hcp->req_body_in.pair; if (prev_is) { if (prev_is->ready) { hcp->req_body_in.ready=1; ISTREAM_CLASS(prev_is)->do_write(prev_is, &hcp->req_body_in); } if (!prev_is->ready) { nxe_istream_unset_ready(is); nxe_ostream_set_ready(loop, &hcp->req_body_in); // get notified when prev_is becomes ready again } } else { nxweb_log_error("no connected device for hcp->req_body_in"); nxe_istream_unset_ready(is); } } else { // wrong state nxweb_log_error("called data_out_do_write() at wrong HCP state %d", hcp->state); nxe_istream_unset_ready(is); } }