static void cgi_copy_err(chunkqueue *cq) {
buffer *line = buffer_init();
chunk *c;
for (c = cq->first; c; c = c->next) {
off_t we_have;
char *str, *nl;
if (c->type != MEM_CHUNK) {
ERROR("%s", "wrong chunk type");
chunk_set_done(c);
continue;
}
we_have = c->mem->used - 1 - c->offset;
str = c->mem->ptr + c->offset;
if (we_have <= 0) continue;
for ( ; NULL != (nl = strchr(str, '\n')); str = nl+1) {
*nl = '\0';
if (!buffer_is_empty(line)) {
buffer_append_string(line, str);
cgi_log_err(SAFE_BUF_STR(line));
buffer_reset(line);
} else {
cgi_log_err(str);
}
}
if (*str) {
buffer_append_string(line, str);
}
chunk_set_done(c);
}
if (!buffer_is_empty(line)) {
cgi_log_err(SAFE_BUF_STR(line));
}
chunkqueue_remove_finished_chunks(cq);
}
static int http_response_parse_range(server *srv, connection *con, plugin_data *p) {
int multipart = 0;
char *boundary = "fkj49sn38dcn3";
data_string *ds;
stat_cache_entry *sce = NULL;
buffer *content_type = NULL;
buffer *range = NULL;
http_req_range *ranges, *r;
if (NULL != (ds = (data_string *)array_get_element(con->request.headers, CONST_STR_LEN("Range")))) {
range = ds->value;
} else {
/* we don't have a Range header */
return -1;
}
if (HANDLER_ERROR == stat_cache_get_entry(srv, con, con->physical.path, &sce)) {
SEGFAULT("stat_cache_get_entry(%s) returned %d", SAFE_BUF_STR(con->physical.path), HANDLER_ERROR);
}
con->response.content_length = 0;
if (NULL != (ds = (data_string *)array_get_element(con->response.headers, CONST_STR_LEN("Content-Type")))) {
content_type = ds->value;
}
/* start the range-header parser
* bytes=<num> */
ranges = p->ranges;
http_request_range_reset(ranges);
switch (http_request_range_parse(range, ranges)) {
case PARSE_ERROR:
return -1; /* no range valid Range Header */
case PARSE_SUCCESS:
break;
default:
TRACE("%s", "foobar");
return -1;
}
if (ranges->next) {
multipart = 1;
}
/* patch the '-1' */
for (r = ranges; r; r = r->next) {
if (r->start == -1) {
/* -<end>
*
* the last <end> bytes */
r->start = sce->st.st_size - r->end;
r->end = sce->st.st_size - 1;
}
if (r->end == -1) {
/* <start>-
* all but the first <start> bytes */
r->end = sce->st.st_size - 1;
}
if (r->end > sce->st.st_size - 1) {
/* RFC 2616 - 14.35.1
*
* if last-byte-pos not present or > size-of-file
* take the size-of-file
*
* */
r->end = sce->st.st_size - 1;
}
if (r->start > sce->st.st_size - 1) {
/* RFC 2616 - 14.35.1
*
* if first-byte-pos > file-size, 416
*/
con->http_status = 416;
return -1;
}
if (r->start > r->end) {
/* RFC 2616 - 14.35.1
*
* if last-byte-pos is present, it has to be >= first-byte-pos
*
* invalid ranges have to be handle as no Range specified
* */
return -1;
}
}
if (r) {
/* we ran into an range violation */
return -1;
}
if (multipart) {
buffer *b;
for (r = ranges; r; r = r->next) {
/* write boundary-header */
b = chunkqueue_get_append_buffer(con->send);
buffer_copy_string_len(b, CONST_STR_LEN("\r\n--"));
buffer_append_string(b, boundary);
/* write Content-Range */
buffer_append_string_len(b, CONST_STR_LEN("\r\nContent-Range: bytes "));
buffer_append_off_t(b, r->start);
buffer_append_string_len(b, CONST_STR_LEN("-"));
buffer_append_off_t(b, r->end);
buffer_append_string_len(b, CONST_STR_LEN("/"));
buffer_append_off_t(b, sce->st.st_size);
buffer_append_string_len(b, CONST_STR_LEN("\r\nContent-Type: "));
buffer_append_string_buffer(b, content_type);
/* write END-OF-HEADER */
buffer_append_string_len(b, CONST_STR_LEN("\r\n\r\n"));
con->response.content_length += b->used - 1;
con->send->bytes_in += b->used - 1;
chunkqueue_append_file(con->send, con->physical.path, r->start, r->end - r->start + 1);
con->response.content_length += r->end - r->start + 1;
con->send->bytes_in += r->end - r->start + 1;
}
/* add boundary end */
b = chunkqueue_get_append_buffer(con->send);
buffer_copy_string_len(b, "\r\n--", 4);
buffer_append_string(b, boundary);
buffer_append_string_len(b, "--\r\n", 4);
con->response.content_length += b->used - 1;
con->send->bytes_in += b->used - 1;
/* set header-fields */
buffer_copy_string_len(p->range_buf, CONST_STR_LEN("multipart/byteranges; boundary="));
buffer_append_string(p->range_buf, boundary);
/* overwrite content-type */
response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_BUF_LEN(p->range_buf));
} else {
r = ranges;
chunkqueue_append_file(con->send, con->physical.path, r->start, r->end - r->start + 1);
con->response.content_length += r->end - r->start + 1;
con->send->bytes_in += r->end - r->start + 1;
buffer_copy_string_len(p->range_buf, CONST_STR_LEN("bytes "));
buffer_append_off_t(p->range_buf, r->start);
buffer_append_string_len(p->range_buf, CONST_STR_LEN("-"));
buffer_append_off_t(p->range_buf, r->end);
buffer_append_string_len(p->range_buf, CONST_STR_LEN("/"));
buffer_append_off_t(p->range_buf, sce->st.st_size);
response_header_insert(srv, con, CONST_STR_LEN("Content-Range"), CONST_BUF_LEN(p->range_buf));
}
/* ok, the file is set-up */
return 0;
}
int http_response_handle_cachable(server *srv, connection *con, buffer *mtime, buffer *etag) {
data_string *http_if_none_match;
data_string *http_if_modified_since;
UNUSED(srv);
/*
* 14.26 If-None-Match
* [...]
* If none of the entity tags match, then the server MAY perform the
* requested method as if the If-None-Match header field did not exist,
* but MUST also ignore any If-Modified-Since header field(s) in the
* request. That is, if no entity tags match, then the server MUST NOT
* return a 304 (Not Modified) response.
*/
http_if_none_match = (data_string *)array_get_element(con->request.headers, CONST_STR_LEN("if-none-match"));
http_if_modified_since = (data_string *)array_get_element(con->request.headers, CONST_STR_LEN("if-modified-since"));
/* last-modified handling */
if (http_if_none_match) {
if (etag_is_equal(etag, BUF_STR(http_if_none_match->value))) {
if (con->request.http_method == HTTP_METHOD_GET ||
con->request.http_method == HTTP_METHOD_HEAD) {
/* check if etag + last-modified */
if (http_if_modified_since) {
size_t used_len;
char *semicolon;
if (NULL == (semicolon = strchr(BUF_STR(http_if_modified_since->value), ';'))) {
used_len = http_if_modified_since->value->used - 1;
} else {
used_len = semicolon - BUF_STR(http_if_modified_since->value);
}
if (0 == strncmp(BUF_STR(http_if_modified_since->value), mtime->ptr, used_len)) {
if ('\0' == mtime->ptr[used_len]) con->http_status = 304;
return HANDLER_FINISHED;
} else {
#ifdef HAVE_STRPTIME
char buf[sizeof("Sat, 23 Jul 2005 21:20:01 GMT")];
time_t t_header, t_file;
struct tm tm;
/* check if we can safely copy the string */
if (used_len >= sizeof(buf)) {
TRACE("last-mod check failed as timestamp was too long: %s: %zu, %zu",
SAFE_BUF_STR(http_if_modified_since->value),
used_len, sizeof(buf) - 1);
con->http_status = 412;
return HANDLER_FINISHED;
}
strncpy(buf, BUF_STR(http_if_modified_since->value), used_len);
buf[used_len] = '\0';
if (NULL == strptime(buf, "%a, %d %b %Y %H:%M:%S GMT", &tm)) {
con->http_status = 412;
return HANDLER_FINISHED;
}
tm.tm_isdst = 0;
t_header = mktime(&tm);
strptime(mtime->ptr, "%a, %d %b %Y %H:%M:%S GMT", &tm);
tm.tm_isdst = 0;
t_file = mktime(&tm);
if (t_file > t_header) return HANDLER_GO_ON;
con->http_status = 304;
return HANDLER_FINISHED;
#else
return HANDLER_GO_ON;
#endif
}
} else {
con->http_status = 304;
return HANDLER_FINISHED;
}
} else {
con->http_status = 412;
return HANDLER_FINISHED;
}
}
} else if (http_if_modified_since) {
size_t used_len;
char *semicolon;
if (NULL == (semicolon = strchr(BUF_STR(http_if_modified_since->value), ';'))) {
used_len = http_if_modified_since->value->used - 1;
} else {
used_len = semicolon - BUF_STR(http_if_modified_since->value);
}
if (0 == strncmp(BUF_STR(http_if_modified_since->value), mtime->ptr, used_len)) {
if ('\0' == mtime->ptr[used_len]) con->http_status = 304;
return HANDLER_FINISHED;
} else {
#ifdef HAVE_STRPTIME
char buf[sizeof("Sat, 23 Jul 2005 21:20:01 GMT")];
time_t t_header, t_file;
struct tm tm;
/* convert to timestamp */
if (used_len >= sizeof(buf)) return HANDLER_GO_ON;
strncpy(buf, BUF_STR(http_if_modified_since->value), used_len);
buf[used_len] = '\0';
if (NULL == strptime(buf, "%a, %d %b %Y %H:%M:%S GMT", &tm)) {
return HANDLER_GO_ON;
}
tm.tm_isdst = 0;
t_header = mktime(&tm);
strptime(mtime->ptr, "%a, %d %b %Y %H:%M:%S GMT", &tm);
tm.tm_isdst = 0;
t_file = mktime(&tm);
if (t_file > t_header) return HANDLER_GO_ON;
con->http_status = 304;
return HANDLER_FINISHED;
#else
return HANDLER_GO_ON;
#endif
}
}
return HANDLER_GO_ON;
}
