int
send_request(Request req)
{
if (! req->socket ) {
req->socket = connect_socket(req->host,req->port,0);
if (! req->socket) {
error("Failed to connect to %s:%i\n",req->host,req->port);
return 0;
}
add_req_socket(req->socket->fd);
return 0;
}
if (req->length < 0) {
str cmd = _("%s %s HTTP/1.1\r\n",req->method,req->path);
write_socket(req->socket,cmd);
request_headers(req,_("Host"),req->host);
send_headers(req->socket,req->headers);
req->length = outbound_content_length(req->contents,req->raw_contents);
return req->contents != NULL || req->raw_contents != NULL ;
}
req->written += req->contents ?
send_contents(req->socket,req->contents,is_chunked(req->headers)) :
req->raw_contents ?
send_raw_contents(req->socket,req->raw_contents,req->written,0):
0;
if (is_chunked(req->headers) && req->written >= req->length)
write_chunk(req->socket,NULL,0);
return req->written < req->length;
}
void
dechunk_request()
{
if (!is_chunked(client.request->headers)) return;
str hed = from(client.request->contents,0,client.request->body);
str con = dechunk(client.request->contents);
client.request->contents = append(hed,con);
}
void
dechunk_response()
{
if (is_chunked(client.response->headers)) {
str hed = ref(client.response->contents->data,client.response->body);
str con = dechunk(client.response->contents);
client.response->contents = append(hed,con);
}
}
uint32 put_data_to_response(HTTP_RESPONSE* response, const char* p_data, const uint32 data_len)
{
uint32 ret = SUCCEEDED;
uint32 value = 0;
uint32 temp_len = 0;
char* data_index = p_data;
char* temp_p = 0;
if (response == 0 || p_data == 0 || data_len == 0)
return 0;
if (response->header.result == 0)
{
ret = http_get_response_result(p_data, data_len, &value);
printf("on put_data_to_response result:%d\r\n", value);
if (ret != SUCCEEDED) return 0;
response->header.result = value;
}
if (response->header.header == 0)
{
data_index = strstr(p_data, "\r\n\r\n");
if (data_index == 0)
{
if (response->content == 0)
{
response->content = (char*)malloc(data_len);
response->content_len = data_len;
memcpy(response->content, p_data, data_len);
}
else
{
temp_p = response->content;
temp_len = response->content_len;
response->content = (char*)malloc(data_len + temp_len);
response->content_len = data_len + temp_len;
memcpy(response->content, temp_p, temp_len);
memcpy(response->content + temp_len, p_data, data_len);
free(temp_p);
}
}
else
{
temp_len = data_index - p_data;
if (response->content && response->content_len)
{
response->header.header = (char*)malloc(temp_len + response->content_len + 1);
response->header.header_len = temp_len + response->content_len;
memcpy(response->header.header, response->content, response->content_len);
memcpy(response->header.header + response->content_len, p_data, data_len);
response->header.header[response->header.header_len] = '\0';
free(response->content);
response->content = 0;
response->content_len = 0;
}
else
{
response->header.header = (char*)malloc(temp_len + 1);
memcpy(response->header.header, p_data, temp_len);
response->header.header[temp_len] = '\0';
response->header.header_len = temp_len;
}
ret = get_http_response_int_value_for_key(response->header.header, "Content-Length", &value);
if(ret == SUCCEEDED)
response->header.content_len = value;
else
response->header.content_len = (uint32)-1;
response->header.chunked = is_chunked(response->header.header);
if (data_len > temp_len + 4)
{
data_index += 4;
temp_len += 4;
return http_fill_body_data(response, data_index, data_len - temp_len);
}
return 1;
}
}
return http_fill_body_data(response, p_data, data_len);
}
