static void websocket_perform_handshake(full_subscriber_t *fsub) {
static ngx_str_t magic = ngx_string("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
ngx_str_t ws_accept_key, sha1_str;
u_char buf_sha1[21];
u_char buf[255];
ngx_str_t *tmp, *ws_key;
ngx_int_t ws_version;
ngx_http_request_t *r = fsub->sub.request;
ngx_sha1_t sha1;
ws_accept_key.data = buf;
r->headers_out.content_length_n = 0;
r->header_only = 1;
if((tmp = nchan_get_header_value(r, NCHAN_HEADER_SEC_WEBSOCKET_VERSION)) == NULL) {
r->headers_out.status = NGX_HTTP_BAD_REQUEST;
fsub->sub.dequeue_after_response=1;
}
else {
ws_version=ngx_atoi(tmp->data, tmp->len);
if(ws_version != 13) {
r->headers_out.status = NGX_HTTP_BAD_REQUEST;
fsub->sub.dequeue_after_response=1;
}
}
if((ws_key = nchan_get_header_value(r, NCHAN_HEADER_SEC_WEBSOCKET_KEY)) == NULL) {
r->headers_out.status = NGX_HTTP_BAD_REQUEST;
fsub->sub.dequeue_after_response=1;
}
if(r->headers_out.status != NGX_HTTP_BAD_REQUEST) {
//generate accept key
ngx_sha1_init(&sha1);
ngx_sha1_update(&sha1, ws_key->data, ws_key->len);
ngx_sha1_update(&sha1, magic.data, magic.len);
ngx_sha1_final(buf_sha1, &sha1);
sha1_str.len=20;
sha1_str.data=buf_sha1;
ws_accept_key.len=ngx_base64_encoded_length(sha1_str.len);
assert(ws_accept_key.len < 255);
ngx_encode_base64(&ws_accept_key, &sha1_str);
nchan_include_access_control_if_needed(r, fsub->ctx);
nchan_add_response_header(r, &NCHAN_HEADER_SEC_WEBSOCKET_ACCEPT, &ws_accept_key);
nchan_add_response_header(r, &NCHAN_HEADER_UPGRADE, &NCHAN_WEBSOCKET);
#if nginx_version < 1003013
nchan_add_response_header(r, &NCHAN_HEADER_CONNECTION, &NCHAN_UPGRADE);
#endif
r->headers_out.status_line = NCHAN_HTTP_STATUS_101;
r->headers_out.status = NGX_HTTP_SWITCHING_PROTOCOLS;
r->keepalive=0; //apparently, websocket must not use keepalive.
}
ngx_http_send_header(r);
}
ngx_int_t nchan_respond_string(ngx_http_request_t *r, ngx_int_t status_code, const ngx_str_t *content_type, const ngx_str_t *body, ngx_int_t finalize) {
ngx_int_t rc = NGX_OK;
ngx_buf_t *b = REQUEST_PCALLOC(r, b);
ngx_chain_t *chain = REQUEST_PALLOC(r, chain);
//assume both were alloc'd fine
r->headers_out.status=status_code;
r->headers_out.content_length_n = body->len;
if(content_type) {
r->headers_out.content_type.len = content_type->len;
r->headers_out.content_type.data = content_type->data;
}
nchan_include_access_control_if_needed(r, NULL);
if ((!b) || (!chain)) {
ERR("Couldn't allocate ngx buf or chain.");
r->headers_out.status=NGX_HTTP_INTERNAL_SERVER_ERROR;
r->headers_out.content_length_n = 0;
r->header_only = 1;
ngx_http_send_header(r);
rc=NGX_ERROR;
}
else {
chain->buf=b;
chain->next=NULL;
b->last_buf = 1;
b->last_in_chain = 1;
b->flush = 1; //flush just to be sure, although I should perhaps rethink this
b->memory = 1;
b->start = body->data;
b->pos = body->data;
b->end = body->data + body->len;
b->last = b->end;
if ((rc = ngx_http_send_header(r)) == NGX_OK) {
rc= nchan_output_filter(r, chain);
}
}
if(finalize) {
nchan_http_finalize_request(r, rc);
}
return rc;
}
ngx_int_t nchan_respond_status(ngx_http_request_t *r, ngx_int_t status_code, const ngx_str_t *status_line, ngx_int_t finalize) {
ngx_int_t rc = NGX_OK;
r->headers_out.status=status_code;
if(status_line!=NULL) {
r->headers_out.status_line.len =status_line->len;
r->headers_out.status_line.data=status_line->data;
}
r->headers_out.content_length_n = 0;
r->header_only = 1;
nchan_include_access_control_if_needed(r, NULL);
rc= ngx_http_send_header(r);
if(finalize) {
ngx_http_finalize_request(r, rc);
}
return rc;
}
ngx_int_t nchan_cleverly_output_headers_only_for_later_response(ngx_http_request_t *r) {
ngx_int_t rc;
static const ngx_str_t everything_ok = ngx_string("200 OK");
r->headers_out.status_line = everything_ok; //but in reality, we're returning a 200 OK
#if (NGX_HTTP_V2)
if(r->stream) {
r->headers_out.status=NGX_HTTP_OK; //no need to fool chunking module
r->header_only = 0;
}
else {
r->headers_out.status=NGX_HTTP_NO_CONTENT; //fake it to fool the chunking module (mostly);
r->header_only = 1;
}
#elif (NGX_HTTP_SPDY)
if(r->spdy_stream) {
r->headers_out.status=NGX_HTTP_OK; //no need to fool chunking module
r->header_only = 0;
}
else {
r->headers_out.status=NGX_HTTP_NO_CONTENT; //fake it to fool the chunking module (mostly);
r->header_only = 1;
}
#else
r->headers_out.status=NGX_HTTP_NO_CONTENT; //fake it to fool the chunking module (mostly);
r->header_only = 1;
#endif
nchan_include_access_control_if_needed(r, NULL);
rc = ngx_http_send_header(r);
if(r->headers_out.status == NGX_HTTP_OK) {
r->keepalive = 1;
}
return rc;
}
ngx_int_t nchan_respond_msg(ngx_http_request_t *r, nchan_msg_t *msg, nchan_msg_id_t *msgid, ngx_int_t finalize, char **err) {
ngx_buf_t *buffer = &msg->buf;
nchan_buf_and_chain_t *cb;
ngx_int_t rc;
ngx_chain_t *rchain = NULL;
ngx_buf_t *rbuffer;
nchan_request_ctx_t *ctx = ngx_http_get_module_ctx(r, ngx_nchan_module);
if(ngx_buf_size(buffer) > 0) {
cb = ngx_palloc(r->pool, sizeof(*cb));
if (!cb) {
if(err) *err = "couldn't allocate memory for buf-and-chain while responding with msg";
return NGX_ERROR;
}
rchain = &cb->chain;
rbuffer = &cb->buf;
rchain->next = NULL;
rchain->buf = rbuffer;
ngx_memcpy(rbuffer, buffer, sizeof(*buffer));
nchan_msg_buf_open_fd_if_needed(rbuffer, NULL, r);
r->headers_out.content_length_n=ngx_buf_size(rbuffer);
}
else {
r->headers_out.content_length_n = 0;
r->header_only = 1;
}
if (msg->content_type) {
r->headers_out.content_type = *msg->content_type;
}
if(msgid == NULL) {
msgid = &msg->id;
}
if(nchan_set_msgid_http_response_headers(r, ctx, msgid) != NGX_OK) {
if(err) *err = "can't set msgid headers";
return NGX_ERROR;
}
r->headers_out.status=NGX_HTTP_OK;
nchan_include_access_control_if_needed(r, ctx);
//we know the entity length, and we're using just one buffer. so no chunking please.
if((rc = ngx_http_send_header(r)) >= NGX_HTTP_SPECIAL_RESPONSE) {
ERR("request %p, send_header response %i", r, rc);
if(err) *err="WTF just happened to request?";
return NGX_ERROR;
}
if(rchain) {
rc= nchan_output_filter(r, rchain);
if(rc != NGX_OK && err) *err="failed to write data to connection socket, probably because the connection got closed";
}
if(finalize) {
nchan_http_finalize_request(r, rc);
}
return rc;
}
static ngx_int_t longpoll_multipart_respond(full_subscriber_t *fsub) {
ngx_http_request_t *r = fsub->sub.request;
nchan_request_ctx_t *ctx = ngx_http_get_module_ctx(r, ngx_nchan_module);
char *err;
ngx_int_t rc;
u_char *char_boundary = NULL;
u_char *char_boundary_last;
ngx_buf_t boundary[3]; //first, mid, and last boundary
ngx_buf_t newline_buf;
ngx_chain_t *chain, *first_chain = NULL, *last_chain = NULL;
ngx_buf_t *buf;
ngx_buf_t double_newline_buf;
ngx_str_t *content_type;
size_t size = 0;
nchan_loc_conf_t *cf = fsub->sub.cf;
int use_raw_stream_separator = cf->longpoll_multimsg_use_raw_stream_separator;
nchan_buf_and_chain_t *bc;
nchan_longpoll_multimsg_t *first, *cur;
//disable abort handler
fsub->data.cln->handler = empty_handler;
first = fsub->data.multimsg_first;
fsub->sub.dequeue_after_response = 1;
//cleanup to release msgs
fsub->data.cln = ngx_http_cleanup_add(fsub->sub.request, 0);
fsub->data.cln->data = first;
fsub->data.cln->handler = (ngx_http_cleanup_pt )multipart_request_cleanup_handler;
if(fsub->data.multimsg_first == fsub->data.multimsg_last) {
//just one message.
if((rc = nchan_respond_msg(r, fsub->data.multimsg_first->msg, &fsub->sub.last_msgid, 0, &err)) != NGX_OK) {
return abort_response(&fsub->sub, err);
}
return NGX_OK;
}
//multi messages
if(!use_raw_stream_separator) {
nchan_request_set_content_type_multipart_boundary_header(r, ctx);
char_boundary = ngx_palloc(r->pool, 50);
char_boundary_last = ngx_snprintf(char_boundary, 50, ("\r\n--%V--\r\n"), nchan_request_multipart_boundary(r, ctx));
ngx_init_set_membuf_char(&double_newline_buf, "\r\n\r\n");
//set up the boundaries
ngx_init_set_membuf(&boundary[0], &char_boundary[2], &char_boundary_last[-4]);
ngx_init_set_membuf(&boundary[1], &char_boundary[0], &char_boundary_last[-4]);
ngx_init_set_membuf(&boundary[2], &char_boundary[0], char_boundary_last);
ngx_init_set_membuf_char(&newline_buf, "\n");
}
int n=0;
for(cur = first; cur != NULL; cur = cur->next) {
bc = nchan_bufchain_pool_reserve(ctx->bcp, 4);
chain = &bc->chain;
n++;
if(last_chain) {
last_chain->next = chain;
}
if(!first_chain) {
first_chain = chain;
}
if(!use_raw_stream_separator) {
// each buffer needs to be unique for the purpose of dealing with nginx output guts
// (something about max. 64 iovecs per write call and counting the number of bytes already sent)
*chain->buf = cur == first ? boundary[0] : boundary[1];
size += ngx_buf_size((chain->buf));
chain = chain->next;
content_type = &cur->msg->content_type;
buf = chain->buf;
if (content_type->data != NULL) {
u_char *char_cur = ngx_pcalloc(r->pool, content_type->len + 25);
ngx_init_set_membuf(buf, char_cur, ngx_snprintf(char_cur, content_type->len + 25, "\r\nContent-Type: %V\r\n\r\n", content_type));
}
else {
*buf = double_newline_buf;
}
size += ngx_buf_size(buf);
chain = chain->next;
}
if(ngx_buf_size(cur->msg->buf) > 0) {
buf = chain->buf;
*buf = *cur->msg->buf;
if(buf->file) {
ngx_file_t *file_copy = nchan_bufchain_pool_reserve_file(ctx->bcp);
nchan_msg_buf_open_fd_if_needed(buf, file_copy, NULL);
}
buf->last_buf = 0;
size += ngx_buf_size(buf);
}
if(use_raw_stream_separator) {
chain = chain->next;
ngx_init_set_membuf_str(chain->buf, &cf->subscriber_http_raw_stream_separator);
size += ngx_buf_size((chain->buf));
}
else {
if(cur->next == NULL) {
chain = chain->next;
chain->buf = &boundary[2];
size += ngx_buf_size((chain->buf));
}
}
last_chain = chain;
}
buf = last_chain->buf;
buf->last_buf = 1;
buf->last_in_chain = 1;
buf->flush = 1;
last_chain->next = NULL;
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_length_n = size;
nchan_set_msgid_http_response_headers(r, ctx, &fsub->data.multimsg_last->msg->id);
nchan_include_access_control_if_needed(r, ctx);
ngx_http_send_header(r);
nchan_output_filter(r, first_chain);
return NGX_OK;
}
static ngx_int_t longpoll_multipart_respond(full_subscriber_t *fsub) {
ngx_http_request_t *r = fsub->sub.request;
nchan_request_ctx_t *ctx = ngx_http_get_module_ctx(r, nchan_module);
char *err;
ngx_int_t rc;
u_char char_boundary[50];
u_char *char_boundary_last;
ngx_int_t i;
ngx_buf_t boundary[3]; //first, mid, and last boundary
ngx_chain_t *chains, *first_chain = NULL, *last_chain = NULL;
ngx_buf_t *buf;
ngx_buf_t double_newline_buf;
ngx_str_t *content_type;
size_t size = 0;
nchan_longpoll_multimsg_t *first, *cur;
//disable abort handler
fsub->data.cln->handler = empty_handler;
first = fsub->data.multimsg_first;
fsub->sub.dequeue_after_response = 1;
//cleanup to release msgs
fsub->data.cln = ngx_http_cleanup_add(fsub->sub.request, 0);
fsub->data.cln->data = first;
fsub->data.cln->handler = (ngx_http_cleanup_pt )multipart_request_cleanup_handler;
if(fsub->data.multimsg_first == fsub->data.multimsg_last) {
//just one message.
if((rc = nchan_respond_msg(r, fsub->data.multimsg_first->msg, &fsub->sub.last_msgid, 0, &err)) != NGX_OK) {
return abort_response(&fsub->sub, err);
}
return NGX_OK;
}
//multi messages
nchan_request_set_content_type_multipart_boundary_header(r, ctx);
char_boundary_last = ngx_snprintf(char_boundary, 50, ("\r\n--%V--\r\n"), nchan_request_multipart_boundary(r, ctx));
ngx_memzero(&double_newline_buf, sizeof(double_newline_buf));
double_newline_buf.start = (u_char *)"\r\n\r\n";
double_newline_buf.end = double_newline_buf.start + 4;
double_newline_buf.pos = double_newline_buf.start;
double_newline_buf.last = double_newline_buf.end;
double_newline_buf.memory = 1;
//set up the boundaries
for(i=0; i<3; i++) {
ngx_memzero(&boundary[i], sizeof(ngx_buf_t));
boundary[i].memory = 1;
if(i==0) {
boundary[i].start = &char_boundary[2];
boundary[i].end = &char_boundary_last[-4];
}
else if(i==1) {
boundary[i].start = &char_boundary[0];
boundary[i].end = &char_boundary_last[-4];
}
else if(i==2) {
boundary[i].start = &char_boundary[0];
boundary[i].end = char_boundary_last;
boundary[i].last_buf = 1;
boundary[i].last_in_chain = 1;
boundary[i].flush = 1;
}
boundary[i].pos = boundary[i].start;
boundary[i].last = boundary[i].end;
}
int n=0;
for(cur = first; cur != NULL; cur = cur->next) {
chains = ngx_palloc(r->pool, sizeof(*chains)*4);
n++;
if(last_chain) {
last_chain->next = &chains[0];
}
if(!first_chain) {
first_chain = &chains[0];
}
// each buffer needs to be unique for the purpose of dealing with nginx output guts
// (something about max. 64 iovecs per write call and counting the number of bytes already sent)
buf = ngx_pcalloc(r->pool, sizeof(*buf));
*buf = cur == first ? boundary[0] : boundary[1];
chains[0].buf = buf;
chains[0].next = &chains[1];
size += ngx_buf_size(chains[0].buf);
content_type = &cur->msg->content_type;
if (content_type->data != NULL) {
buf = ngx_pcalloc(r->pool, sizeof(*buf) + content_type->len + 25);
buf->memory = 1;
buf->start = (u_char *)&buf[1];
buf->end = ngx_snprintf(buf->start, content_type->len + 25, "\r\nContent-Type: %V\r\n\r\n", content_type);
buf->pos = buf->start;
buf->last = buf->end;
chains[1].buf = buf;
}
else {
buf = ngx_palloc(r->pool, sizeof(*buf));
chains[1].buf = buf;
*buf = double_newline_buf;
}
size += ngx_buf_size(chains[1].buf);
if(ngx_buf_size(cur->msg->buf) > 0) {
chains[1].next = &chains[2];
buf = ngx_palloc(r->pool, sizeof(*buf));
*buf = *cur->msg->buf;
nchan_msg_buf_open_fd_if_needed(buf, NULL, r);
buf->last_buf = 0;
chains[2].buf = buf;
size += ngx_buf_size(chains[2].buf);
last_chain = &chains[2];
}
else {
last_chain = &chains[1];
}
if(cur->next == NULL) {
last_chain->next = &chains[3];
chains[3].buf = &boundary[2];
chains[3].next = NULL;
last_chain = &chains[3];
size += ngx_buf_size(chains[3].buf);
}
}
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_length_n = size;
nchan_set_msgid_http_response_headers(r, ctx, &fsub->data.multimsg_last->msg->id);
nchan_include_access_control_if_needed(r, ctx);
ngx_http_send_header(r);
nchan_output_filter(r, first_chain);
return NGX_OK;
}
