#include <time.h>
#include <strings.h>
#include <dirent.h>
+#include <stdint.h>
#include <libubox/blobmsg.h>
static LIST_HEAD(index_files);
static LIST_HEAD(dispatch_handlers);
+static LIST_HEAD(pending_requests);
+static int n_requests;
+
+struct deferred_request {
+ struct list_head list;
+ struct dispatch_handler *d;
+ struct client *cl;
+ struct path_info pi;
+ bool called, path;
+};
struct index_file {
struct list_head list;
static const char * uh_file_mktag(struct stat *s, char *buf, int len)
{
- snprintf(buf, len, "\"%x-%x-%x\"",
- (unsigned int) s->st_ino,
- (unsigned int) s->st_size,
- (unsigned int) s->st_mtime);
+ snprintf(buf, len, "\"%" PRIx64 "-%" PRIx64 "-%" PRIx64 "\"",
+ s->st_ino, s->st_size, (uint64_t)s->st_mtime);
return buf;
}
bool dir = !!(files[i]->d_type & DT_DIR);
if (name[0] == '.' && name[1] == 0)
- continue;
+ goto next;
sprintf(file, "%s", name);
if (stat(local_path, &s))
- continue;
+ goto next;
if (!dir) {
suffix = "";
}
if (!(s.st_mode & mode))
- continue;
+ goto next;
uh_chunk_printf(cl,
"<li><strong><a href='%s%s%s'>%s</a>%s"
type, s.st_size / 1024.0);
*file = 0;
+next:
free(files[i]);
}
}
!uh_file_if_range(cl, &pi->stat) ||
!uh_file_if_unmodified_since(cl, &pi->stat) ||
!uh_file_if_none_match(cl, &pi->stat)) {
- ustream_printf(cl->us, "Content-Length: 0\r\n");
ustream_printf(cl->us, "\r\n");
uh_request_done(cl);
close(fd);
ustream_printf(cl->us, "Content-Type: %s\r\n",
uh_file_mime_lookup(pi->name));
- ustream_printf(cl->us, "Content-Length: %i\r\n\r\n",
+ ustream_printf(cl->us, "Content-Length: %" PRIu64 "\r\n\r\n",
pi->stat.st_size);
file_write_cb(cl);
}
+static bool __handle_file_request(struct client *cl, char *url);
+
static void uh_file_request(struct client *cl, const char *url,
struct path_info *pi, struct blob_attr **tb)
{
int fd;
+ struct http_request *req = &cl->request;
+ char *error_handler;
if (!(pi->stat.st_mode & S_IROTH))
goto error;
}
error:
+ /* check for a previously set 403 redirect status to prevent infinite
+ recursion when the error page itself lacks sufficient permissions */
+ if (conf.error_handler && req->redirect_status != 403) {
+ req->redirect_status = 403;
+ error_handler = alloca(strlen(conf.error_handler) + 1);
+ strcpy(error_handler, conf.error_handler);
+ if (__handle_file_request(cl, error_handler))
+ return;
+ }
+
uh_client_error(cl, 403, "Forbidden",
"You don't have permission to access %s on this server.",
url);
return NULL;
}
+static void
+uh_invoke_script(struct client *cl, struct dispatch_handler *d, struct path_info *pi)
+{
+ char *url = blobmsg_data(blob_data(cl->hdr.head));
+
+ n_requests++;
+ d->handle_request(cl, url, pi);
+}
+
+static void uh_complete_request(struct client *cl)
+{
+ struct deferred_request *dr;
+
+ n_requests--;
+
+ while (!list_empty(&pending_requests)) {
+ if (n_requests >= conf.max_script_requests)
+ return;
+
+ dr = list_first_entry(&pending_requests, struct deferred_request, list);
+ list_del(&dr->list);
+
+ dr->called = true;
+ uh_invoke_script(dr->cl, dr->d, dr->path ? &dr->pi : NULL);
+ }
+}
+
+
+static void
+uh_free_pending_request(struct client *cl)
+{
+ struct deferred_request *dr = cl->dispatch.req_data;
+
+ if (dr->called)
+ uh_complete_request(cl);
+ else
+ list_del(&dr->list);
+ free(dr);
+}
+
+static int field_len(const char *ptr)
+{
+ if (!ptr)
+ return 0;
+
+ return strlen(ptr) + 1;
+}
+
+#define path_info_fields \
+ _field(root) \
+ _field(phys) \
+ _field(name) \
+ _field(info) \
+ _field(query) \
+ _field(auth)
+
+static void
+uh_defer_script(struct client *cl, struct dispatch_handler *d, struct path_info *pi)
+{
+ struct deferred_request *dr;
+ char *_root, *_phys, *_name, *_info, *_query, *_auth;
+
+ cl->dispatch.req_free = uh_free_pending_request;
+
+ if (pi) {
+ /* allocate enough memory to duplicate all path_info strings in one block */
+#undef _field
+#define _field(_name) &_##_name, field_len(pi->_name),
+ dr = calloc_a(sizeof(*dr), path_info_fields NULL);
+
+ memcpy(&dr->pi, pi, sizeof(*pi));
+ dr->path = true;
+
+ /* copy all path_info strings */
+#undef _field
+#define _field(_name) if (pi->_name) dr->pi._name = strcpy(_##_name, pi->_name);
+ path_info_fields
+ } else {
+ dr = calloc(1, sizeof(*dr));
+ }
+
+ cl->dispatch.req_data = dr;
+ dr->cl = cl;
+ dr->d = d;
+ list_add(&dr->list, &pending_requests);
+}
+
+static void
+uh_invoke_handler(struct client *cl, struct dispatch_handler *d, char *url, struct path_info *pi)
+{
+ if (!d->script)
+ return d->handle_request(cl, url, pi);
+
+ if (n_requests >= conf.max_script_requests)
+ return uh_defer_script(cl, d, pi);
+
+ cl->dispatch.req_free = uh_complete_request;
+ uh_invoke_script(cl, d, pi);
+}
+
static bool __handle_file_request(struct client *cl, char *url)
{
static const struct blobmsg_policy hdr_policy[__HDR_MAX] = {
d = dispatch_find(url, pi);
if (d)
- d->handle_request(cl, url, pi);
+ uh_invoke_handler(cl, d, url, pi);
else
uh_file_request(cl, url, pi, tb);
{
struct http_request *req = &cl->request;
struct dispatch_handler *d;
- char *url = blobmsg_data(blob_data(cl->hdr.head));;
+ char *url = blobmsg_data(blob_data(cl->hdr.head));
char *error_handler;
req->redirect_status = 200;
d = dispatch_find(url, NULL);
- if (d) {
- d->handle_request(cl, url, NULL);
- return;
- }
+ if (d)
+ return uh_invoke_handler(cl, d, url, NULL);
if (__handle_file_request(cl, url))
return;
projects / project / uhttpd.git / blobdiff