static int uwsgi_wevdav_manage_put(struct wsgi_request *wsgi_req) {
char filename[PATH_MAX];
size_t filename_len = uwsgi_webdav_expand_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
// the collection does not exist, search for the last /
if (!filename_len) {
filename_len = uwsgi_webdav_expand_fake_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
if (!filename_len) {
uwsgi_response_prepare_headers(wsgi_req, "409 Conflict", 12);
return UWSGI_OK;
}
}
int fd = open(filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (fd < 0) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
if (uwsgi_response_prepare_headers(wsgi_req, "201 Created", 11)) goto end;
size_t remains = wsgi_req->post_cl;
while(remains > 0) {
ssize_t body_len = 0;
char *body = uwsgi_request_body_read(wsgi_req, UMIN(remains, 32768) , &body_len);
if (!body || body == uwsgi.empty) break;
if (write(fd, body, body_len) != body_len) goto end;
}
end:
close(fd);
return UWSGI_OK;
}
static int sapi_uwsgi_send_headers(sapi_headers_struct *sapi_headers)
{
sapi_header_struct *h;
zend_llist_position pos;
if (SG(request_info).no_headers == 1) {
return SAPI_HEADER_SENT_SUCCESSFULLY;
}
struct wsgi_request *wsgi_req = (struct wsgi_request *) SG(server_context);
if (!SG(sapi_headers).http_status_line) {
char status[4];
int hrc = SG(sapi_headers).http_response_code;
if (!hrc) hrc = 200;
uwsgi_num2str2n(hrc, status, 4);
uwsgi_response_prepare_headers(wsgi_req, status, 3);
}
else {
char *sl = SG(sapi_headers).http_status_line;
uwsgi_response_prepare_headers(wsgi_req, sl, strlen(sl));
}
h = zend_llist_get_first_ex(&sapi_headers->headers, &pos);
while (h) {
uwsgi_response_add_header(wsgi_req, NULL, 0, h->header, h->header_len);
h = zend_llist_get_next_ex(&sapi_headers->headers, &pos);
}
return SAPI_HEADER_SENT_SUCCESSFULLY;
}
static int uwsgi_wevdav_manage_mkcol(struct wsgi_request *wsgi_req) {
if (wsgi_req->post_cl > 0) {
uwsgi_response_prepare_headers(wsgi_req, "415 Unsupported Media Type", 26);
return UWSGI_OK;
}
char filename[PATH_MAX];
size_t filename_len = uwsgi_webdav_expand_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
// the collection already exists
if (filename_len > 0) {
uwsgi_response_prepare_headers(wsgi_req, "405 Method Not Allowed", 22);
return UWSGI_OK;
}
// remove the last slash (if needed)
if (wsgi_req->path_info_len > 1 && wsgi_req->path_info[wsgi_req->path_info_len-1] == '/') {
wsgi_req->path_info_len--;
}
filename_len = uwsgi_webdav_expand_fake_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
if (!filename_len) {
uwsgi_response_prepare_headers(wsgi_req, "409 Conflict", 12);
return UWSGI_OK;
}
// mkdir, if it fails, return a 409 (Conflict)
if (mkdir(filename, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
uwsgi_response_prepare_headers(wsgi_req, "409 Conflict", 12);
}
uwsgi_response_prepare_headers(wsgi_req, "201 Created", 11);
return UWSGI_OK;
}
static int uwsgi_wevdav_manage_mkcalendar(struct wsgi_request *wsgi_req, xmlDoc *doc) {
char filename[PATH_MAX];
size_t filename_len = uwsgi_webdav_expand_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
// the collection already exists
if (filename_len > 0) {
uwsgi_response_prepare_headers(wsgi_req, "405 Method Not Allowed", 22);
return UWSGI_OK;
}
// remove the last slash (if needed)
if (wsgi_req->path_info_len > 1 && wsgi_req->path_info[wsgi_req->path_info_len-1] == '/') {
wsgi_req->path_info_len--;
}
filename_len = uwsgi_webdav_expand_fake_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
if (!filename_len) {
uwsgi_response_prepare_headers(wsgi_req, "409 Conflict", 12);
return UWSGI_OK;
}
// mkdir, if it fails, return a 409 (Conflict)
if (mkdir(filename, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
uwsgi_response_prepare_headers(wsgi_req, "409 Conflict", 12);
return UWSGI_OK;
}
xmlNode *element = xmlDocGetRootElement(doc);
if (!element) return -1;
if (!element || (strcmp((char *) element->name, "mkcalendar"))) return -1;
xmlDoc *rdoc = xmlNewDoc(BAD_CAST "1.0");
xmlNode *foobar = xmlNewNode(NULL, BAD_CAST "foobar");
xmlDocSetRootElement(rdoc, foobar);
// propfind can be "set" or "remove"
xmlNode *node;
for (node = element->children; node; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
if (node->ns && !strcmp((char *) node->ns->href, "DAV:")) {
if (!strcmp((char *) node->name, "set")) {
uwsgi_webdav_manage_prop_update(wsgi_req, node, foobar, filename, 0);
}
}
}
}
uwsgi_response_prepare_headers(wsgi_req, "201 Created", 11);
xmlFreeDoc(rdoc);
return UWSGI_OK;
}
static int uwsgi_routing_func_basicauth(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
// skip if already authenticated
if (wsgi_req->remote_user_len > 0) {
return UWSGI_ROUTE_NEXT;
}
if (wsgi_req->authorization_len > 7 && ur->data2_len > 0) {
if (strncmp(wsgi_req->authorization, "Basic ", 6))
goto forbidden;
size_t auth_len = 0;
char *auth = uwsgi_base64_decode(wsgi_req->authorization+6, wsgi_req->authorization_len-6, &auth_len);
if (auth) {
if (!ur->custom) {
// check htpasswd-like file
uint16_t ulen = htpasswd_check(ur->data2, auth);
if (ulen > 0) {
wsgi_req->remote_user = uwsgi_req_append(wsgi_req, "REMOTE_USER", 11, auth, ulen);
if (!wsgi_req->remote_user) {
free(auth);
goto forbidden;
}
wsgi_req->remote_user_len = ulen;
}
else if (ur->data3_len == 0) {
free(auth);
goto forbidden;
}
}
else {
if (!uwsgi_strncmp(auth, auth_len, ur->data2, ur->data2_len)) {
wsgi_req->remote_user = uwsgi_req_append(wsgi_req, "REMOTE_USER", 11, auth, ur->custom);
if (!wsgi_req->remote_user) {
free(auth);
goto forbidden;
}
wsgi_req->remote_user_len = ur->custom;
}
else if (ur->data3_len == 0) {
free(auth);
goto forbidden;
}
}
free(auth);
return UWSGI_ROUTE_NEXT;
}
}
forbidden:
if (uwsgi_response_prepare_headers(wsgi_req, "401 Authorization Required", 26)) goto end;
char *realm = uwsgi_concat3n("Basic realm=\"", 13, ur->data, ur->data_len, "\"", 1);
// no need to check for errors
uwsgi_response_add_header(wsgi_req, "WWW-Authenticate", 16, realm, 13 + ur->data_len + 1);
free(realm);
uwsgi_response_write_body_do(wsgi_req, "Unauthorized", 12);
end:
return UWSGI_ROUTE_BREAK;
}
static int uwsgi_routing_func_ssi(struct wsgi_request *wsgi_req, struct uwsgi_route *ur){
struct uwsgi_buffer *ub = NULL;
char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
struct uwsgi_buffer *ub_filename = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, ur->data, ur->data_len);
if (!ub_filename) goto end;
struct uwsgi_buffer *ub_ssi = uwsgi_buffer_from_file(ub_filename->buf);
uwsgi_buffer_destroy(ub_filename);
if (!ub_ssi) goto end;
ub = uwsgi_ssi_parse(wsgi_req, ub_ssi->buf, ub_ssi->pos);
uwsgi_buffer_destroy(ub_ssi);
if (!ub) goto end;
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto end;
if (uwsgi_response_add_content_length(wsgi_req, ub->pos)) goto end;
if (uwsgi_response_add_content_type(wsgi_req, "text/html", 9)) goto end;
uwsgi_response_write_body_do(wsgi_req, ub->buf, ub->pos);
end:
if (ub) uwsgi_buffer_destroy(ub);
return UWSGI_ROUTE_BREAK;
}
static int uwsgi_wevdav_manage_delete(struct wsgi_request *wsgi_req) {
char filename[PATH_MAX];
size_t filename_len = uwsgi_webdav_expand_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
// the collection does not exists
if (!filename_len) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
if (uwsgi_is_dir(filename)) {
int ret = rmdir(filename);
if (ret < 0) {
if (errno == ENOTEMPTY) {
if (uwsgi_webdav_massive_delete(filename)) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
}
else {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
}
}
else {
if (unlink(filename)) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
}
uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6);
return UWSGI_OK;
}
static int uwsgi_ssi_request(struct wsgi_request *wsgi_req) {
struct uwsgi_buffer *ub = NULL;
if (uwsgi_parse_vars(wsgi_req)) {
return -1;
}
if (!wsgi_req->document_root_len || !wsgi_req->path_info_len) {
uwsgi_log("[uwsgi-ssi] DOCUMENT_ROOT and PATH_INFO must be defined !!!\n");
uwsgi_500(wsgi_req);
return UWSGI_OK;
}
char *filename = uwsgi_concat3n(wsgi_req->document_root, wsgi_req->document_root_len, "/", 1, wsgi_req->path_info, wsgi_req->path_info_len);
size_t filename_len = wsgi_req->document_root_len + 1 + wsgi_req->path_info_len;
// we expand the path for future security implementations
char *real_filename = uwsgi_expand_path(filename, filename_len, NULL);
free(filename);
if (!real_filename) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
struct uwsgi_buffer *ub_ssi = uwsgi_buffer_from_file(real_filename);
free(real_filename);
if (!ub_ssi) {
uwsgi_500(wsgi_req);
return UWSGI_OK;
}
ub = uwsgi_ssi_parse(wsgi_req, ub_ssi->buf, ub_ssi->pos);
uwsgi_buffer_destroy(ub_ssi);
if (!ub) {
uwsgi_500(wsgi_req);
return UWSGI_OK;
}
// prepare headers
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) {
uwsgi_500(wsgi_req);
goto end;
}
// content_length
if (uwsgi_response_add_content_length(wsgi_req, ub->pos)) {
uwsgi_500(wsgi_req);
goto end;
}
// content_type
if (uwsgi_response_add_content_type(wsgi_req, "text/html", 9)) {
uwsgi_500(wsgi_req);
goto end;
}
uwsgi_response_write_body_do(wsgi_req, ub->buf, ub->pos);
end:
if (ub) {
uwsgi_buffer_destroy(ub);
}
return UWSGI_OK;
}
int uwsgi_websocket_handshake(struct wsgi_request *wsgi_req, char *key, uint16_t key_len, char *origin, uint16_t origin_len) {
#ifdef UWSGI_SSL
char sha1[20];
if (uwsgi_response_prepare_headers(wsgi_req, "101 Web Socket Protocol Handshake", 33)) return -1;
if (uwsgi_response_add_header(wsgi_req, "Upgrade", 7, "WebSocket", 9)) return -1;
if (uwsgi_response_add_header(wsgi_req, "Connection", 10, "Upgrade", 7)) return -1;
if (origin_len > 0) {
if (uwsgi_response_add_header(wsgi_req, "Sec-WebSocket-Origin", 20, origin, origin_len)) return -1;
}
else {
if (uwsgi_response_add_header(wsgi_req, "Sec-WebSocket-Origin", 20, "*", 1)) return -1;
}
// generate websockets sha1 and encode it to base64
if (!uwsgi_sha1_2n(key, key_len, "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", 36, sha1)) return -1;
size_t b64_len = 0;
char *b64 = uwsgi_base64_encode(sha1, 20, &b64_len);
if (!b64) return -1;
if (uwsgi_response_add_header(wsgi_req, "Sec-WebSocket-Accept", 20, b64, b64_len)) {
free(b64);
return -1;
}
free(b64);
wsgi_req->websocket_last_pong = uwsgi_now();
return uwsgi_response_write_headers_do(wsgi_req);
#else
uwsgi_log("you need to build uWSGI with SSL support to use the websocket handshake api function !!!\n");
return -1;
#endif
}
static int uwsgi_routing_func_cache(struct wsgi_request *wsgi_req, struct uwsgi_route *ur){
struct uwsgi_router_cache_conf *urcc = (struct uwsgi_router_cache_conf *) ur->data2;
char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urcc->key, urcc->key_len);
if (!ub) return UWSGI_ROUTE_BREAK;
uint64_t valsize = 0;
char *value = uwsgi_cache_magic_get(ub->buf, ub->pos, &valsize, urcc->name);
uwsgi_buffer_destroy(ub);
if (value) {
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto error;
if (uwsgi_response_add_content_type(wsgi_req, urcc->content_type, urcc->content_type_len)) goto error;
if (uwsgi_response_add_content_length(wsgi_req, valsize)) goto error;
uwsgi_response_write_body_do(wsgi_req, value, valsize);
free(value);
if (ur->custom)
return UWSGI_ROUTE_NEXT;
return UWSGI_ROUTE_BREAK;
}
return UWSGI_ROUTE_NEXT;
error:
free(value);
return UWSGI_ROUTE_BREAK;
}
static int uwsgi_routing_func_rpc_blob(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
int ret = -1;
// this is the list of args
char *argv[UMAX8];
// this is the size of each argument
uint16_t argvs[UMAX8];
// this is a placeholder for tmp uwsgi_buffers
struct uwsgi_buffer *ubs[UMAX8];
char **r_argv = (char **) ur->data2;
uint16_t *r_argvs = (uint16_t *) ur->data3;
char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
uint64_t i;
for(i=0;i<ur->custom;i++) {
ubs[i] = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, r_argv[i], r_argvs[i]);
if (!ubs[i]) goto end;
argv[i] = ubs[i]->buf;
argvs[i] = ubs[i]->pos;
}
// ok we now need to check it it is a local call or a remote one
char *func = uwsgi_str(ur->data);
char *remote = NULL;
char *at = strchr(func, '@');
if (at) {
*at = 0;
remote = at+1;
}
uint16_t size;
char *response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
free(func);
if (!response) goto end;
ret = UWSGI_ROUTE_NEXT;
// optimization
if (!wsgi_req->headers_sent) {
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) {free(response) ; goto end;}
if (uwsgi_response_add_connection_close(wsgi_req)) {free(response) ; goto end;}
}
uwsgi_response_write_body_do(wsgi_req, response, size);
free(response);
end:
for(i=0;i<ur->custom;i++) {
if (ubs[i] != NULL) {
uwsgi_buffer_destroy(ubs[i]);
}
}
return ret;
}
static int uwsgi_rpc_xmlrpc(struct wsgi_request *wsgi_req, xmlDoc *doc, char **argv, uint16_t *argvs, uint8_t *argc, char *response_buf) {
char *method = NULL;
xmlNode *element = xmlDocGetRootElement(doc);
if (!element) return -1;
if (strcmp((char *) element->name, "methodCall")) return -1;
*argc = 0;
xmlNode *node;
for (node = element->children; node; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
if (!strcmp((char *) node->name, "methodName") && node->children) {
method = (char *) node->children->content;
}
else if (!strcmp((char *) node->name, "params")) {
if (uwsgi_rpc_xmlrpc_args(node, argv, argvs, argc)) return -1;
}
}
}
if (!method) return -1;
wsgi_req->uh->pktsize = uwsgi_rpc(method, *argc, argv+1, argvs+1, response_buf);
if (!wsgi_req->uh->pktsize) return -1;
if (wsgi_req->uh->pktsize == UMAX16-1) return -1;
// add final NULL byte
response_buf[wsgi_req->uh->pktsize] = 0;
xmlDoc *rdoc = xmlNewDoc(BAD_CAST "1.0");
xmlNode *m_response = xmlNewNode(NULL, BAD_CAST "methodResponse");
xmlDocSetRootElement(rdoc, m_response);
xmlNode *x_params = xmlNewChild(m_response, NULL, BAD_CAST "params", NULL);
xmlNode *x_param = xmlNewChild(x_params, NULL, BAD_CAST "param", NULL);
xmlNode *x_value = xmlNewChild(x_param, NULL, BAD_CAST "value", NULL);
xmlNewTextChild(x_value, NULL, BAD_CAST "string", BAD_CAST response_buf);
xmlChar *xmlbuf;
int xlen = 0;
xmlDocDumpFormatMemory(rdoc, &xmlbuf, &xlen, 1);
uwsgi_response_prepare_headers(wsgi_req,"200 OK", 6);
uwsgi_response_add_content_length(wsgi_req, xlen);
uwsgi_response_add_content_type(wsgi_req, "application/xml", 15);
uwsgi_response_write_body_do(wsgi_req, (char *) xmlbuf, xlen);
xmlFreeDoc(rdoc);
xmlFree(xmlbuf);
return 0;
}
Response& Response::flush()
{
if ( !status_.empty() )
{
uwsgi_response_prepare_headers(
r_,
(char*)status_.c_str(), status_.size()
);
status_ = "";
}
for ( size_t i = 0; i < headers_.size(); i++)
{
const std::string& key = headers_[i].first;
const std::string& val = headers_[i].second;
uwsgi_response_add_header(
r_,
(char*)key.c_str(), key.size(),
(char*)val.c_str(), val.size()
);
headers_.clear();
}
if ( !cookies_.empty())
{
for ( size_t i = 0; i < cookies_.size(); i++ )
{
std::string key = "Set-Cookie";
std::string val = cookies_[i].str();
uwsgi_response_add_header(
r_,
(char*)key.c_str(), key.size(),
(char*)val.c_str(), val.size()
);
}
cookies_.clear();
}
if ( !body_.empty() )
{
uwsgi_response_write_body_do(
r_,
(char*)body_.c_str(), body_.size()
);
body_ = "";
}
return *this;
}
static int uwsgi_routing_func_xslt(struct wsgi_request *wsgi_req, struct uwsgi_route *ur){
struct uwsgi_router_xslt_conf *urxc = (struct uwsgi_router_xslt_conf *) ur->data2;
char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
struct uwsgi_buffer *ub_doc = NULL;
struct uwsgi_buffer *ub_stylesheet = NULL;
struct uwsgi_buffer *ub_params = NULL;
struct uwsgi_buffer *ub_content_type = NULL;
ub_doc = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urxc->doc, urxc->doc_len);
if (!ub_doc) goto end;
ub_stylesheet = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urxc->stylesheet, urxc->stylesheet_len);
if (!ub_stylesheet) goto end;
if (urxc->params) {
ub_params = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urxc->params, urxc->params_len);
if (!ub_params) goto end;
}
if (urxc->content_type) {
ub_content_type = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urxc->content_type, urxc->content_type_len);
if (!ub_content_type) goto end;
}
int rlen;
char *output = uwsgi_xslt_apply( ub_doc->buf, ub_stylesheet->buf, ub_params ? ub_params->buf : NULL, &rlen);
if (!output) goto end;
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto end;
if (uwsgi_response_add_content_length(wsgi_req, rlen)) goto end;
if (uwsgi_response_add_content_type(wsgi_req, urxc->content_type, urxc->content_type_len)) goto end;
uwsgi_response_write_body_do(wsgi_req, output, rlen);
xmlFree(output);
end:
if (ub_doc) uwsgi_buffer_destroy(ub_doc);
if (ub_stylesheet) uwsgi_buffer_destroy(ub_stylesheet);
if (ub_params) uwsgi_buffer_destroy(ub_params);
if (ub_content_type) uwsgi_buffer_destroy(ub_content_type);
return UWSGI_ROUTE_BREAK;
}
/*
OPTIONS: if it is a valid webdav resource add Dav: to the response header
*/
static int uwsgi_wevdav_manage_options(struct wsgi_request *wsgi_req) {
uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6);
if (udav.add_option) {
struct uwsgi_buffer *ub = uwsgi_buffer_new(uwsgi.page_size);
if (uwsgi_buffer_append(ub, "1, 2, 3", 7)) goto end;
struct uwsgi_string_list *usl = udav.add_option;
while(usl) {
if (uwsgi_buffer_append(ub, ", ", 2)) goto end;
if (uwsgi_buffer_append(ub, usl->value, usl->len)) goto end;
usl = usl->next;
}
uwsgi_response_add_header(wsgi_req, "Dav", 3, ub->buf, ub->pos);
end:
uwsgi_buffer_destroy(ub);
}
else {
uwsgi_response_add_header(wsgi_req, "Dav", 3, "1, 2, 3", 7);
}
return UWSGI_OK;
}
int uwsgi_routing_func_fastfile(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
struct stat st;
int ret = UWSGI_ROUTE_BREAK;
struct uwsgi_router_file_conf *urfc = (struct uwsgi_router_file_conf *) ur->data2;
char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urfc->filename, urfc->filename_len);
if (!ub) return UWSGI_ROUTE_BREAK;
int fd = open(ub->buf, O_RDONLY);
if (fd < 0) {
if (ur->custom)
ret = UWSGI_ROUTE_NEXT;
goto end;
}
if (fstat(fd, &st)) {
goto end2;
}
struct uwsgi_buffer *ub_s = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urfc->status, urfc->status_len);
if (!ub_s) goto end2;
// static file - don't update avg_rt after request
wsgi_req->do_not_account_avg_rt = 1;
if (urfc->no_headers) {
uwsgi_buffer_destroy(ub_s);
goto send;
}
if (uwsgi_response_prepare_headers(wsgi_req, ub_s->buf, ub_s->pos)) {
uwsgi_buffer_destroy(ub_s);
goto end2;
}
uwsgi_buffer_destroy(ub_s);
if (uwsgi_response_add_content_length(wsgi_req, st.st_size)) goto end2;
if (urfc->mime) {
size_t mime_type_len = 0;
char *mime_type = uwsgi_get_mime_type(ub->buf, ub->pos, &mime_type_len);
if (mime_type) {
if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len)) goto end2;
}
else {
if (uwsgi_response_add_content_type(wsgi_req, urfc->content_type, urfc->content_type_len)) goto end2;
}
}
else {
if (uwsgi_response_add_content_type(wsgi_req, urfc->content_type, urfc->content_type_len)) goto end2;
}
send:
if (!wsgi_req->headers_sent) {
if (uwsgi_response_write_headers_do(wsgi_req)) goto end2;
}
if (wsgi_req->socket->can_offload) {
if (!uwsgi_offload_request_sendfile_do(wsgi_req, fd, st.st_size)) {
wsgi_req->via = UWSGI_VIA_OFFLOAD;
wsgi_req->response_size += st.st_size;
// the fd will be closed by the offload engine
goto end;
}
}
if (!uwsgi_simple_sendfile(wsgi_req, fd, 0, st.st_size)) {
wsgi_req->via = UWSGI_VIA_SENDFILE;
wsgi_req->response_size += st.st_size;
}
end2:
close(fd);
end:
uwsgi_buffer_destroy(ub);
return ret;
}
static int uwsgi_rados_request(struct wsgi_request *wsgi_req) {
char filename[PATH_MAX+1];
if (!wsgi_req->len) {
uwsgi_log( "Empty request. skip.\n");
return -1;
}
if (uwsgi_parse_vars(wsgi_req)) {
return -1;
}
// blocks empty paths
if (wsgi_req->path_info_len == 0 || wsgi_req->path_info_len > PATH_MAX) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
wsgi_req->app_id = uwsgi_get_app_id(wsgi_req, wsgi_req->appid, wsgi_req->appid_len, rados_plugin.modifier1);
if (wsgi_req->app_id == -1 && !uwsgi.no_default_app && uwsgi.default_app > -1) {
if (uwsgi_apps[uwsgi.default_app].modifier1 == rados_plugin.modifier1) {
wsgi_req->app_id = uwsgi.default_app;
}
}
if (wsgi_req->app_id == -1) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
struct uwsgi_app *ua = &uwsgi_apps[wsgi_req->app_id];
if (wsgi_req->path_info_len > ua->mountpoint_len &&
memcmp(wsgi_req->path_info, ua->mountpoint, ua->mountpoint_len) == 0) {
memcpy(filename, wsgi_req->path_info+ua->mountpoint_len, wsgi_req->path_info_len-ua->mountpoint_len);
filename[wsgi_req->path_info_len-ua->mountpoint_len] = 0;
} else {
memcpy(filename, wsgi_req->path_info, wsgi_req->path_info_len);
filename[wsgi_req->path_info_len] = 0;
}
// in multithread mode the memory is different (as we need a ctx for each thread) !!!
rados_ioctx_t ctx;
if (uwsgi.threads > 1) {
rados_ioctx_t *ctxes = (rados_ioctx_t *) ua->responder0;
ctx = ctxes[wsgi_req->async_id];
}
else {
ctx = (rados_ioctx_t) ua->responder0;
}
struct uwsgi_rados_mountpoint *urmp = (struct uwsgi_rados_mountpoint *) ua->responder1;
uint64_t stat_size = 0;
time_t stat_mtime = 0;
struct uwsgi_rados_io *urio = &urados.urio[wsgi_req->async_id];
if (uwsgi.async > 0) {
// no need to lock here (the rid protect us)
if (pipe(urio->fds)) {
uwsgi_error("uwsgi_rados_read_async()/pipe()");
uwsgi_500(wsgi_req);
return UWSGI_OK;
}
}
int ret = -1;
int timeout = urmp->timeout ? urmp->timeout : urados.timeout;
if (!uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "OPTIONS", 7)) {
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto end;
if (uwsgi_response_add_header(wsgi_req, "Dav", 3, "1", 1)) goto end;
struct uwsgi_buffer *ub_allow = uwsgi_buffer_new(64);
if (uwsgi_buffer_append(ub_allow, "OPTIONS, GET, HEAD", 18)) {
uwsgi_buffer_destroy(ub_allow);
goto end;
}
if (urmp->allow_put) {
if (uwsgi_buffer_append(ub_allow, ", PUT", 5)) {
uwsgi_buffer_destroy(ub_allow);
goto end;
}
}
if (urmp->allow_delete) {
if (uwsgi_buffer_append(ub_allow, ", DELETE", 8)) {
uwsgi_buffer_destroy(ub_allow);
goto end;
}
}
if (urmp->allow_mkcol) {
if (uwsgi_buffer_append(ub_allow, ", MKCOL", 7)) {
uwsgi_buffer_destroy(ub_allow);
goto end;
}
}
if (urmp->allow_propfind) {
if (uwsgi_buffer_append(ub_allow, ", PROPFIND", 10)) {
uwsgi_buffer_destroy(ub_allow);
goto end;
}
}
uwsgi_response_add_header(wsgi_req, "Allow", 5, ub_allow->buf, ub_allow->pos);
uwsgi_buffer_destroy(ub_allow);
goto end;
}
// empty paths are mapped to propfind
if (wsgi_req->path_info_len == 1 && wsgi_req->path_info[0] == '/') {
if (urmp->allow_propfind && !uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "PROPFIND", 8)) {
uwsgi_rados_propfind(wsgi_req, ctx, NULL, 0, 0, timeout);
goto end;
}
uwsgi_405(wsgi_req);
goto end;
}
// MKCOL does not require stat
if (!uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "MKCOL", 5)) {
if (!urmp->allow_mkcol) {
uwsgi_405(wsgi_req);
goto end;
}
ret = rados_pool_create(urmp->cluster, filename);
if (ret < 0) {
if (ret == -EEXIST) {
uwsgi_405(wsgi_req);
}
else {
uwsgi_500(wsgi_req);
}
goto end;
}
uwsgi_response_prepare_headers(wsgi_req, "201 Created", 11);
goto end;
}
if (uwsgi.async > 0) {
ret = uwsgi_rados_async_stat(urio, ctx, filename, &stat_size, &stat_mtime, timeout);
}
else {
ret = rados_stat(ctx, filename, &stat_size, &stat_mtime);
}
// PUT AND MKCOL can be used for non-existent objects
if (!uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "PUT", 3)) {
if (!urmp->allow_put) {
uwsgi_405(wsgi_req);
goto end;
}
if (ret == 0) {
if (uwsgi_rados_delete(wsgi_req, ctx, filename, timeout)) {
uwsgi_500(wsgi_req);
goto end;
}
}
if (uwsgi_rados_put(wsgi_req, ctx, filename, urmp->put_buffer_size, timeout)) {
uwsgi_500(wsgi_req);
goto end;
}
uwsgi_response_prepare_headers(wsgi_req, "201 Created", 11);
goto end;
}
else if (ret < 0) {
if (ret == -ENOENT)
uwsgi_404(wsgi_req);
else
uwsgi_403(wsgi_req);
goto end;
}
if (!uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "DELETE", 6)) {
if (!urmp->allow_delete) {
uwsgi_405(wsgi_req);
goto end;
}
if (uwsgi_rados_delete(wsgi_req, ctx, filename, timeout)) {
uwsgi_403(wsgi_req);
goto end;
}
uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6);
goto end;
}
if (!uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "PROPFIND", 8)) {
if (!urmp->allow_propfind) {
uwsgi_405(wsgi_req);
goto end;
}
uwsgi_rados_propfind(wsgi_req, ctx, filename, stat_size, stat_mtime, timeout);
goto end;
}
if (uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "HEAD", 4) && uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "GET", 3)) {
uwsgi_405(wsgi_req);
goto end;
}
uint64_t offset = 0;
uint64_t remains = stat_size;
uwsgi_request_fix_range_for_size(wsgi_req, remains);
switch (wsgi_req->range_parsed) {
case UWSGI_RANGE_INVALID:
if (uwsgi_response_prepare_headers(wsgi_req,
"416 Requested Range Not Satisfiable", 35))
goto end;
if (uwsgi_response_add_content_range(wsgi_req, -1, -1, stat_size))
goto end;
return 0;
case UWSGI_RANGE_VALID:
offset = wsgi_req->range_from;
remains = wsgi_req->range_to - wsgi_req->range_from + 1;
if (uwsgi_response_prepare_headers(wsgi_req, "206 Partial Content", 19))
goto end;
break;
default: /* UWSGI_RANGE_NOT_PARSED */
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) return -1;
}
size_t mime_type_len = 0;
char *mime_type = uwsgi_get_mime_type(wsgi_req->path_info, wsgi_req->path_info_len, &mime_type_len);
if (mime_type) {
if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len)) goto end;
}
if (uwsgi_response_add_last_modified(wsgi_req, (uint64_t) stat_mtime)) goto end;
// set Content-Length to actual result size
if (uwsgi_response_add_content_length(wsgi_req, remains)) goto end;
if (wsgi_req->range_parsed == UWSGI_RANGE_VALID) {
// here use the original size !!!
if (uwsgi_response_add_content_range(wsgi_req, wsgi_req->range_from, wsgi_req->range_to, stat_size))
goto end;
}
// skip body on HEAD
if (uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "HEAD", 4)) {
if (uwsgi.async > 0) {
if (uwsgi_rados_read_async(wsgi_req, ctx, filename, offset, remains, urmp->buffer_size, timeout)) goto end;
}
else {
if (uwsgi_rados_read_sync(wsgi_req, ctx, filename, offset, remains, urmp->buffer_size)) goto end;
}
}
end:
if (uwsgi.async > 0) {
close(urio->fds[0]);
close(urio->fds[1]);
}
return UWSGI_OK;
}
int uwsgi_response_prepare_headers_int(struct wsgi_request *wsgi_req, int status) {
char status_str[11];
uwsgi_num2str2(status, status_str);
return uwsgi_response_prepare_headers(wsgi_req, status_str, 3);
}
static int uwsgi_jwsgi_request(struct wsgi_request *wsgi_req) {
char status_str[11];
jobject hm = NULL;
jobject response = NULL;
jobject r_status = NULL;
jobject r_headers = NULL;
jobject r_headers_entries = NULL;
jobject r_body = NULL;
hm = uwsgi_jvm_hashmap();
if (!hm) return -1;
int i;
for(i=0;i<wsgi_req->var_cnt;i++) {
char *hk = wsgi_req->hvec[i].iov_base;
uint16_t hk_l = wsgi_req->hvec[i].iov_len;
char *hv = wsgi_req->hvec[i+1].iov_base;
uint16_t hv_l = wsgi_req->hvec[i+1].iov_len;
if (uwsgi_jwsgi_add_request_item(hm, hk, hk_l, hv, hv_l)) goto end;
i++;
}
if (uwsgi_jwsgi_add_request_input(hm, "jwsgi.input", 11)) goto end;
if (!ujwsgi.app_instance) {
response = uwsgi_jvm_call_object_static(ujwsgi.app_class, ujwsgi.app_mid, hm);
}
else {
response = uwsgi_jvm_call_object(ujwsgi.app_instance, ujwsgi.app_mid, hm);
}
if (!response) goto end;
if (uwsgi_jvm_array_len(response) != 3) {
uwsgi_log("invalid JWSGI response object\n");
goto end;
}
r_status = uwsgi_jvm_array_get(response, 0);
if (!r_status) goto end;
long n_status = uwsgi_jvm_number2c(r_status);
if (n_status == -1) goto end;
if (uwsgi_num2str2(n_status, status_str) != 3) {
goto end;
}
if (uwsgi_response_prepare_headers(wsgi_req, status_str, 3)) goto end;
r_headers = uwsgi_jvm_array_get(response, 1);
if (!r_headers) goto end;
// get entrySet
r_headers_entries = uwsgi_jvm_entryset(r_headers);
if (!r_headers_entries) goto end;
// get iterator
jobject values = uwsgi_jvm_auto_iterator(r_headers_entries);
if (values) {
int ret = uwsgi_jvm_iterator_to_response_headers(wsgi_req, values);
uwsgi_jvm_local_unref(values);
if (ret) goto end;
}
else {
uwsgi_log("unsupported response headers type !!! (must be java/util/HashMap)\n");
goto end;
}
r_body = uwsgi_jvm_array_get(response, 2);
if (!r_body) goto end;
if (uwsgi_jvm_object_to_response_body(wsgi_req, r_body)) {
uwsgi_log("unsupported JWSGI response body type\n");
}
end:
if (r_status) uwsgi_jvm_local_unref(r_status);
if (r_headers_entries) uwsgi_jvm_local_unref(r_headers_entries);
if (r_headers) uwsgi_jvm_local_unref(r_headers);
if (r_body) uwsgi_jvm_local_unref(r_body);
if (response) {
uwsgi_jvm_local_unref(response);
}
uwsgi_jvm_local_unref(hm);
return UWSGI_OK;
}
static int uwsgi_routing_func_http(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
struct uwsgi_buffer *ub = NULL;
// mark a route request
wsgi_req->via = UWSGI_VIA_ROUTE;
char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
struct uwsgi_buffer *ub_addr = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, ur->data, ur->data_len);
if (!ub_addr) return UWSGI_ROUTE_BREAK;
struct uwsgi_buffer *ub_url = NULL;
if (ur->data3_len) {
ub_url = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, ur->data3, ur->data3_len);
if (!ub_url) {
uwsgi_buffer_destroy(ub_addr);
return UWSGI_ROUTE_BREAK;
}
}
// convert the wsgi_request to an http proxy request
if (ur->custom & 0x02) {
ub = uwsgi_buffer_new(uwsgi.page_size);
}
else if (ur->custom & 0x04) {
ub = uwsgi_to_http_dumb(wsgi_req, ur->data2, ur->data2_len, ub_url ? ub_url->buf : NULL, ub_url ? ub_url->pos : 0);
}
else {
ub = uwsgi_to_http(wsgi_req, ur->data2, ur->data2_len, ub_url ? ub_url->buf : NULL, ub_url ? ub_url->pos : 0);
}
if (!ub) {
if (ub_url) uwsgi_buffer_destroy(ub_url);
uwsgi_log("unable to generate http request for %s\n", ub_addr->buf);
uwsgi_buffer_destroy(ub_addr);
return UWSGI_ROUTE_NEXT;
}
if (ub_url) uwsgi_buffer_destroy(ub_url);
// amount of body to send
size_t remains = wsgi_req->post_cl - wsgi_req->proto_parser_remains;
// append remaining body...
if (wsgi_req->proto_parser_remains > 0) {
if (uwsgi_buffer_append(ub, wsgi_req->proto_parser_remains_buf, wsgi_req->proto_parser_remains)) {
uwsgi_buffer_destroy(ub);
uwsgi_log("unable to generate http request for %s\n", ub_addr->buf);
uwsgi_buffer_destroy(ub_addr);
return UWSGI_ROUTE_NEXT;
}
wsgi_req->post_pos += wsgi_req->proto_parser_remains;
wsgi_req->proto_parser_remains = 0;
}
// ok now if have offload threads, directly use them
if (!wsgi_req->post_file && !(ur->custom & 0x01) && wsgi_req->socket->can_offload) {
// append buffered body
if (uwsgi.post_buffering > 0 && wsgi_req->post_cl > 0) {
if (uwsgi_buffer_append(ub, wsgi_req->post_buffering_buf, wsgi_req->post_cl)) {
uwsgi_buffer_destroy(ub);
uwsgi_log("unable to generate http request for %s\n", ub_addr->buf);
uwsgi_buffer_destroy(ub_addr);
return UWSGI_ROUTE_NEXT;
}
}
// if we have a CONNECT request, let's confirm it to the client
if (ur->custom & 0x02) {
if (uwsgi_response_prepare_headers(wsgi_req, "200 Connection established", 26)) goto end;
// no need to check for return value
uwsgi_response_write_headers_do(wsgi_req);
}
if (!uwsgi_offload_request_net_do(wsgi_req, ub_addr->buf, ub)) {
wsgi_req->via = UWSGI_VIA_OFFLOAD;
wsgi_req->status = 202;
uwsgi_buffer_destroy(ub_addr);
return UWSGI_ROUTE_BREAK;
}
}
if (uwsgi_proxy_nb(wsgi_req, ub_addr->buf, ub, remains, uwsgi.socket_timeout)) {
uwsgi_log("error routing request to http server %s\n", ub_addr->buf);
}
end:
uwsgi_buffer_destroy(ub);
uwsgi_buffer_destroy(ub_addr);
return UWSGI_ROUTE_BREAK;
}
static int uwsgi_wevdav_manage_proppatch(struct wsgi_request *wsgi_req, xmlDoc * doc) {
char filename[PATH_MAX];
size_t filename_len = uwsgi_webdav_expand_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
if (filename_len == 0) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
xmlNode *element = xmlDocGetRootElement(doc);
if (!element) return -1;
if (!element || (strcmp((char *) element->name, "propertyupdate"))) return -1;
if (uwsgi_response_prepare_headers(wsgi_req, "207 Multi-Status", 16))
return -1;
if (uwsgi_response_add_content_type(wsgi_req, "application/xml; charset=\"utf-8\"", 32))
return -1;
xmlDoc *rdoc = xmlNewDoc(BAD_CAST "1.0");
xmlNode *multistatus = xmlNewNode(NULL, BAD_CAST "multistatus");
xmlDocSetRootElement(rdoc, multistatus);
xmlNsPtr dav_ns = xmlNewNs(multistatus, BAD_CAST "DAV:", BAD_CAST "D");
xmlSetNs(multistatus, dav_ns);
xmlNode *response = xmlNewChild(multistatus, dav_ns, BAD_CAST "response", NULL);
char *uri = uwsgi_concat2n(wsgi_req->path_info, wsgi_req->path_info_len, "", 0);
uint16_t uri_len = strlen(uri) ;
char *encoded_uri = uwsgi_malloc( (uri_len * 3) + 1);
http_url_encode(uri, &uri_len, encoded_uri);
encoded_uri[uri_len] = 0;
xmlNewChild(response, dav_ns, BAD_CAST "href", BAD_CAST encoded_uri);
free(encoded_uri);
// propfind can be "set" or "remove"
xmlNode *node;
for (node = element->children; node; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
if (node->ns && !strcmp((char *) node->ns->href, "DAV:")) {
if (!strcmp((char *) node->name, "set")) {
uwsgi_webdav_manage_prop_update(wsgi_req, node, response, filename, 0);
}
else if (!strcmp((char *) node->name, "remove")) {
uwsgi_webdav_manage_prop_update(wsgi_req, node, response, filename, 1);
}
}
}
}
if (!rdoc) return UWSGI_OK;
xmlChar *xmlbuf;
int xlen = 0;
xmlDocDumpFormatMemory(rdoc, &xmlbuf, &xlen, 1);
uwsgi_response_add_content_length(wsgi_req, xlen);
uwsgi_response_write_body_do(wsgi_req, (char *) xmlbuf, xlen);
#ifdef UWSGI_DEBUG
uwsgi_log("\n%.*s\n", xlen, xmlbuf);
#endif
xmlFreeDoc(rdoc);
xmlFree(xmlbuf);
return UWSGI_OK;
}
static int uwsgi_wevdav_manage_propfind(struct wsgi_request *wsgi_req, xmlDoc * doc) {
char filename[PATH_MAX];
size_t filename_len = uwsgi_webdav_expand_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
if (filename_len == 0) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
xmlDoc *rdoc = NULL;
xmlNode *element = NULL;
if (doc) {
element = xmlDocGetRootElement(doc);
if (!element) return -1;
if (!element || strcmp((char *) element->name, "propfind")) return -1;
}
if (uwsgi_response_prepare_headers(wsgi_req, "207 Multi-Status", 16))
return -1;
if (uwsgi_response_add_content_type(wsgi_req, "application/xml; charset=\"utf-8\"", 32))
return -1;
if (doc) {
// propfind must have a child (scan them until you find a valid one)
xmlNode *node;
for (node = element->children; node; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
if (node->ns && !strcmp((char *) node->ns->href, "DAV:")) {
if (!strcmp((char *) node->name, "prop")) {
rdoc = uwsgi_webdav_manage_prop(wsgi_req, node, filename, filename_len, 1);
break;
}
if (!strcmp((char *) node->name, "allprop")) {
rdoc = uwsgi_webdav_manage_prop(wsgi_req, NULL, filename, filename_len, 1);
break;
}
if (!strcmp((char *) node->name, "propname")) {
rdoc = uwsgi_webdav_manage_prop(wsgi_req, node, filename, filename_len, 0);
break;
}
}
}
}
}
else {
rdoc = uwsgi_webdav_manage_prop(wsgi_req, NULL, filename, filename_len, 1);
}
if (!rdoc) return UWSGI_OK;
xmlChar *xmlbuf;
int xlen = 0;
xmlDocDumpFormatMemory(rdoc, &xmlbuf, &xlen, 1);
uwsgi_response_add_content_length(wsgi_req, xlen);
uwsgi_response_write_body_do(wsgi_req, (char *) xmlbuf, xlen);
#ifdef UWSGI_DEBUG
uwsgi_log("\n%.*s\n", xlen, xmlbuf);
#endif
xmlFreeDoc(rdoc);
xmlFree(xmlbuf);
return UWSGI_OK;
}
static int uwsgi_wevdav_manage_lock(struct wsgi_request *wsgi_req) {
uwsgi_response_prepare_headers(wsgi_req, "201 Created", 11);
return UWSGI_OK;
}
static int uwsgi_ssh_request_file(
struct wsgi_request *wsgi_req,
char* filepath,
struct uwsgi_ssh_mountpoint *usm
) {
int sock = -1;
int return_status = 0;
LIBSSH2_SESSION *session = NULL;
if (uwsgi_init_ssh_session(usm, &sock, &session)) {
uwsgi_log("[SSH] session initialization failed. Is the SSH server up?\n");
return_status = 500;
goto shutdown;
}
LIBSSH2_SFTP *sftp_session = NULL;
do {
sftp_session = libssh2_sftp_init(session);
if (!sftp_session) {
if ((libssh2_session_last_errno(session)) == LIBSSH2_ERROR_EAGAIN) {
if (uwsgi_ssh_waitsocket(sock, session)) {
return_status = 500;
goto shutdown;
}
} else {
uwsgi_error("uwsgi_ssh_request_file()/libssh2_sftp_init()");
return_status = 500;
goto shutdown;
}
}
} while (!sftp_session);
// Request file stats via SFTP
LIBSSH2_SFTP_ATTRIBUTES file_attrs;
int rc;
while ((rc = libssh2_sftp_stat(sftp_session, filepath, &file_attrs)) == LIBSSH2_ERROR_EAGAIN) {
if (uwsgi_ssh_waitsocket(sock, session)) {
return_status = 500;
goto shutdown;
}
}
if (rc < 0) {
// If it fails, requested file could not exist.
if (rc == LIBSSH2_ERROR_SFTP_PROTOCOL && libssh2_sftp_last_error(sftp_session) == LIBSSH2_FX_NO_SUCH_FILE) {
return_status = 404;
} else {
uwsgi_error("uwsgi_ssh_request_file()/libssh2_sftp_stat()");
return_status = 500;
}
goto sftp_shutdown;
}
if (wsgi_req->if_modified_since_len) {
time_t ims = uwsgi_parse_http_date(wsgi_req->if_modified_since, wsgi_req->if_modified_since_len);
if (file_attrs.mtime <= (unsigned long)ims) {
if (uwsgi_response_prepare_headers(wsgi_req, "304 Not Modified", 16) || uwsgi_response_write_headers_do(wsgi_req)) {
uwsgi_error("uwsgi_parse_http_date()/uwsgi_response_prepare_headers(do)()");
}
return_status = 500;
goto sftp_shutdown;
}
}
if (uwsgi_response_prepare_headers(wsgi_req, "200", 3)) {
uwsgi_error("uwsgi_ssh_request_file()/uwsgi_response_prepare_headers()");
return_status = 500;
goto sftp_shutdown;
}
if (uwsgi_response_add_content_length(wsgi_req, file_attrs.filesize)) {
uwsgi_error("uwsgi_ssh_request_file()/uwsgi_response_add_content_length()");
return_status = 500;
goto sftp_shutdown;
}
if (uwsgi_response_add_last_modified(wsgi_req, file_attrs.mtime)) {
uwsgi_error("uwsgi_ssh_request_file()/uwsgi_response_add_last_modified()");
return_status = 500;
goto sftp_shutdown;
}
size_t mime_type_len = 0;
char *mime_type = uwsgi_get_mime_type(filepath, strlen(filepath), &mime_type_len);
if (mime_type) {
if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len)) {
uwsgi_error("uwsgi_ssh_request_file()/uwsgi_response_add_content_type()");
// goto sftp_shutdown;
}
}
// Request a file via SFTP
LIBSSH2_SFTP_HANDLE *sftp_handle = NULL;
do {
sftp_handle = libssh2_sftp_open(sftp_session, filepath, LIBSSH2_FXF_READ, 0);
if (!sftp_handle) {
if (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
uwsgi_error("uwsgi_ssh_request_file()/libssh2_sftp_open()");
return_status = 500;
goto sftp_shutdown;
} else {
if (uwsgi_ssh_waitsocket(sock, session)) {
return_status = 500;
goto sftp_shutdown;
}
}
}
} while (!sftp_handle);
size_t buffer_size = uwsgi.page_size;
void *buffer = alloca(buffer_size);
libssh2_uint64_t read_size = 0;
while (read_size < file_attrs.filesize) {
rc = libssh2_sftp_read(sftp_handle, buffer, buffer_size);
if (rc == LIBSSH2_ERROR_EAGAIN) {
if (uwsgi_ssh_waitsocket(sock, session)) {
return_status = 500;
goto sftp_shutdown;
}
} else if (rc < 0) {
uwsgi_error("uwsgi_ssh_request_file()/libssh2_sftp_read()");
break;
} else {
read_size += rc;
if (uwsgi_response_write_body_do(wsgi_req, buffer, rc)) {
uwsgi_error("uwsgi_ssh_request_file()/uwsgi_response_write_body_do()");
break;
}
}
}
while ((rc = libssh2_sftp_close(sftp_handle)) == LIBSSH2_ERROR_EAGAIN) {
if (uwsgi_ssh_waitsocket(sock, session)) {
return_status = 500;
goto sftp_shutdown;
}
};
if (rc < 0) {
uwsgi_error("uwsgi_ssh_request_file()/libssh2_sftp_close()");
}
sftp_shutdown:
while ((rc = libssh2_sftp_shutdown(sftp_session)) == LIBSSH2_ERROR_EAGAIN) {
uwsgi_ssh_waitsocket(sock, session);
}
if (rc < 0) {
uwsgi_error("uwsgi_ssh_request_file()/libssh2_sftp_shutdown()");
}
shutdown:
while (libssh2_session_disconnect(session, "Normal Shutdown, thank you!") == LIBSSH2_ERROR_EAGAIN) {
uwsgi_ssh_waitsocket(sock, session);
}
libssh2_session_free(session);
close(sock);
libssh2_exit();
return return_status;
}
static int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
// this is the list of args
char *argv[UMAX8];
// this is the size of each argument
uint16_t argvs[UMAX8];
// maximum number of supported arguments
uint8_t argc = 0xff;
// response output
char response_buf[UMAX16];
/* Standard RPC request */
if (!wsgi_req->uh->pktsize) {
uwsgi_log("Empty RPC request. skip.\n");
return -1;
}
if (wsgi_req->uh->modifier2 == 2) {
if (uwsgi_parse_vars(wsgi_req)) {
uwsgi_log("Invalid RPC request. skip.\n");
return -1;
}
if (wsgi_req->path_info_len == 0) {
uwsgi_500(wsgi_req);
return UWSGI_OK;
}
char *args = NULL;
if (wsgi_req->path_info[0] == '/') {
args = uwsgi_concat2n(wsgi_req->path_info+1, wsgi_req->path_info_len-1, "", 0);
}
else {
args = uwsgi_concat2n(wsgi_req->path_info, wsgi_req->path_info_len, "", 0);
}
argc = 0;
argv[0] = strtok(args, "/");
if (!argv[0]) {
free(args);
uwsgi_500(wsgi_req);
return UWSGI_OK;
}
char *p = strtok(NULL, "/");
while(p) {
argc++;
argv[argc] = p;
argvs[argc] = strlen(p);
p = strtok(NULL, "/");
}
wsgi_req->uh->pktsize = uwsgi_rpc(argv[0], argc, argv+1, argvs+1, response_buf);
free(args);
if (!wsgi_req->uh->pktsize) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) return 1;
if (uwsgi_response_add_content_length(wsgi_req, wsgi_req->uh->pktsize)) return -1;
uint16_t ctype_len = 0;
char *ctype = uwsgi_get_var(wsgi_req, "HTTP_ACCEPT", 11, &ctype_len);
if (ctype && strcmp(ctype, "*/*") && strcmp(ctype, "*")) {
if (uwsgi_response_add_content_type(wsgi_req, ctype, ctype_len)) return -1;
}
else {
if (uwsgi_response_add_content_type(wsgi_req, "application/binary", 18)) return -1;
}
goto sendbody;
}
#ifdef UWSGI_XML_LIBXML2
if (wsgi_req->uh->modifier2 == 3) {
if (wsgi_req->post_cl == 0) {
uwsgi_500(wsgi_req);
return UWSGI_OK;
}
ssize_t body_len = 0;
char *body = uwsgi_request_body_read(wsgi_req, wsgi_req->post_cl, &body_len);
xmlDoc *doc = xmlReadMemory(body, body_len, NULL, NULL, 0);
if (!doc) {
uwsgi_500(wsgi_req);
return UWSGI_OK;
}
int ret = uwsgi_rpc_xmlrpc(wsgi_req, doc, argv, argvs, &argc, response_buf);
xmlFreeDoc(doc);
if (ret) {
uwsgi_500(wsgi_req);
}
return UWSGI_OK;
}
#endif
if (uwsgi_parse_array(wsgi_req->buffer, wsgi_req->uh->pktsize, argv, argvs, &argc)) {
uwsgi_log("Invalid RPC request. skip.\n");
return -1;
}
// call the function (output will be in wsgi_req->buffer)
wsgi_req->uh->pktsize = uwsgi_rpc(argv[0], argc-1, argv+1, argvs+1, response_buf);
// using modifier2 we may want a raw output
if (wsgi_req->uh->modifier2 == 0) {
if (uwsgi_response_write_body_do(wsgi_req, (char *) wsgi_req->uh, 4)) {
return -1;
}
}
sendbody:
// write the response
uwsgi_response_write_body_do(wsgi_req, response_buf, wsgi_req->uh->pktsize);
return UWSGI_OK;
}
static int uwsgi_wevdav_manage_move(struct wsgi_request *wsgi_req) {
char filename[PATH_MAX];
char d_filename[PATH_MAX];
size_t filename_len = uwsgi_webdav_expand_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
if (filename_len == 0) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
uint16_t destination_len = 0;
char *destination = uwsgi_get_var(wsgi_req, "HTTP_DESTINATION", 16, &destination_len);
if (destination_len == 0) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
uint16_t overwrite_len = 0;
int can_overwrite = 1;
char *overwrite = uwsgi_get_var(wsgi_req, "HTTP_OVERWRITE", 14, &overwrite_len);
if (overwrite) {
if (overwrite[0] == 'F') {
can_overwrite = 0;
}
}
uint16_t scheme_len = wsgi_req->scheme_len;
if (wsgi_req->scheme_len == 0) {
// http
scheme_len = 4;
}
uint16_t skip = scheme_len + 3 + wsgi_req->host_len;
int already_exists = 0;
size_t d_filename_len = uwsgi_webdav_expand_path(wsgi_req, destination + skip, destination_len - skip, d_filename);
if (d_filename_len > 0) {
already_exists = 1;
if (!can_overwrite) {
uwsgi_response_prepare_headers(wsgi_req, "412 Precondition Failed", 23);
return UWSGI_OK;
}
}
else {
d_filename_len = uwsgi_webdav_expand_fake_path(wsgi_req, destination + skip, destination_len - skip, d_filename);
}
if (d_filename_len == 0) {
uwsgi_response_prepare_headers(wsgi_req, "409 Conflict", 12);
return UWSGI_OK;
}
if (rename(filename, d_filename)) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
if (already_exists) {
uwsgi_response_prepare_headers(wsgi_req, "204 No Content", 14);
}
else {
uwsgi_response_prepare_headers(wsgi_req, "201 Created", 11);
}
return UWSGI_OK;
}
// "next" || "continue" || "break(.*)" || "goon" || "goto .+"
static int uwsgi_routing_func_rpc_ret(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
int ret = -1;
// this is the list of args
char *argv[UMAX8];
// this is the size of each argument
uint16_t argvs[UMAX8];
// this is a placeholder for tmp uwsgi_buffers
struct uwsgi_buffer *ubs[UMAX8];
char **r_argv = (char **) ur->data2;
uint16_t *r_argvs = (uint16_t *) ur->data3;
char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
uint64_t i;
for(i=0;i<ur->custom;i++) {
ubs[i] = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, r_argv[i], r_argvs[i]);
if (!ubs[i]) goto end;
argv[i] = ubs[i]->buf;
argvs[i] = ubs[i]->pos;
}
// ok we now need to check it it is a local call or a remote one
char *func = uwsgi_str(ur->data);
char *remote = NULL;
char *at = strchr(func, '@');
if (at) {
*at = 0;
remote = at+1;
}
uint16_t size;
char *response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
free(func);
if (!response) goto end;
ret = UWSGI_ROUTE_CONTINUE;
if (!uwsgi_strncmp(response, size, "next", 4 )) {
ret = UWSGI_ROUTE_NEXT;
}
else if (!uwsgi_strncmp(response, size, "continue", 8 )) {
ret = UWSGI_ROUTE_CONTINUE;
}
else if (!uwsgi_starts_with(response, size, "break", 5 )) {
ret = UWSGI_ROUTE_BREAK;
if (size > 6) {
if (uwsgi_response_prepare_headers(wsgi_req, response+6, size-6)) goto end0;
if (uwsgi_response_add_connection_close(wsgi_req)) goto end0;
if (uwsgi_response_add_content_type(wsgi_req, "text/plain", 10)) goto end0;
// no need to check for return value
uwsgi_response_write_headers_do(wsgi_req);
}
}
else if (!uwsgi_starts_with(response, size, "goto ", 5)) {
ret = UWSGI_ROUTE_BREAK;
if (size > 5) {
// find the label
struct uwsgi_route *routes = uwsgi.routes;
while(routes) {
if (!routes->label) goto next;
if (!uwsgi_strncmp(routes->label, routes->label_len, response+5, size-5)) {
ret = UWSGI_ROUTE_NEXT;
wsgi_req->route_goto = routes->pos;
goto found;
}
next:
routes = routes->next;
}
goto end0;
found:
if (wsgi_req->route_goto <= wsgi_req->route_pc) {
wsgi_req->route_goto = 0;
uwsgi_log("[uwsgi-route] ERROR \"goto\" instruction can only jump forward (check your label !!!)\n");
ret = UWSGI_ROUTE_BREAK;
}
}
}
end0:
free(response);
end:
for(i=0;i<ur->custom;i++) {
if (ubs[i] != NULL) {
uwsgi_buffer_destroy(ubs[i]);
}
}
return ret;
}
int uwsgi_routing_func_file(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
char buf[32768];
struct stat st;
int ret = UWSGI_ROUTE_BREAK;
size_t remains = 0;
struct uwsgi_router_file_conf *urfc = (struct uwsgi_router_file_conf *) ur->data2;
char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urfc->filename, urfc->filename_len);
if (!ub) return UWSGI_ROUTE_BREAK;
int fd = open(ub->buf, O_RDONLY);
if (fd < 0) {
if (ur->custom)
ret = UWSGI_ROUTE_NEXT;
goto end;
}
if (fstat(fd, &st)) {
goto end2;
}
struct uwsgi_buffer *ub_s = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urfc->status, urfc->status_len);
if (!ub_s) goto end2;
// static file - don't update avg_rt after request
wsgi_req->do_not_account_avg_rt = 1;
if (urfc->no_headers) {
uwsgi_buffer_destroy(ub_s);
goto send;
}
if (uwsgi_response_prepare_headers(wsgi_req, ub_s->buf, ub_s->pos)) {
uwsgi_buffer_destroy(ub_s);
goto end2;
}
uwsgi_buffer_destroy(ub_s);
if (!urfc->no_cl) {
if (uwsgi_response_add_content_length(wsgi_req, st.st_size)) goto end2;
}
if (urfc->mime) {
size_t mime_type_len = 0;
char *mime_type = uwsgi_get_mime_type(ub->buf, ub->pos, &mime_type_len);
if (mime_type) {
if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len)) goto end2;
}
else {
if (uwsgi_response_add_content_type(wsgi_req, urfc->content_type, urfc->content_type_len)) goto end2;
}
}
else {
if (uwsgi_response_add_content_type(wsgi_req, urfc->content_type, urfc->content_type_len)) goto end2;
}
send:
remains = st.st_size;
while(remains) {
ssize_t rlen = read(fd, buf, UMIN(32768, remains));
if (rlen <= 0) goto end2;
if (uwsgi_response_write_body_do(wsgi_req, buf, rlen)) goto end2;
remains -= rlen;
}
end2:
close(fd);
end:
uwsgi_buffer_destroy(ub);
return ret;
}
static int uwsgi_glusterfs_request(struct wsgi_request *wsgi_req) {
char filename[PATH_MAX+1];
/* Standard GlusterFS request */
if (!wsgi_req->uh->pktsize) {
uwsgi_log( "Empty GlusterFS request. skip.\n");
return -1;
}
if (uwsgi_parse_vars(wsgi_req)) {
return -1;
}
// blocks empty paths
if (wsgi_req->path_info_len == 0 || wsgi_req->path_info_len > PATH_MAX) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
wsgi_req->app_id = uwsgi_get_app_id(wsgi_req, wsgi_req->appid, wsgi_req->appid_len, glusterfs_plugin.modifier1);
if (wsgi_req->app_id == -1 && !uwsgi.no_default_app && uwsgi.default_app > -1) {
if (uwsgi_apps[uwsgi.default_app].modifier1 == glusterfs_plugin.modifier1) {
wsgi_req->app_id = uwsgi.default_app;
}
}
if (wsgi_req->app_id == -1) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
struct uwsgi_app *ua = &uwsgi_apps[wsgi_req->app_id];
memcpy(filename, wsgi_req->path_info, wsgi_req->path_info_len);
filename[wsgi_req->path_info_len] = 0;
glfs_fd_t *fd = glfs_open((glfs_t *) ua->interpreter, filename, O_RDONLY);
if (!fd) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
struct stat st;
if (glfs_fstat(fd, &st)) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto end;
size_t mime_type_len = 0;
char *mime_type = uwsgi_get_mime_type(wsgi_req->path_info, wsgi_req->path_info_len, &mime_type_len);
if (mime_type) {
if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len)) goto end;
}
if (uwsgi_response_add_last_modified(wsgi_req, (uint64_t) st.st_mtime)) goto end;
if (uwsgi_response_add_content_length(wsgi_req, st.st_size)) goto end;
// skip body on HEAD
if (uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "HEAD", 4)) {
size_t remains = st.st_size;
while(remains > 0) {
char buf[8192];
ssize_t rlen = glfs_read (fd, buf, UMIN(remains, 8192), 0);
if (rlen <= 0) goto end;
if (uwsgi_response_write_body_do(wsgi_req, buf, rlen)) goto end;
remains -= rlen;
}
}
end:
glfs_close(fd);
return UWSGI_OK;
}
static int uwsgi_wevdav_manage_get(struct wsgi_request *wsgi_req, int send_body) {
char filename[PATH_MAX];
size_t filename_len = uwsgi_webdav_expand_path(wsgi_req, wsgi_req->path_info, wsgi_req->path_info_len, filename);
if (!filename_len) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
if (uwsgi_is_dir(filename)) {
uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6);
if (send_body) {
uwsgi_webdav_dirlist(wsgi_req, filename);
}
return UWSGI_OK;
}
int fd = open(filename, O_RDONLY);
if (fd < 0) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
struct stat st;
if (fstat(fd, &st)) {
close(fd);
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6))
goto end;
// add content_length
if (uwsgi_response_add_content_length(wsgi_req, st.st_size))
goto end;
// add last-modified
if (uwsgi_response_add_last_modified(wsgi_req, st.st_mtime))
goto end;
// add mime_type
size_t mime_type_len = 0;
char *mime_type = uwsgi_get_mime_type(filename, filename_len, &mime_type_len);
if (mime_type) {
if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len))
goto end;
}
// add ETag (based on file mtime, not rock-solid, but good enough)
char *etag = uwsgi_num2str(st.st_mtime);
if (uwsgi_response_add_header(wsgi_req, "ETag", 4, etag, strlen(etag))) {
free(etag);
goto end;
}
free(etag);
// start sending the file (note: we do not use sendfile() api, for being able to use caching and transformations)
if (!send_body)
goto end;
// use a pretty big buffer (for performance reasons)
char buf[32768];
size_t remains = st.st_size;
while (remains > 0) {
ssize_t rlen = read(fd, buf, UMIN(32768, remains));
if (rlen <= 0) {
uwsgi_error("uwsgi_wevdav_manage_get/read()");
break;
}
remains -= rlen;
if (uwsgi_response_write_body_do(wsgi_req, buf, rlen)) {
break;
}
}
end:
close(fd);
return UWSGI_OK;
}
