webserver: comparison src/server/proxy/httpclient.c

-:c7b73000a1ed
+:4d8a55a7618b
 ret = ev_pollout(client->ev, socketfd, &client->writeev);
 } else {
 log_ereport(LOG_FAILURE, "http-client-start: connect failed: %s", strerror(err));
 }
 } else {
-// TODO: call client_connected directly
+ret = 0; // TODO
 }
 if(ret) {
 close(socketfd);
 }
 return client_io(ev, event);
 }
 static int client_io(EventHandler *ev, Event *event) {
 HttpClient *client = event->cookie;
-if(client->transfer_buffer_pos < client->transfer_buffer_len) {
+if(client->stage == 0) {
-if(client_send_request(client)) {
+if(client->transfer_buffer_pos < client->transfer_buffer_len) {
-return client->error == 0;
+if(client_send_request(client)) {
-}
+return client->error == 0;
 }
+}
-// do we need to send a request body?
-if(client->req_content_length != 0) {
+// do we need to send a request body?
-if(client_send_request_body(client)) {
+if(client->req_content_length != 0) {
-return client->error == 0;
+if(client_send_request_body(client)) {
+return client->error == 0;
+}
 }
 }
 // writing complete, switch to read events
 event->events = EVENT_POLLIN;
+client->stage = 1;
+client->transfer_buffer_pos = 0;
+client->transfer_buffer_len = 0;
 if(client_read_response_header(client)) {
 return client->error == 0;
 }
 if(client_read_response_body(client)) {
 }
 return 0;
 }
+// returns 0 success
+//         1 would block or error
 static int client_read_response_header(HttpClient *client) {
 if(client->response_header_complete) {
 return 0;
 }
 char t = msg.ptr[msg.length];
 msg.ptr[msg.length] = 0;
 int ret = client->response_start(client, client->statuscode, msg.ptr, client->response_start_userdata);
 msg.ptr[msg.length] = t;
-// TODO: check ret
+if(ret != 0) {
+if(ret != HTTP_CLIENT_CALLBACK_WOULD_BLOCK) {
+client->error = 1;
+}
+return 1;
+}
 }
 break;
 }
 case 1: { // need more data
 continue;
 }
 return 0;
 }
+// uses the response_body_write callback to write the content of the
+// transfer buffer
+// returns 0 success
+//         1 would block or error
+static int client_write_response(HttpClient *client) {
+while(client->transfer_buffer_pos < client->transfer_buffer_len) {
+char *buf = client->transfer_buffer + client->transfer_buffer_pos;
+size_t len = client->transfer_buffer_len - client->transfer_buffer_pos;
+int ret = client->response_body_write(client, buf, len, client->response_body_write_userdata);
+if(ret > 0) {
+client->transfer_buffer_pos += ret;
+} else if(ret == 0) {
+// EOF?
+// check if the write is incomplete, which would be an error
+client->error == client->transfer_buffer_pos < client->transfer_buffer_len;
+return client->error;
+} else {
+if(ret != HTTP_CLIENT_CALLBACK_WOULD_BLOCK) {
+client->error = 1;
+}
+return 1;
+}
+}
+return 0;
+}
+// returns 0 success
+//         1 would block or error
 static int client_read_response_body(HttpClient *client) {
 if(!client->stream) {
 return 0; // no input stream -> no response body
 }
+// does the transfer buffer still contains bytes, that should be written?
+if(client_write_response(client)) {
+return 1;
+}
 char *buf = client->transfer_buffer;
 size_t nbytes = client->transfer_buffer_alloc;
 ssize_t r;
 while((r = net_read(&client->stream->st, buf, nbytes)) > 0) {
+client->transfer_buffer_len = r;
+client->transfer_buffer_pos = 0;
 if(client->response_body_write) {
-int ret = client->response_body_write(client, buf, r, client->response_body_write_userdata);
+if(client_write_response(client)) {
-// TODO: check ret
+return 1;
+}
 }
 }
 if(r < 0) {
 if(client->stream->st.io_errno != EWOULDBLOCK) {
 static CX_TEST_SUBROUTINE(test_read_response, cxstring response_str, CxBuffer *response_body) {
 EventHandler dummy;
 HttpClient *client = http_client_new(&dummy);
 create_req_buffer(client);
+client->transfer_buffer_pos = 0;
+client->transfer_buffer_len = 0;
 client->req_content_length = -1;
 int fds[2];
 util_socketpair(fds);
 util_socket_setnonblock(fds[0], 1);

Mercurial > hg > webserver / file comparison

comparison: src/server/proxy/httpclient.c

src/server/proxy/httpclient.c