include $(TOPDIR)/rules.mk
PKG_NAME:=uhttpd
-PKG_RELEASE:=15
+PKG_RELEASE:=16
PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME)
PKG_BUILD_DEPENDS := libcyassl liblua
struct client *cl, struct http_request *req,
struct path_info *pi, struct interpreter *ip
) {
- int i, hdroff, bufoff;
+ int i, hdroff, bufoff, rv;
int hdrlen = 0;
int buflen = 0;
int fd_max = 0;
memset(hdr, 0, sizeof(hdr));
- timeout.tv_sec = cl->server->conf->script_timeout;
- timeout.tv_usec = 0;
-
-#define ensure(x) \
- do { if( x < 0 ) goto out; } while(0)
-
/* I/O loop, watch our pipe ends and dispatch child reads/writes from/to socket */
while( 1 )
{
FD_SET(rfd[0], &reader);
FD_SET(wfd[1], &writer);
+ timeout.tv_sec = (header_sent < 1) ? cl->server->conf->script_timeout : 3;
+ timeout.tv_usec = 0;
+
+ ensure_out(rv = select_intr(fd_max, &reader,
+ (content_length > -1) ? &writer : NULL, NULL, &timeout));
+
+ /* timeout */
+ if( rv == 0 )
+ {
+ ensure_out(kill(child, 0));
+ }
+
/* wait until we can read or write or both */
- if( select_intr(fd_max, &reader,
- (content_length > -1) ? &writer : NULL, NULL,
- (header_sent < 1) ? &timeout : NULL) > 0
- ) {
+ else if( rv > 0 )
+ {
/* ready to write to cgi program */
if( FD_ISSET(wfd[1], &writer) )
{
if( content_length > 0 )
{
/* read it from socket ... */
- if( (buflen = uh_tcp_recv(cl, buf, min(content_length, sizeof(buf)))) > 0 )
+ ensure_out(buflen = uh_tcp_recv(cl, buf,
+ min(content_length, sizeof(buf))));
+
+ if( buflen > 0 )
{
/* ... and write it to child's stdin */
if( write(wfd[1], buf, buflen) < 0 )
if( (res = uh_cgi_header_parse(hdr, hdrlen, &hdroff)) != NULL )
{
/* write status */
- ensure(uh_http_sendf(cl, NULL,
+ ensure_out(uh_http_sendf(cl, NULL,
"HTTP/%.1f %03d %s\r\n"
"Connection: close\r\n",
req->version, res->statuscode,
if( !uh_cgi_header_lookup(res, "Location") &&
!uh_cgi_header_lookup(res, "Content-Type")
) {
- ensure(uh_http_send(cl, NULL,
+ ensure_out(uh_http_send(cl, NULL,
"Content-Type: text/plain\r\n", -1));
}
if( (req->version > 1.0) &&
!uh_cgi_header_lookup(res, "Transfer-Encoding")
) {
- ensure(uh_http_send(cl, NULL,
+ ensure_out(uh_http_send(cl, NULL,
"Transfer-Encoding: chunked\r\n", -1));
}
/* write headers from CGI program */
foreach_header(i, res->headers)
{
- ensure(uh_http_sendf(cl, NULL, "%s: %s\r\n",
+ ensure_out(uh_http_sendf(cl, NULL, "%s: %s\r\n",
res->headers[i], res->headers[i+1]));
}
/* terminate header */
- ensure(uh_http_send(cl, NULL, "\r\n", -1));
+ ensure_out(uh_http_send(cl, NULL, "\r\n", -1));
/* push out remaining head buffer */
if( hdroff < hdrlen )
- ensure(uh_http_send(cl, req, &hdr[hdroff], hdrlen - hdroff));
+ ensure_out(uh_http_send(cl, req, &hdr[hdroff], hdrlen - hdroff));
}
/* ... failed and head buffer exceeded */
else if( hdrlen >= sizeof(hdr) )
{
- ensure(uh_cgi_error_500(cl, req,
+ ensure_out(uh_cgi_error_500(cl, req,
"The CGI program generated an invalid response:\n\n"));
- ensure(uh_http_send(cl, req, hdr, hdrlen));
+ ensure_out(uh_http_send(cl, req, hdr, hdrlen));
}
/* ... failed but free buffer space, try again */
/* push out remaining read buffer */
if( bufoff < buflen )
- ensure(uh_http_send(cl, req, &buf[bufoff], buflen - bufoff));
+ ensure_out(uh_http_send(cl, req, &buf[bufoff], buflen - bufoff));
header_sent = 1;
continue;
/* headers complete, pass through buffer to socket */
- ensure(uh_http_send(cl, req, buf, buflen));
+ ensure_out(uh_http_send(cl, req, buf, buflen));
}
/* looks like eof from child */
* build the required headers here.
*/
- ensure(uh_http_sendf(cl, NULL,
+ ensure_out(uh_http_sendf(cl, NULL,
"HTTP/%.1f 200 OK\r\n"
"Content-Type: text/plain\r\n"
"%s\r\n",
? "Transfer-Encoding: chunked\r\n" : ""
));
- ensure(uh_http_send(cl, req, hdr, hdrlen));
+ ensure_out(uh_http_send(cl, req, hdr, hdrlen));
}
/* send final chunk if we're in chunked transfer mode */
- ensure(uh_http_send(cl, req, "", 0));
+ ensure_out(uh_http_send(cl, req, "", 0));
break;
}
}
{
if( (errno != EINTR) && ! header_sent )
{
- ensure(uh_http_sendhf(cl, 504, "Gateway Timeout",
+ ensure_out(uh_http_sendhf(cl, 504, "Gateway Timeout",
"The CGI script took too long to produce "
"a response"));
}
/* send final chunk if we're in chunked transfer mode */
- ensure(uh_http_send(cl, req, "", 0));
+ ensure_out(uh_http_send(cl, req, "", 0));
break;
}
return NULL;
}
-#define ensure_ret(x) \
- do { if( x < 0 ) return -1; } while(0)
static int uh_file_response_ok_hdrs(struct client *cl, struct http_request *req, struct stat *s)
{
"Connection: close\r\n", req->version);
}
-static int uh_file_if_match(struct client *cl, struct http_request *req, struct stat *s)
+static int uh_file_if_match(struct client *cl, struct http_request *req, struct stat *s, int *ok)
{
const char *tag = uh_file_mktag(s);
char *hdr = uh_file_header_lookup(req, "If-Match");
}
else if( !strcmp(p, "*") || !strcmp(p, tag) )
{
- return 1;
+ *ok = 1;
+ return *ok;
}
}
- uh_file_response_412(cl, req);
- return 0;
+ *ok = 0;
+ ensure_ret(uh_file_response_412(cl, req));
+ return *ok;
}
- return 1;
+ *ok = 1;
+ return *ok;
}
-static int uh_file_if_modified_since(struct client *cl, struct http_request *req, struct stat *s)
+static int uh_file_if_modified_since(struct client *cl, struct http_request *req, struct stat *s, int *ok)
{
char *hdr = uh_file_header_lookup(req, "If-Modified-Since");
+ *ok = 1;
if( hdr )
{
- if( uh_file_date2unix(hdr) < s->st_mtime )
+ if( uh_file_date2unix(hdr) >= s->st_mtime )
{
- return 1;
- }
- else
- {
- uh_file_response_304(cl, req, s);
- return 0;
+ *ok = 0;
+ ensure_ret(uh_file_response_304(cl, req, s));
}
}
- return 1;
+ return *ok;
}
-static int uh_file_if_none_match(struct client *cl, struct http_request *req, struct stat *s)
+static int uh_file_if_none_match(struct client *cl, struct http_request *req, struct stat *s, int *ok)
{
const char *tag = uh_file_mktag(s);
char *hdr = uh_file_header_lookup(req, "If-None-Match");
char *p;
int i;
+ *ok = 1;
if( hdr )
{
}
else if( !strcmp(p, "*") || !strcmp(p, tag) )
{
+ *ok = 0;
+
if( (req->method == UH_HTTP_MSG_GET) ||
(req->method == UH_HTTP_MSG_HEAD) )
- uh_file_response_304(cl, req, s);
+ ensure_ret(uh_file_response_304(cl, req, s));
else
- uh_file_response_412(cl, req);
+ ensure_ret(uh_file_response_412(cl, req));
- return 0;
+ break;
}
}
}
- return 1;
+ return *ok;
}
-static int uh_file_if_range(struct client *cl, struct http_request *req, struct stat *s)
+static int uh_file_if_range(struct client *cl, struct http_request *req, struct stat *s, int *ok)
{
char *hdr = uh_file_header_lookup(req, "If-Range");
+ *ok = 1;
if( hdr )
{
- uh_file_response_412(cl, req);
- return 0;
+ *ok = 0;
+ ensure_ret(uh_file_response_412(cl, req));
}
- return 1;
+ return *ok;
}
-static int uh_file_if_unmodified_since(struct client *cl, struct http_request *req, struct stat *s)
+static int uh_file_if_unmodified_since(struct client *cl, struct http_request *req, struct stat *s, int *ok)
{
char *hdr = uh_file_header_lookup(req, "If-Unmodified-Since");
+ *ok = 1;
if( hdr )
{
if( uh_file_date2unix(hdr) <= s->st_mtime )
{
- uh_file_response_412(cl, req);
- return 0;
+ *ok = 0;
+ ensure_ret(uh_file_response_412(cl, req));
}
}
- return 1;
+ return *ok;
}
-#define ensure_out(x) \
- do { if( x < 0 ) goto out; } while(0)
-
static int uh_file_scandir_filter_dir(const struct dirent *e)
{
return strcmp(e->d_name, ".") ? 1 : 0;
void uh_file_request(struct client *cl, struct http_request *req, struct path_info *pi)
{
int rlen;
+ int ok = 1;
int fd = -1;
char buf[UH_LIMIT_MSGHEAD];
if( (pi->stat.st_mode & S_IFREG) && ((fd = open(pi->phys, O_RDONLY)) > 0) )
{
/* test preconditions */
- if(
- uh_file_if_modified_since(cl, req, &pi->stat) &&
- uh_file_if_match(cl, req, &pi->stat) &&
- uh_file_if_range(cl, req, &pi->stat) &&
- uh_file_if_unmodified_since(cl, req, &pi->stat) &&
- uh_file_if_none_match(cl, req, &pi->stat)
- ) {
+ if(ok) ensure_out(uh_file_if_modified_since(cl, req, &pi->stat, &ok));
+ if(ok) ensure_out(uh_file_if_match(cl, req, &pi->stat, &ok));
+ if(ok) ensure_out(uh_file_if_range(cl, req, &pi->stat, &ok));
+ if(ok) ensure_out(uh_file_if_unmodified_since(cl, req, &pi->stat, &ok));
+ if(ok) ensure_out(uh_file_if_none_match(cl, req, &pi->stat, &ok));
+
+ if( ok > 0 )
+ {
/* write status */
ensure_out(uh_file_response_200(cl, req, &pi->stat));
int uh_tls_client_recv(struct client *c, void *buf, int len)
{
- return SSL_read(c->tls, buf, len);
+ int rv = SSL_read(c->tls, buf, len);
+ return (rv > 0) ? rv : -1;
}
int uh_tls_client_send(struct client *c, void *buf, int len)
{
- return SSL_write(c->tls, buf, len);
+ int rv = SSL_write(c->tls, buf, len);
+ return (rv > 0) ? rv : -1;
}
void uh_tls_client_close(struct client *c)
/* unblock SIGCHLD */
sigemptyset(&ssn);
sigaddset(&ssn, SIGCHLD);
+ sigaddset(&ssn, SIGPIPE);
sigprocmask(SIG_UNBLOCK, &ssn, &sso);
rv = select(n, r, w, e, t);
return sz;
}
-#define ensure(x) \
- do { if( x < 0 ) return -1; } while(0)
int uh_http_sendhf(struct client *cl, int code, const char *summary, const char *fmt, ...)
{
code, summary
);
- ensure(uh_tcp_send(cl, buffer, len));
+ ensure_ret(uh_tcp_send(cl, buffer, len));
va_start(ap, fmt);
len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
va_end(ap);
- ensure(uh_http_sendc(cl, buffer, len));
- ensure(uh_http_sendc(cl, NULL, 0));
+ ensure_ret(uh_http_sendc(cl, buffer, len));
+ ensure_ret(uh_http_sendc(cl, NULL, 0));
return 0;
}
if( len > 0 )
{
clen = snprintf(chunk, sizeof(chunk), "%X\r\n", len);
- ensure(uh_tcp_send(cl, chunk, clen));
- ensure(uh_tcp_send(cl, data, len));
- ensure(uh_tcp_send(cl, "\r\n", 2));
+ ensure_ret(uh_tcp_send(cl, chunk, clen));
+ ensure_ret(uh_tcp_send(cl, data, len));
+ ensure_ret(uh_tcp_send(cl, "\r\n", 2));
}
else
{
- ensure(uh_tcp_send(cl, "0\r\n\r\n", 5));
+ ensure_ret(uh_tcp_send(cl, "0\r\n\r\n", 5));
}
return 0;
va_end(ap);
if( (req != NULL) && (req->version > 1.0) )
- ensure(uh_http_sendc(cl, buffer, len));
+ ensure_ret(uh_http_sendc(cl, buffer, len));
else if( len > 0 )
- ensure(uh_tcp_send(cl, buffer, len));
+ ensure_ret(uh_tcp_send(cl, buffer, len));
return 0;
}
len = strlen(buf);
if( (req != NULL) && (req->version > 1.0) )
- ensure(uh_http_sendc(cl, buf, len));
+ ensure_ret(uh_http_sendc(cl, buf, len));
else if( len > 0 )
- ensure(uh_tcp_send(cl, buf, len));
+ ensure_ret(uh_tcp_send(cl, buf, len));
return 0;
}
) {
memcpy(new->pass, pwd->pw_passwd,
min(strlen(pwd->pw_passwd), sizeof(new->pass) - 1));
- }
+ }
}
/* ordinary pwd */
#define fd_cloexec(fd) \
fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC)
+#define ensure_out(x) \
+ do { if((x) < 0) goto out; } while(0)
+
+#define ensure_ret(x) \
+ do { if((x) < 0) return -1; } while(0)
+
+
struct path_info {
char *root;
char *phys;
conf->error_handler = strdup(col1);
}
#ifdef HAVE_CGI
- else if( (line[0] == '.') && (strchr(line, ':') != NULL) )
+ else if( (line[0] == '*') && (strchr(line, ':') != NULL) )
{
- if( !(col1 = strchr(line, ':')) || (*col1++ = 0) ||
- !(eol = strchr(col1, '\n')) || (*eol++ = 0) )
+ if( !(col1 = strchr(line, '*')) || (*col1++ = 0) ||
+ !(col2 = strchr(col1, ':')) || (*col2++ = 0) ||
+ !(eol = strchr(col2, '\n')) || (*eol++ = 0) )
continue;
- if( !uh_interpreter_add(line, col1) )
+ if( !uh_interpreter_add(col1, col2) )
{
fprintf(stderr,
"Unable to add interpreter %s for extension %s: "
- "Out of memory\n", col1, line
+ "Out of memory\n", col2, col1
);
}
}
int status;
int bound = 0;
+ int tcp_ka_idl = 1;
+ int tcp_ka_int = 1;
+ int tcp_ka_cnt = 3;
+
struct listener *l = NULL;
struct addrinfo *addrs = NULL, *p = NULL;
}
/* "address already in use" */
- if( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1 )
+ if( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) )
{
perror("setsockopt()");
goto error;
}
+ /* TCP keep-alive */
+ if( setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) ||
+ setsockopt(sock, SOL_TCP, TCP_KEEPIDLE, &tcp_ka_idl, sizeof(tcp_ka_idl)) ||
+ setsockopt(sock, SOL_TCP, TCP_KEEPINTVL, &tcp_ka_int, sizeof(tcp_ka_int)) ||
+ setsockopt(sock, SOL_TCP, TCP_KEEPCNT, &tcp_ka_cnt, sizeof(tcp_ka_cnt)) )
+ {
+ fprintf(stderr, "Notice: Unable to enable TCP keep-alive: %s\n",
+ strerror(errno));
+ }
+
/* required to get parallel v4 + v6 working */
if( p->ai_family == AF_INET6 )
{
ssize_t blen = sizeof(buffer)-1;
ssize_t rlen = 0;
-
memset(buffer, 0, sizeof(buffer));
while( blen > 0 )
if( select(cl->socket + 1, &reader, NULL, NULL, &timeout) > 0 )
{
/* receive data */
- rlen = uh_tcp_peek(cl, bufptr, blen);
+ ensure_out(rlen = uh_tcp_peek(cl, bufptr, blen));
- if( rlen > 0 )
+ if( (idxptr = strfind(buffer, sizeof(buffer), "\r\n\r\n", 4)) )
{
- if( (idxptr = strfind(buffer, sizeof(buffer), "\r\n\r\n", 4)) )
- {
- blen -= uh_tcp_recv(cl, bufptr, (int)(idxptr - bufptr) + 4);
+ ensure_out(rlen = uh_tcp_recv(cl, bufptr,
+ (int)(idxptr - bufptr) + 4));
- /* header read complete ... */
- return uh_http_header_parse(cl, buffer, sizeof(buffer) - blen - 1);
- }
- else
- {
- rlen = uh_tcp_recv(cl, bufptr, rlen);
- blen -= rlen;
- bufptr += rlen;
- }
+ /* header read complete ... */
+ blen -= rlen;
+ return uh_http_header_parse(cl, buffer,
+ sizeof(buffer) - blen - 1);
}
else
{
- /* invalid request (unexpected eof/timeout) */
- uh_http_response(cl, 408, "Request Timeout");
- return NULL;
+ ensure_out(rlen = uh_tcp_recv(cl, bufptr, rlen));
+
+ blen -= rlen;
+ bufptr += rlen;
}
}
else
{
/* invalid request (unexpected eof/timeout) */
- uh_http_response(cl, 408, "Request Timeout");
return NULL;
}
}
/* request entity too large */
uh_http_response(cl, 413, "Request Entity Too Large");
+
+out:
return NULL;
}
#include <sys/select.h>
#include <sys/wait.h>
#include <netinet/in.h>
+#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <linux/limits.h>
#include <netdb.h>
#include <openssl/ssl.h>
#endif
+/* uClibc... */
+#ifndef SOL_TCP
+#define SOL_TCP 6
+#endif
+
#define UH_LIMIT_MSGHEAD 4096
#define UH_LIMIT_HEADERS 64
projects / openwrt / staging / yousong.git / commitdiff