Lab
/
libuhttpd
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'upstream/master' into main

main
Chris Babcock 2021-03-06 23:52:36 -07:00
parent 3dbd2c0fc8 7f5b41317b
commit e29741fb1f
31 changed files with 1721 additions and 583 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
.github/workflows/build.yml vendored 100644
View File

@ -0,0 +1,32 @@
name: build
on: push
jobs:
build:
runs-on: ubuntu-20.04
strategy:
matrix:
include:
- ssl: none
name: none
- ssl: openssl
name: OPENSSL
pkg: libssl-dev
- ssl: mbedtls
name: MBEDTLS
pkg: libmbedtls-dev
- ssl: wolfssl
name: WOLFSSL
pkg: libwolfssl-dev
steps:
- uses: actions/checkout@v2
with:
submodules: true
- name: build
env:
name: ${{ matrix.name }}
pkg: ${{ matrix.pkg }}
run: |
sudo apt install -y libev-dev
[ -n "$pkg" ] && sudo apt install -y $pkg
[ "$name" = "none" ] && cmake . -DUHTTPD_SSL_SUPPORT=OFF || cmake . -DUHTTPD_USE_$name=ON
make

45
.github/workflows/release.yml vendored 100644
View File

@ -0,0 +1,45 @@
name: release
on:
push:
tags:
- 'v*'
jobs:
release:
runs-on: ubuntu-20.04
steps:
- id: changelog
uses: zhaojh329/auto-changelog@master
with:
token: ${{ secrets.GITHUB_TOKEN }}
- id: release
uses: actions/create-release@v1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
tag_name: ${{ github.ref }}
release_name: ${{ github.ref }}
draft: true
body: ${{steps.changelog.outputs.changelog}}
- uses: actions/checkout@v2
with:
submodules: true
- id: get-version
uses: battila7/get-version-action@v2
- id: release-asset
run: |
version=${{ steps.get-version.outputs.version-without-v }}
cd ..
cp -r libuhttpd libuhttpd-$version
rm -rf libuhttpd-$version/.git* libuhttpd-$version/src/buffer/.git* libuhttpd-$version/src/http-parser/{.git*,.mailmap,.travis.yml}
tar zcfv libuhttpd-$version.tar.gz libuhttpd-$version
echo "::set-output name=asset-path::../libuhttpd-$version.tar.gz"
echo "::set-output name=asset-name::libuhttpd-$version.tar.gz"
- id: upload-release-asset
uses: actions/upload-release-asset@v1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.release.outputs.upload_url }}
asset_path: ${{ steps.release-asset.outputs.asset-path }}
asset_name: ${{ steps.release-asset.outputs.asset-name }}
asset_content_type: application/gzip

11
.gitignore vendored
View File

@ -50,14 +50,3 @@ modules.order
Module.symvers
Mkfile.old
dkms.conf
server-cert.pem
server-key.pem
build/
CMakeFiles
CMakeCache.txt
cmake_install.cmake
Makefile
helloworld

13
.travis.yml
View File

@ -1,13 +0,0 @@
language: c
os:
- linux
before_install:
- sudo apt-get -qq update
- sudo apt-get install -y libssl-dev libev-dev
script:
- mkdir build && cd build
- cmake ..
- make && sudo make install

8
CMakeLists.txt
View File

@ -1,11 +1,15 @@
cmake_minimum_required(VERSION 2.8)
cmake_minimum_required(VERSION 2.8.12)
project(libuhttpd C)
option(BUILD_EXAMPLE "Build example" ON)
INCLUDE(CheckLibraryExists)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules/")
add_subdirectory(src)
add_subdirectory(example)
if(BUILD_EXAMPLE)
add_subdirectory(example)
endif()

41
README.md
View File

@ -9,16 +9,15 @@
[4]: https://github.com/zhaojh329/libuhttpd/pulls
[5]: https://img.shields.io/badge/Issues-welcome-brightgreen.svg?style=plastic
[6]: https://github.com/zhaojh329/libuhttpd/issues/new
[7]: https://img.shields.io/badge/release-3.7.0-blue.svg?style=plastic
[7]: https://img.shields.io/badge/release-3.10.1-blue.svg?style=plastic
[8]: https://github.com/zhaojh329/libuhttpd/releases
[9]: https://travis-ci.org/zhaojh329/libuhttpd.svg?branch=master
[10]: https://travis-ci.org/zhaojh329/libuhttpd
[9]: https://github.com/zhaojh329/libuhttpd/workflows/build/badge.svg
[![license][1]][2]
[![PRs Welcome][3]][4]
[![Issue Welcome][5]][6]
[![Release Version][7]][8]
[![Build Status][9]][10]
![Build Status][9]
[libev]: http://software.schmorp.de/pkg/libev.html
[http-parser]: https://github.com/nodejs/http-parser
@ -32,19 +31,47 @@ A very flexible, lightweight and fully asynchronous HTTP server library based on
* Lightweight and fully asynchronous
* Use [libev] as its event backend
* Support HTTPS - OpenSSL, mbedtls and CyaSSl(wolfssl)
* Support HTTP pipelining
* Support IPv6
* Support plugin
* Support upload large file
* Support HTTP range requests
* Support multi-process model - The same multi-process model as Nginx
* Flexible - you can easily extend your application to have HTTP/HTTPS services
* Code structure is concise and understandable, also suitable for learning
# Dependencies
* [libev]
* [http-parser] - A parser for HTTP messages written in C
* [libev] - A full-featured and high-performance event loop
* [http-parser] - A high performance parser for HTTP messages written in C
* [mbedtls] - If you choose mbedtls as your SSL backend
* [wolfssl] - If you choose wolfssl as your SSL backend
* [openssl] - If you choose openssl as your SSL backend
# Benchmark
## Nginx
$ wrk -t4 -c400 -d10s http://localhost:80/test.html
Running 10s test @ http://localhost:80/test.html
4 threads and 400 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 3.54ms 7.32ms 224.58ms 93.30%
Req/Sec 40.63k 12.49k 96.29k 74.50%
1622012 requests in 10.05s, 385.09MB read
Requests/sec: 161390.39
Transfer/sec: 38.32MB
## libuhttpd
$ wrk -t4 -c400 -d10s http://localhost:8080/test.html
Running 10s test @ http://localhost:8080/test.html
4 threads and 400 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 2.12ms 3.01ms 31.30ms 89.26%
Req/Sec 70.87k 12.53k 142.54k 79.75%
2826394 requests in 10.05s, 547.18MB read
Requests/sec: 281328.83
Transfer/sec: 54.46MB
# Configure
See which configuration are supported
@ -59,7 +86,7 @@ See which configuration are supported
# Run Example
Run
~/libuhttpd/build$ ./example/example
~/libuhttpd/build$ ./example/simple_server -v
Then use the command curl or browser to test

41
README_ZH.md
View File

@ -6,16 +6,15 @@
[4]: https://github.com/zhaojh329/libuhttpd/pulls
[5]: https://img.shields.io/badge/Issues-welcome-brightgreen.svg?style=plastic
[6]: https://github.com/zhaojh329/libuhttpd/issues/new
[7]: https://img.shields.io/badge/release-3.7.0-blue.svg?style=plastic
[7]: https://img.shields.io/badge/release-3.10.1-blue.svg?style=plastic
[8]: https://github.com/zhaojh329/libuhttpd/releases
[9]: https://travis-ci.org/zhaojh329/libuhttpd.svg?branch=master
[10]: https://travis-ci.org/zhaojh329/libuhttpd
[9]: https://github.com/zhaojh329/libuhttpd/workflows/build/badge.svg
[![license][1]][2]
[![PRs Welcome][3]][4]
[![Issue Welcome][5]][6]
[![Release Version][7]][8]
[![Build Status][9]][10]
![Build Status][9]
[libev]: http://software.schmorp.de/pkg/libev.html
[http-parser]: https://github.com/nodejs/http-parser
@ -29,19 +28,47 @@
* 轻量、全异步
* 使用[libev]作为其事件后端
* 支持HTTPS - OpenSSL, mbedtls 和 CyaSSl(wolfssl)
* 支持 HTTP 流水线
* 支持 IPv6
* 支持插件
* 支持上传大文件
* 支持 HTTP 范围请求
* 支持多进程模型 - 和 Nginx 一样的多进程模型
* 可伸缩 - 你可以非常方便的扩展你的应用程序，使之具备HTTP/HTTPS服务
* 代码结构简洁通俗易懂，亦适合学习
# 依赖
* [libev]
* [http-parser] - 已经集成到源码里面
* [libev] - 一个全功能和高性能的事件循环库
* [http-parser] - 一个用 C 语言编写的高性能的 HTTP 消息解析器
* [mbedtls] - 如果你选择mbedtls作为你的SSL后端
* [wolfssl] - 如果你选择wolfssl作为你的SSL后端
* [openssl] - 如果你选择openssl作为你的SSL后端
# 基准测试
## Nginx
$ wrk -t4 -c400 -d10s http://localhost:80/test.html
Running 10s test @ http://localhost:80/test.html
4 threads and 400 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 3.54ms 7.32ms 224.58ms 93.30%
Req/Sec 40.63k 12.49k 96.29k 74.50%
1622012 requests in 10.05s, 385.09MB read
Requests/sec: 161390.39
Transfer/sec: 38.32MB
## libuhttpd
$ wrk -t4 -c400 -d10s http://localhost:8080/test.html
Running 10s test @ http://localhost:8080/test.html
4 threads and 400 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 2.12ms 3.01ms 31.30ms 89.26%
Req/Sec 70.87k 12.53k 142.54k 79.75%
2826394 requests in 10.05s, 547.18MB read
Requests/sec: 281328.83
Transfer/sec: 54.46MB
# 配置
查看支持哪些配置选项
@ -56,7 +83,7 @@
# 运行示例程序
运行
~/libuhttpd/build$ ./example/example -v
~/libuhttpd/build$ ./example/simple_server -v
然后使用命令curl或者浏览器进行测试

15
example/CMakeLists.txt
View File

@ -5,14 +5,23 @@ include_directories(
${CMAKE_BINARY_DIR}/src
${LIBEV_INCLUDE_DIR})
add_executable(example example.c)
set(LIBS ${LIBEV_LIBRARY})
if(BUILD_SHARED_LIBS)
target_link_libraries(example uhttpd ${LIBEV_LIBRARY})
list(APPEND LIBS uhttpd)
else()
target_link_libraries(example uhttpd_s ${LIBEV_LIBRARY})
list(APPEND LIBS uhttpd_s)
endif()
add_executable(simple_server simple_server.c handler.c)
target_link_libraries(simple_server ${LIBS})
add_executable(multi_process_server_reuseport multi_process_server_reuseport.c handler.c)
target_link_libraries(multi_process_server_reuseport ${LIBS})
add_executable(multi_process_server multi_process_server.c handler.c)
target_link_libraries(multi_process_server ${LIBS})
if(HAVE_DLOPEN)
add_library(test_plugin MODULE test_plugin.c)
set_target_properties(test_plugin PROPERTIES OUTPUT_NAME test_plugin PREFIX "")

210
example/example.c
View File

@ -1,210 +0,0 @@
/*
* MIT License
*
* Copyright (c) 2019 Jianhui Zhao <zhaojh329@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include "uhttpd.h"
static bool serve_file = false;
static const char *docroot = ".";
static const char *index_page = "index.html";
static void default_handler(struct uh_connection *conn, int event)
{
if (event != UH_EV_COMPLETE)
return;
if (!serve_file) {
struct uh_str path = conn->get_path(conn);
struct uh_str query = conn->get_query(conn);
struct uh_str ua = conn->get_header(conn, "User-Agent");
struct uh_str body = conn->get_body(conn);
conn->send_head(conn, HTTP_STATUS_OK, -1, NULL);
conn->chunk_printf(conn, "I'm Libuhttpd: %s\n", UHTTPD_VERSION_STRING);
conn->chunk_printf(conn, "Method: %s\n", conn->get_method_str(conn));
conn->chunk_printf(conn, "Path: %.*s\n", path.len ,path.p);
conn->chunk_printf(conn, "Query: %.*s\n", query.len, query.p);
conn->chunk_printf(conn, "User-Agent: %.*s\n", ua.len, ua.p);
conn->chunk_printf(conn, "Body: %.*s\n", body.len, body.p);
conn->chunk_end(conn);
conn->done(conn);
} else {
conn->serve_file(conn, docroot, index_page);
}
}
static void upload_handler(struct uh_connection *conn, int event)
{
static int fd = -1;
if (event == UH_EV_HEAD_COMPLETE) {
struct uh_str str = conn->get_header(conn, "Content-Length");
int content_length;
char buf[128];
sprintf(buf, "%.*s\n", (int)str.len, str.p);
content_length = atoi(buf);
if (content_length > 1024 * 1024 * 1024) {
conn->error(conn, HTTP_STATUS_INTERNAL_SERVER_ERROR, "Too big");
return;
}
} if (event == UH_EV_BODY) {
struct uh_str body = conn->extract_body(conn);
if (fd < 0) {
fd = open("upload.bin", O_RDWR | O_CREAT | O_TRUNC, 0644);
if (fd < 0) {
conn->error(conn, HTTP_STATUS_INTERNAL_SERVER_ERROR, strerror(errno));
return;
}
}
if (write(fd, body.p, body.len) < 0) {
conn->error(conn, HTTP_STATUS_INTERNAL_SERVER_ERROR, strerror(errno));
close(fd);
return;
}
} else if (event == UH_EV_COMPLETE) {
struct stat st;
size_t size = 0;
conn->send_head(conn, HTTP_STATUS_OK, -1, NULL);
if (fd > 0) {
fstat(fd, &st);
close(fd);
fd = -1;
size = st.st_size;
}
conn->chunk_printf(conn, "Upload size: %zd\n", size);
conn->chunk_end(conn);
conn->done(conn);
}
}
static void signal_cb(struct ev_loop *loop, ev_signal *w, int revents)
{
if (w->signum == SIGINT) {
ev_break(loop, EVBREAK_ALL);
uh_log_info("Normal quit\n");
}
}
static void usage(const char *prog)
{
fprintf(stderr, "Usage: %s [option]\n"
" -a addr # Default addr is localhost\n"
" -p port # Default port is 8080\n"
" -s # SSl on\n"
" -f # Serve file\n"
" -P # plugin path\n"
" -v # verbose\n", prog);
exit(1);
}
int main(int argc, char **argv)
{
struct ev_loop *loop = EV_DEFAULT;
struct ev_signal signal_watcher;
struct uh_server *srv = NULL;
const char *plugin_path = NULL;
bool verbose = false;
bool ssl = false;
const char *addr = "localhost";
int port = 8080;
int opt;
while ((opt = getopt(argc, argv, "a:p:sfP:v")) != -1) {
switch (opt) {
case 'a':
addr = optarg;
break;
case 'p':
port = atoi(optarg);
break;
case 's':
ssl = true;
break;
case 'f':
serve_file = true;
break;
case 'P':
plugin_path = optarg;
break;
case 'v':
verbose = true;
break;
default: /* '?' */
usage(argv[0]);
}
}
if (!verbose)
uh_log_threshold(LOG_ERR);
uh_log_info("libuhttpd version: %s\n", UHTTPD_VERSION_STRING);
signal(SIGPIPE, SIG_IGN);
srv = uh_server_new(loop, addr, port);
if (!srv)
return -1;
#if UHTTPD_SSL_SUPPORT
if (ssl && srv->ssl_init(srv, "server-cert.pem", "server-key.pem") < 0)
goto err;
#endif
srv->default_handler = default_handler;
srv->add_path_handler(srv, "/upload", upload_handler);
if (plugin_path)
srv->load_plugin(srv, plugin_path);
ev_signal_init(&signal_watcher, signal_cb, SIGINT);
ev_signal_start(loop, &signal_watcher);
ev_run(loop, 0);
err:
srv->free(srv);
free(srv);
ev_loop_destroy(loop);
return 0;
}

112
example/handler.c 100644
View File

@ -0,0 +1,112 @@
/*
* MIT License
*
* Copyright (c) 2019 Jianhui Zhao <zhaojh329@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include "uhttpd.h"
void default_handler(struct uh_connection *conn, int event)
{
if (event != UH_EV_COMPLETE)
return;
conn->serve_file(conn);
}
void echo_handler(struct uh_connection *conn, int event)
{
if (event == UH_EV_COMPLETE) {
struct uh_str path = conn->get_path(conn);
struct uh_str query = conn->get_query(conn);
struct uh_str ua = conn->get_header(conn, "User-Agent");
struct uh_str body = conn->get_body(conn);
conn->send_head(conn, HTTP_STATUS_OK, -1, NULL);
conn->chunk_printf(conn, "I'm Libuhttpd: %s\n", UHTTPD_VERSION_STRING);
conn->chunk_printf(conn, "Method: %s\n", conn->get_method_str(conn));
conn->chunk_printf(conn, "Path: %.*s\n", (int)path.len, path.p);
conn->chunk_printf(conn, "Query: %.*s\n", (int)query.len, query.p);
conn->chunk_printf(conn, "User-Agent: %.*s\n", (int)ua.len, ua.p);
conn->chunk_printf(conn, "Body: %.*s\n", (int)body.len, body.p);
conn->chunk_end(conn);
conn->done(conn);
}
}
void upload_handler(struct uh_connection *conn, int event)
{
if (event == UH_EV_HEAD_COMPLETE) {
uint64_t content_length = conn->get_content_length(conn);
if (content_length > 1024 * 1024 * 1024) {
conn->error(conn, HTTP_STATUS_INTERNAL_SERVER_ERROR, "Too big");
return;
}
conn->userdata = (void *)(intptr_t)-1;
} if (event == UH_EV_BODY) {
struct uh_str body = conn->extract_body(conn);
int fd = (intptr_t)conn->userdata;
if (fd < 0) {
fd = open("upload.bin", O_RDWR | O_CREAT | O_TRUNC, 0644);
if (fd < 0) {
conn->error(conn, HTTP_STATUS_INTERNAL_SERVER_ERROR, strerror(errno));
return;
}
}
if (write(fd, body.p, body.len) < 0) {
conn->error(conn, HTTP_STATUS_INTERNAL_SERVER_ERROR, strerror(errno));
close(fd);
return;
}
conn->userdata = (void *)(intptr_t)fd;
} else if (event == UH_EV_COMPLETE) {
int fd = (intptr_t)conn->userdata;
struct stat st;
size_t size = 0;
conn->send_head(conn, HTTP_STATUS_OK, -1, NULL);
if (fd > 0) {
fstat(fd, &st);
close(fd);
fd = -1;
size = st.st_size;
}
conn->chunk_printf(conn, "Upload size: %zd\n", size);
conn->chunk_end(conn);
conn->done(conn);
}
}

34
example/handler.h 100644
View File

@ -0,0 +1,34 @@
/*
* MIT License
*
* Copyright (c) 2019 Jianhui Zhao <zhaojh329@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef _EXAMPLE_HANDLER_H
#define _EXAMPLE_HANDLER_H
#include "uhttpd.h"
void default_handler(struct uh_connection *conn, int event);
void echo_handler(struct uh_connection *conn, int event);
void upload_handler(struct uh_connection *conn, int event);
#endif

170
example/multi_process_server.c 100644
View File

@ -0,0 +1,170 @@
/*
* MIT License
*
* Copyright (c) 2019 Jianhui Zhao <zhaojh329@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <sys/sysinfo.h>
#include <sys/prctl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include "handler.h"
#define MAX_WORKER 10
static void signal_cb(struct ev_loop *loop, ev_signal *w, int revents)
{
int i;
if (w->signum == SIGINT) {
pid_t *workers = w->data;
for (i = 0; i < MAX_WORKER; i++) {
if (workers[i] == 0)
break;
kill(workers[i], SIGKILL);
}
ev_break(loop, EVBREAK_ALL);
uh_log_info("Normal quit\n");
}
}
static void usage(const char *prog)
{
fprintf(stderr, "Usage: %s [option]\n"
" -h docroot # Document root, default is .\n"
" -i index_page # Index page, default is index.html\n"
" -a addr # address to listen\n"
" -s addr # address to listen with ssl\n"
" -P # plugin path\n"
" -w # worker process number, default is equal to available CPUs\n"
" -v # verbose\n", prog);
exit(1);
}
int main(int argc, char **argv)
{
struct ev_loop *loop = EV_DEFAULT;
struct ev_signal signal_watcher;
struct uh_server *srv = NULL;
const char *plugin_path = NULL;
bool verbose = false;
const char *docroot = ".";
const char *index_page = "index.html";
pid_t workers[MAX_WORKER] = {};
int nworker = get_nprocs();
int opt, i;
srv = uh_server_new(loop);
if (!srv)
return -1;
while ((opt = getopt(argc, argv, "h:i:a:s:P:w:v")) != -1) {
switch (opt) {
case 'h':
docroot = optarg;
break;
case 'i':
index_page = optarg;
break;
case 'a':
if (srv->listen(srv, optarg, false) < 1)
goto err;
break;
case 's':
if (srv->listen(srv, optarg, true) < 1)
goto err;
break;
case 'P':
plugin_path = optarg;
break;
case 'w':
nworker = atoi(optarg);
case 'v':
verbose = true;
break;
default: /* '?' */
usage(argv[0]);
}
}
if (!verbose)
uh_log_threshold(LOG_ERR);
uh_log_info("libuhttpd version: %s\n", UHTTPD_VERSION_STRING);
if (nworker < 1)
return 0;
signal(SIGPIPE, SIG_IGN);
#if UHTTPD_SSL_SUPPORT
srv->ssl_init(srv, "cert.pem", "key.pem");
#endif
srv->set_docroot(srv, docroot);
srv->set_index_page(srv, index_page);
srv->set_default_handler(srv, default_handler);
srv->add_path_handler(srv, "/echo", echo_handler);
srv->add_path_handler(srv, "/upload", upload_handler);
if (plugin_path)
srv->load_plugin(srv, plugin_path);
for (i = 0; i < nworker - 1; i++) {
pid_t pid = fork();
if (pid < 0) {
uh_log_info("fork: %s\n", strerror(errno));
break;
}
if (pid == 0) {
prctl(PR_SET_PDEATHSIG, SIGKILL);
ev_loop_fork(loop);
ev_run(loop, 0);
return 0;
}
workers[i] = pid;
}
ev_signal_init(&signal_watcher, signal_cb, SIGINT);
signal_watcher.data = workers;
ev_signal_start(loop, &signal_watcher);
ev_run(loop, 0);
err:
srv->free(srv);
free(srv);
ev_loop_destroy(loop);
return 0;
}

189
example/multi_process_server_reuseport.c 100644
View File

@ -0,0 +1,189 @@
/*
* MIT License
*
* Copyright (c) 2019 Jianhui Zhao <zhaojh329@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <sys/sysinfo.h>
#include <sys/prctl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include "handler.h"
#define MAX_WORKER 10
static void signal_cb(struct ev_loop *loop, ev_signal *w, int revents)
{
int i;
if (w->signum == SIGINT) {
pid_t *workers = w->data;
for (i = 0; i < MAX_WORKER; i++) {
if (workers[i] == 0)
break;
kill(workers[i], SIGKILL);
}
ev_break(loop, EVBREAK_ALL);
uh_log_info("Normal quit\n");
}
}
static void usage(const char *prog)
{
fprintf(stderr, "Usage: %s [option]\n"
" -h docroot # Document root, default is .\n"
" -i index_page # Index page, default is index.html\n"
" -a addr # address to listen\n"
" -s addr # address to listen with ssl\n"
" -P # plugin path\n"
" -w # worker process number, default is equal to available CPUs\n"
" -v # verbose\n", prog);
exit(1);
}
static void start_server(const char *addr, const char *addrs, const char *docroot, const char *index_page, const char *plugin, bool ssl)
{
struct ev_loop *loop = ev_loop_new(0);
struct uh_server *srv = NULL;
signal(SIGPIPE, SIG_IGN);
srv = uh_server_new(loop);
if (!srv)
return;
if (addr) {
if (srv->listen(srv, addrs, false) < 0)
return;
} else if (addrs) {
if (srv->listen(srv, addrs, true) < 0)
return;
} else {
return;
}
#if UHTTPD_SSL_SUPPORT
if (ssl && srv->ssl_init(srv, "cert.pem", "key.pem") < 0)
return;
#endif
srv->set_docroot(srv, docroot);
srv->set_index_page(srv, index_page);
srv->set_default_handler(srv, default_handler);
srv->add_path_handler(srv, "/echo", echo_handler);
srv->add_path_handler(srv, "/upload", upload_handler);
if (plugin)
srv->load_plugin(srv, plugin);
ev_run(loop, 0);
}
int main(int argc, char **argv)
{
struct ev_loop *loop = EV_DEFAULT;
struct ev_signal signal_watcher;
const char *plugin_path = NULL;
bool verbose = false;
bool ssl = false;
const char *docroot = ".";
const char *index_page = "index.html";
const char *addr = NULL;
const char *addrs = NULL;
pid_t workers[MAX_WORKER] = {};
int nworker = get_nprocs();
int opt, i;
while ((opt = getopt(argc, argv, "h:i:a:s:P:w:v")) != -1) {
switch (opt) {
case 'h':
docroot = optarg;
break;
case 'i':
index_page = optarg;
break;
case 'a':
addr = optarg;
break;
case 's':
addrs = optarg;
break;
case 'P':
plugin_path = optarg;
break;
case 'w':
nworker = atoi(optarg);
break;
case 'v':
verbose = true;
break;
default: /* '?' */
usage(argv[0]);
}
}
if (!verbose)
uh_log_threshold(LOG_ERR);
uh_log_info("libuhttpd version: %s\n", UHTTPD_VERSION_STRING);
if (!support_so_reuseport()) {
uh_log_err("Not support SO_REUSEPORT\n");
return -1;
}
if (nworker < 1)
return 0;
for (i = 0; i < nworker; i++) {
pid_t pid = fork();
if (pid < 0) {
uh_log_info("fork: %s\n", strerror(errno));
break;
}
if (pid == 0) {
prctl(PR_SET_PDEATHSIG, SIGKILL);
start_server(addr, addrs, docroot, index_page, plugin_path, ssl);
return 0;
}
workers[i] = pid;
}
ev_signal_init(&signal_watcher, signal_cb, SIGINT);
signal_watcher.data = workers;
ev_signal_start(loop, &signal_watcher);
ev_run(loop, 0);
ev_loop_destroy(loop);
return 0;
}

134
example/simple_server.c 100644
View File

@ -0,0 +1,134 @@
/*
* MIT License
*
* Copyright (c) 2019 Jianhui Zhao <zhaojh329@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include "handler.h"
static void conn_closed_cb(struct uh_connection *conn)
{
}
static void signal_cb(struct ev_loop *loop, ev_signal *w, int revents)
{
if (w->signum == SIGINT) {
ev_break(loop, EVBREAK_ALL);
uh_log_info("Normal quit\n");
}
}
static void usage(const char *prog)
{
fprintf(stderr, "Usage: %s [option]\n"
" -h docroot # Document root, default is .\n"
" -i index_page # Index page, default is index.html\n"
" -a addr # address to listen\n"
" -s addr # address to listen with ssl\n"
" -P # plugin path\n"
" -v # verbose\n", prog);
exit(1);
}
int main(int argc, char **argv)
{
struct ev_loop *loop = EV_DEFAULT;
struct ev_signal signal_watcher;
struct uh_server *srv = NULL;
const char *plugin_path = NULL;
bool verbose = false;
const char *docroot = ".";
const char *index_page = "index.html";
int opt;
srv = uh_server_new(loop);
if (!srv)
return -1;
while ((opt = getopt(argc, argv, "h:i:a:s:P:v")) != -1) {
switch (opt) {
case 'h':
docroot = optarg;
break;
case 'i':
index_page = optarg;
break;
case 'a':
if (srv->listen(srv, optarg, false) < 1)
goto err;
break;
case 's':
if (srv->listen(srv, optarg, true) < 1)
goto err;
break;
case 'P':
plugin_path = optarg;
break;
case 'v':
verbose = true;
break;
default:
usage(argv[0]);
}
}
if (!verbose)
uh_log_threshold(LOG_ERR);
uh_log_info("libuhttpd version: %s\n", UHTTPD_VERSION_STRING);
signal(SIGPIPE, SIG_IGN);
#if UHTTPD_SSL_SUPPORT
srv->ssl_init(srv, "cert.pem", "key.pem");
#endif
srv->set_docroot(srv, docroot);
srv->set_index_page(srv, index_page);
srv->set_conn_closed_cb(srv, conn_closed_cb);
srv->set_default_handler(srv, default_handler);
srv->add_path_handler(srv, "/echo", echo_handler);
srv->add_path_handler(srv, "/upload", upload_handler);
if (plugin_path)
srv->load_plugin(srv, plugin_path);
ev_signal_init(&signal_watcher, signal_cb, SIGINT);
ev_signal_start(loop, &signal_watcher);
ev_run(loop, 0);
err:
srv->free(srv);
free(srv);
ev_loop_destroy(loop);
return 0;
}

2
example/test_plugin.c
View File

@ -34,7 +34,7 @@ static void test_handler(struct uh_connection *conn, int event)
path = conn->get_path(conn);
conn->send_head(conn, 200, -1, NULL);
conn->chunk_printf(conn, "Path: %.*s\n", path.len, path.p);
conn->chunk_printf(conn, "Path: %.*s\n", (int)path.len, path.p);
conn->chunk_end(conn);
}

2
gen_cert.sh
View File

@ -1,3 +1,3 @@
#!/bin/sh
openssl req -x509 -newkey rsa:2048 -nodes -keyout server-key.pem -out server-cert.pem -config openssl.cnf
openssl req -x509 -newkey rsa:2048 -nodes -keyout key.pem -out cert.pem -subj "/C=CZ/O=Acme Inc./OU=ACME/CN=ACME-DEV-123"

5
openssl.cnf
View File

@ -1,5 +0,0 @@
[ req ]
distinguished_name = req_distinguished_name
prompt = no
[ req_distinguished_name ]
CN = DONT USE - test cert for libuhttp

8
src/CMakeLists.txt
View File

@ -1,10 +1,10 @@
add_definitions(-O -Wall -Werror --std=gnu99 -D_GNU_SOURCE)
add_definitions(-O -Wall -Werror --std=gnu99 -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64)
# The version number.
set(UHTTPD_VERSION_MAJOR 3)
set(UHTTPD_VERSION_MINOR 7)
set(UHTTPD_VERSION_PATCH 0)
set(UHTTPD_VERSION_MINOR 10)
set(UHTTPD_VERSION_PATCH 1)
# Check the third party Libraries
find_package(Libev REQUIRED)
@ -141,8 +141,8 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DI
install(
FILES
uhttpd.h
connection.h
log.h
utils.h
buffer/buffer.h
http-parser/http_parser.h
${CMAKE_CURRENT_BINARY_DIR}/config.h

2
src/buffer

@ -1 +1 @@
Subproject commit 55e4d3bddc1cd258766448788f8fa3e406e25065
Subproject commit 1bd1b6d192eda9e5bc24582e7ef3a4a017f9b064

446
src/connection.c
View File

@ -30,67 +30,117 @@
#include <assert.h>
#include <sys/sendfile.h>
#include "connection.h"
#include "uhttpd.h"
#include "uhttpd_internal.h"
#include "utils.h"
#include "file.h"
#include "ssl.h"
static void conn_done(struct uh_connection *conn)
{
struct ev_loop *loop = conn->srv->loop;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct ev_loop *loop = conni->srv->loop;
buffer_pull(&conn->rb, NULL, buffer_length(&conn->rb));
if (conni->flags & CONN_F_CLOSED)
return;
if (!http_should_keep_alive(&conn->parser))
conn->flags |= CONN_F_SEND_AND_CLOSE;
if (!http_should_keep_alive(&conni->parser))
conni->flags |= CONN_F_SEND_AND_CLOSE;
if (conn->flags & CONN_F_SEND_AND_CLOSE)
ev_io_stop(loop, &conn->ior);
if (conni->flags & CONN_F_SEND_AND_CLOSE)
ev_io_stop(loop, &conni->ior);
ev_io_start(loop, &conn->iow);
ev_io_start(loop, &conni->iow);
ev_timer_stop(loop, &conn->timer);
ev_timer_stop(loop, &conni->timer);
/* This is needed for a connection requested multiple times */
conn->handler = NULL;
/* This is needed for a connection requested multiple times on different path */
conni->handler = NULL;
}
static void conn_send(struct uh_connection *conn, const void *data, ssize_t len)
{
buffer_put_data(&conn->wb, data, len);
ev_io_start(conn->srv->loop, &conn->iow);
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
if (conni->flags & CONN_F_CLOSED)
return;
buffer_put_data(&conni->wb, data, len);
ev_io_start(conni->srv->loop, &conni->iow);
}
static void conn_send_file(struct uh_connection *conn, const char *path)
static void conn_send_file(struct uh_connection *conn, const char *path, off_t offset, int64_t len)
{
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
size_t min = 8192;
struct stat st;
int fd;
conn->file.fd = open(path, O_RDONLY);
if (conni->flags & CONN_F_CLOSED)
return;
fstat(conn->file.fd, &st);
if (len == 0)
return;
conn->file.size = st.st_size;
fd = open(path, O_RDONLY);
if (fd < 0) {
uh_log_err("open: %s\n", strerror(errno));
return;
}
ev_io_start(conn->srv->loop, &conn->iow);
fstat(fd, &st);
if (offset >= st.st_size) {
close(fd);
return;
}
lseek(fd, offset, SEEK_SET);
st.st_size -= offset;
if (len < 0 || len > st.st_size)
len = st.st_size;
/* If the file is not greater than 8K, then append it to the HTTP head, send once */
if (len <= min) {
buffer_put_fd(&conni->wb, fd, len, NULL);
close(fd);
} else {
conni->file.size = len;
conni->file.fd = fd;
#if UHTTPD_SSL_SUPPORT
if (conni->ssl)
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK);
#endif
}
ev_io_start(conni->srv->loop, &conni->iow);
}
static void conn_printf(struct uh_connection *conn, const char *format, ...)
{
struct buffer *wb = &conn->wb;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct buffer *wb = &conni->wb;
va_list arg;
if (conni->flags & CONN_F_CLOSED)
return;
va_start(arg, format);
buffer_put_vprintf(wb, format, arg);
va_end(arg);
ev_io_start(conn->srv->loop, &conn->iow);
ev_io_start(conni->srv->loop, &conni->iow);
}
static void conn_vprintf(struct uh_connection *conn, const char *format, va_list arg)
{
buffer_put_vprintf(&conn->wb, format, arg);
ev_io_start(conn->srv->loop, &conn->iow);
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
if (conni->flags & CONN_F_CLOSED)
return;
buffer_put_vprintf(&conni->wb, format, arg);
ev_io_start(conni->srv->loop, &conni->iow);
}
static void conn_chunk_send(struct uh_connection *conn, const void *data, ssize_t len)
@ -139,15 +189,17 @@ static void conn_send_status_line(struct uh_connection *conn, int code, const ch
conn_send(conn, extra_headers, strlen(extra_headers));
}
static void conn_send_head(struct uh_connection *conn, int code, int content_length, const char *extra_headers)
static void conn_send_head(struct uh_connection *conn, int code, int64_t content_length, const char *extra_headers)
{
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
conn_send_status_line(conn, code, extra_headers);
if (content_length < 0)
conn_printf(conn, "%s", "Transfer-Encoding: chunked\r\n");
else
conn_printf(conn, "Content-Length: %d\r\n", content_length);
conn_printf(conn, "Content-Length: %" PRIu64 "\r\n", content_length);
if (!http_should_keep_alive(&conn->parser))
if (!http_should_keep_alive(&conni->parser))
conn_printf(conn, "%s", "Connection: close\r\n");
conn_send(conn, "\r\n", 2);
@ -155,7 +207,9 @@ static void conn_send_head(struct uh_connection *conn, int code, int content_len
static void conn_error(struct uh_connection *conn, int code, const char *reason)
{
if (conn->flags & CONN_F_SEND_AND_CLOSE)
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
if (conni->flags & CONN_F_SEND_AND_CLOSE)
return;
if (!reason)
@ -163,14 +217,15 @@ static void conn_error(struct uh_connection *conn, int code, const char *reason)
conn_send_head(conn, code, strlen(reason), "Content-Type: text/plain\r\nConnection: close\r\n");
conn_send(conn, reason, strlen(reason));
conn->flags |= CONN_F_SEND_AND_CLOSE;
conni->flags |= CONN_F_SEND_AND_CLOSE;
conn_done(conn);
}
static void conn_redirect(struct uh_connection *conn, int code, const char *location, ...)
{
struct buffer *wb = &conn->wb;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct buffer *wb = &conni->wb;
va_list arg;
assert((code == HTTP_STATUS_MOVED_PERMANENTLY || code == HTTP_STATUS_FOUND) && location);
@ -191,17 +246,23 @@ static void conn_redirect(struct uh_connection *conn, int code, const char *loca
static const struct sockaddr *conn_get_addr(struct uh_connection *conn)
{
return &conn->addr.sa;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
return &conni->addr.sa;
}
static enum http_method conn_get_method(struct uh_connection *conn)
{
return conn->parser.method;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
return conni->parser.method;
}
static const char *conn_get_method_str(struct uh_connection *conn)
{
return http_method_str(conn->parser.method);
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
return http_method_str(conni->parser.method);
}
/* offset of the request field */
@ -212,11 +273,12 @@ static const char *conn_get_method_str(struct uh_connection *conn)
static struct uh_str conn_get_path(struct uh_connection *conn)
{
struct http_parser_url *u = &conn->url_parser;
struct uh_request *req = &conn->req;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct http_parser_url *u = &conni->url_parser;
struct uh_request *req = &conni->req;
struct uh_str path;
path.p = O2D(conn, u->field_data[UF_PATH].off) + req->url.offset;
path.p = O2D(conni, u->field_data[UF_PATH].off) + req->url.offset;
path.len = u->field_data[UF_PATH].len;
return path;
@ -224,14 +286,15 @@ static struct uh_str conn_get_path(struct uh_connection *conn)
static struct uh_str conn_get_query(struct uh_connection *conn)
{
struct http_parser_url *u = &conn->url_parser;
struct uh_request *req = &conn->req;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct http_parser_url *u = &conni->url_parser;
struct uh_request *req = &conni->req;
struct uh_str query = {};
if (!(u->field_set & (1 << UF_QUERY)))
return query;
query.p = O2D(conn, u->field_data[UF_QUERY].off) + req->url.offset;
query.p = O2D(conni, u->field_data[UF_QUERY].off) + req->url.offset;
query.len = u->field_data[UF_QUERY].len;
return query;
@ -239,7 +302,8 @@ static struct uh_str conn_get_query(struct uh_connection *conn)
static struct uh_str conn_get_header(struct uh_connection *conn, const char *name)
{
struct uh_request *req = &conn->req;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct uh_request *req = &conni->req;
int name_len = strlen(name);
struct uh_str value = {};
int i;
@ -251,8 +315,8 @@ static struct uh_str conn_get_header(struct uh_connection *conn, const char *nam
if (req->headers[i].field.length != name_len)
continue;
if (!strncasecmp(O2D(conn, req->headers[i].field.offset), name, name_len)) {
value.p = O2D(conn, req->headers[i].value.offset);
if (!strncasecmp(O2D(conni, req->headers[i].field.offset), name, name_len)) {
value.p = O2D(conni, req->headers[i].value.offset);
value.len = req->headers[i].value.length;
}
}
@ -260,12 +324,43 @@ static struct uh_str conn_get_header(struct uh_connection *conn, const char *nam
return value;
}
static void conn_traverse_headers(struct uh_connection *conn,
bool (*cb)(const struct uh_str name, const struct uh_str value, void *arg), void *arg)
{
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct uh_request *req = &conni->req;
struct uh_str name, value;
int i;
for (i = 0; i < UHTTPD_MAX_HEADER_NUM; i++) {
if (req->headers[i].field.offset == 0)
return;
name.p = O2D(conni, req->headers[i].field.offset);
name.len = req->headers[i].field.length;
value.p = O2D(conni, req->headers[i].value.offset);
value.len = req->headers[i].value.length;
if (!cb(name, value, arg))
return;
}
}
static uint64_t conn_get_content_length(struct uh_connection *conn)
{
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
return conni->parser.content_length;
}
static struct uh_str conn_get_body(struct uh_connection *conn)
{
struct uh_request *req = &conn->req;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct uh_request *req = &conni->req;
struct uh_str body;
body.p = O2D(conn, req->body.offset);
body.p = O2D(conni, req->body.offset);
body.len = req->body.length;
return body;
@ -273,22 +368,26 @@ static struct uh_str conn_get_body(struct uh_connection *conn)
static struct uh_str conn_extract_body(struct uh_connection *conn)
{
struct uh_request *req = &conn->req;
struct uh_str body;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
struct uh_str body = conn_get_body(conn);
body.p = O2D(conn, req->body.offset);
body.len = req->body.length;
req->body.length = 0;
buffer_discard(&conn->rb, body.len);
conni->req.body.consumed = true;
return body;
}
static void conn_close(struct uh_connection *conn)
{
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
http_parser_pause(&conni->parser, true);
conni->flags |= CONN_F_CLOSED;
}
static int on_message_begin_cb(struct http_parser *parser)
{
struct uh_connection *conn = (struct uh_connection *)parser->data;
struct uh_connection_internal *conn = (struct uh_connection_internal *)parser->data;
struct uh_request *req = &conn->req;
memset(req, 0, sizeof(struct uh_request));
@ -304,7 +403,7 @@ static int on_message_begin_cb(struct http_parser *parser)
static int on_url_cb(struct http_parser *parser, const char *at, size_t length)
{
struct uh_connection *conn = (struct uh_connection *)parser->data;
struct uh_connection_internal *conn = (struct uh_connection_internal *)parser->data;
struct uh_request *req = &conn->req;
if (req->url.offset == 0)
@ -316,7 +415,7 @@ static int on_url_cb(struct http_parser *parser, const char *at, size_t length)
static int on_header_field_cb(struct http_parser *parser, const char *at, size_t length)
{
struct uh_connection *conn = (struct uh_connection *)parser->data;
struct uh_connection_internal *conn = (struct uh_connection_internal *)parser->data;
struct uh_request *req = &conn->req;
if (req->last_was_header_value) {
@ -338,7 +437,7 @@ static int on_header_field_cb(struct http_parser *parser, const char *at, size_t
static int on_header_value_cb(struct http_parser *parser, const char *at, size_t length)
{
struct uh_connection *conn = (struct uh_connection *)parser->data;
struct uh_connection_internal *conn = (struct uh_connection_internal *)parser->data;
struct uh_request *req = &conn->req;
if (!req->last_was_header_value) {
@ -353,8 +452,8 @@ static int on_header_value_cb(struct http_parser *parser, const char *at, size_t
static int on_headers_complete(struct http_parser *parser)
{
struct uh_connection *conn = (struct uh_connection *)parser->data;
struct uh_server *srv = conn->srv;
struct uh_connection_internal *conn = (struct uh_connection_internal *)parser->data;
struct uh_server_internal *srv = conn->srv;
struct uh_request *req = &conn->req;
struct uh_path_handler *h = srv->handlers;
struct uh_plugin *p = srv->plugins;
@ -362,7 +461,7 @@ static int on_headers_complete(struct http_parser *parser)
http_parser_parse_url(O2D(conn, req->url.offset), req->url.length, false, &conn->url_parser);
path = conn->get_path(conn);
path = conn->com.get_path(&conn->com);
while (h) {
if (strlen(h->path) == path.len && !strncmp(path.p, h->path, path.len)) {
@ -385,11 +484,11 @@ done:
conn->handler = srv->default_handler;
if (!conn->handler) {
conn_error(conn, HTTP_STATUS_NOT_FOUND, NULL);
conn_error(&conn->com, HTTP_STATUS_NOT_FOUND, NULL);
return -1;
}
conn->handler(conn, UH_EV_HEAD_COMPLETE);
conn->handler(&conn->com, UH_EV_HEAD_COMPLETE);
if (conn->flags & CONN_F_SEND_AND_CLOSE)
return -1;
@ -399,29 +498,38 @@ done:
static int on_body_cb(struct http_parser *parser, const char *at, size_t length)
{
struct uh_connection *conn = (struct uh_connection *)parser->data;
struct uh_connection_internal *conn = (struct uh_connection_internal *)parser->data;
struct uh_request *req = &conn->req;
if (req->body.offset == 0)
req->body.offset = ROF(conn, at);
req->body.length += length;
conn->handler(conn, UH_EV_BODY);
conn->handler(&conn->com, UH_EV_BODY);
if (conn->flags & CONN_F_SEND_AND_CLOSE)
return -1;
if (req->body.consumed) {
req->body.consumed = false;
buffer_discard(&conn->rb, req->body.length);
req->length -= req->body.length;
req->body.length = 0;
}
return 0;
}
static int on_message_complete_cb(struct http_parser *parser)
{
struct uh_connection *conn = (struct uh_connection *)parser->data;
struct uh_server *srv = conn->srv;
struct uh_connection_internal *conn = (struct uh_connection_internal *)parser->data;
struct uh_server_internal *srv = conn->srv;
ev_timer_stop(srv->loop, &conn->timer);
conn->handler(conn, UH_EV_COMPLETE);
conn->handler(&conn->com, UH_EV_COMPLETE);
http_parser_pause(parser, true);
return 0;
}
@ -436,7 +544,7 @@ static struct http_parser_settings settings = {
.on_message_complete = on_message_complete_cb
};
void conn_free(struct uh_connection *conn)
void conn_free(struct uh_connection_internal *conn)
{
struct ev_loop *loop = conn->srv->loop;
char addr_str[INET6_ADDRSTRLEN];
@ -464,6 +572,9 @@ void conn_free(struct uh_connection *conn)
uh_ssl_free(conn->ssl);
#endif
if (conn->srv->conn_closed_cb)
conn->srv->conn_closed_cb(&conn->com);
if (conn->sock > 0)
close(conn->sock);
@ -475,6 +586,47 @@ void conn_free(struct uh_connection *conn)
free(conn);
}
static void conn_http_parse(struct uh_connection_internal *conn)
{
struct http_parser *parser = &conn->parser;
struct uh_request *req = &conn->req;
struct buffer *rb = &conn->rb;
uint8_t *data = buffer_data(rb) + req->length;
size_t length = buffer_length(rb) - req->length;
size_t nparsed;
if (parser->http_errno == HPE_PAUSED)
return;
nparsed = http_parser_execute(parser, &settings, (const char *)data, length);
if (conn->flags & CONN_F_CLOSED) {
conn_free(conn);
return;
}
switch (parser->http_errno) {
case HPE_PAUSED:
case HPE_OK:
if (parser->upgrade) {
conn_error(&conn->com, HTTP_STATUS_NOT_IMPLEMENTED, NULL);
return;
}
req->length += nparsed;
/* paused in on_message_complete */
if (parser->http_errno == HPE_PAUSED) {
buffer_pull(rb, NULL, req->length);
req->length = 0;
}
return;
default:
conn_error(&conn->com, HTTP_STATUS_BAD_REQUEST, http_errno_description(parser->http_errno));
return;
}
}
#if UHTTPD_SSL_SUPPORT
static int conn_ssl_write(int fd, void *buf, size_t count, void *ssl)
{
@ -491,7 +643,7 @@ static int conn_ssl_write(int fd, void *buf, size_t count, void *ssl)
static void conn_write_cb(struct ev_loop *loop, struct ev_io *w, int revents)
{
struct uh_connection *conn = container_of(w, struct uh_connection, iow);
struct uh_connection_internal *conn = container_of(w, struct uh_connection_internal, iow);
int ret;
#if UHTTPD_SSL_SUPPORT
@ -509,28 +661,47 @@ static void conn_write_cb(struct ev_loop *loop, struct ev_io *w, int revents)
if (buffer_length(&conn->wb) == 0) {
if (conn->file.fd > 0) {
ret = sendfile(w->fd, conn->file.fd, NULL, conn->file.size);
if (ret < 0) {
if (errno != EAGAIN) {
uh_log_err("write error: %s\n", strerror(errno));
conn_free(conn);
#if UHTTPD_SSL_SUPPORT
if (conn->ssl) {
bool eof;
if (buffer_put_fd(&conn->wb, conn->file.fd, 8192, &eof) < 0 || eof) {
close(conn->file.fd);
conn->file.fd = -1;
}
return;
}
} else {
#endif
ret = sendfile(w->fd, conn->file.fd, NULL, conn->file.size);
if (ret < 0) {
if (errno != EAGAIN) {
uh_log_err("write error: %s\n", strerror(errno));
conn_free(conn);
}
return;
}
if (ret < conn->file.size) {
conn->file.size -= ret;
return;
}
if (ret < conn->file.size) {
conn->file.size -= ret;
return;
}
close(conn->file.fd);
conn->file.fd = -1;
close(conn->file.fd);
conn->file.fd = -1;
#if UHTTPD_SSL_SUPPORT
}
#endif
}
if (conn->flags & CONN_F_SEND_AND_CLOSE)
if (conn->flags & CONN_F_SEND_AND_CLOSE) {
conn_free(conn);
else
} else {
ev_io_stop(loop, w);
http_parser_pause(&conn->parser, false);
if (buffer_length(&conn->rb) > 0)
conn_http_parse(conn);
}
}
}
@ -549,11 +720,10 @@ static int conn_ssl_read(int fd, void *buf, size_t count, void *ssl)
static void conn_read_cb(struct ev_loop *loop, struct ev_io *w, int revents)
{
struct uh_connection *conn = container_of(w, struct uh_connection, ior);
struct http_parser *parser = &conn->parser;
struct uh_connection_internal *conn = container_of(w, struct uh_connection_internal, ior);
struct buffer *rb = &conn->rb;
int ret, nread, length, nparsed;
bool eof;
int ret;
if (conn->flags & CONN_F_SEND_AND_CLOSE) {
ev_io_stop(loop, w);
@ -575,8 +745,6 @@ static void conn_read_cb(struct ev_loop *loop, struct ev_io *w, int revents)
conn->activity = ev_now(loop);
length = buffer_length(rb);
#if UHTTPD_SSL_SUPPORT
if (conn->ssl)
ret = buffer_put_fd_ex(rb, w->fd, -1, &eof, conn_ssl_read, conn->ssl);
@ -585,28 +753,24 @@ static void conn_read_cb(struct ev_loop *loop, struct ev_io *w, int revents)
ret = buffer_put_fd(rb, w->fd, -1, &eof);
if (ret < 0) {
conn_error(conn, HTTP_STATUS_INTERNAL_SERVER_ERROR, NULL);
uh_log_err("read error: %s\n", strerror(errno));
return;
goto done;
}
if (eof) {
conn_free(conn);
return;
}
if (eof)
goto done;
nread = buffer_length(rb) - length;
conn_http_parse(conn);
nparsed = http_parser_execute(parser, &settings, (const char *)rb->data + length, nread);
if (parser->upgrade)
conn_error(conn, HTTP_STATUS_NOT_IMPLEMENTED, NULL);
else if (nparsed != nread)
conn_error(conn, HTTP_STATUS_BAD_REQUEST, http_errno_description(parser->http_errno));
return;
done:
conn_free(conn);
}
static void keepalive_cb(struct ev_loop *loop, struct ev_timer *w, int revents)
{
struct uh_connection *conn = container_of(w, struct uh_connection, timer);
struct uh_connection_internal *conn = container_of(w, struct uh_connection_internal, timer);
ev_tstamp after = conn->activity + UHTTPD_CONNECTION_TIMEOUT - ev_now(loop);
if (conn->flags & CONN_F_SEND_AND_CLOSE) {
@ -620,14 +784,63 @@ static void keepalive_cb(struct ev_loop *loop, struct ev_timer *w, int revents)
return;
}
conn_error(conn, HTTP_STATUS_REQUEST_TIMEOUT, NULL);
conn_error(&conn->com, HTTP_STATUS_REQUEST_TIMEOUT, NULL);
}
struct uh_connection *uh_new_connection(struct uh_server *srv, int sock, struct sockaddr *addr)
static struct uh_server *conn_get_server(struct uh_connection *conn)
{
struct uh_connection *conn;
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
conn = calloc(1, sizeof(struct uh_connection));
return &conni->srv->com;
}
static struct ev_loop *conn_get_loop(struct uh_connection *conn)
{
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
return conni->srv->loop;
}
static void conn_init_cb(struct uh_connection *conn)
{
conn->get_server = conn_get_server;
conn->get_loop = conn_get_loop;
conn->done = conn_done;
conn->send = conn_send;
conn->send_file = conn_send_file;
conn->printf = conn_printf;
conn->vprintf = conn_vprintf;
conn->send_status_line = conn_send_status_line;
conn->send_head = conn_send_head;
conn->error = conn_error;
conn->redirect = conn_redirect;
conn->serve_file = serve_file;
conn->chunk_send = conn_chunk_send;
conn->chunk_printf = conn_chunk_printf;
conn->chunk_vprintf = conn_chunk_vprintf;
conn->chunk_end = conn_chunk_end;
conn->get_addr = conn_get_addr;
conn->get_method = conn_get_method;
conn->get_method_str = conn_get_method_str;
conn->get_path = conn_get_path;
conn->get_query = conn_get_query;
conn->get_header = conn_get_header;
conn->traverse_headers = conn_traverse_headers;
conn->get_content_length = conn_get_content_length;
conn->get_body = conn_get_body;
conn->extract_body = conn_extract_body;
conn->close = conn_close;
}
struct uh_connection_internal *uh_new_connection(struct uh_listener *l, int sock, struct sockaddr *addr)
{
struct uh_server_internal *srv = l->srv;
struct uh_connection_internal *conn;
conn = calloc(1, sizeof(struct uh_connection_internal));
if (!conn) {
uh_log_err("malloc: %s\n", strerror(errno));
return NULL;
@ -651,7 +864,7 @@ struct uh_connection *uh_new_connection(struct uh_server *srv, int sock, struct
ev_timer_start(srv->loop, &conn->timer);
#if UHTTPD_SSL_SUPPORT
if (srv->ssl_ctx)
if (l->ssl)
conn->ssl = uh_ssl_new(srv->ssl_ctx, sock);
#endif
@ -659,30 +872,7 @@ struct uh_connection *uh_new_connection(struct uh_server *srv, int sock, struct
conn->parser.data = conn;
conn->done = conn_done;
conn->send = conn_send;
conn->send_file = conn_send_file;
conn->printf = conn_printf;
conn->vprintf = conn_vprintf;
conn->send_status_line = conn_send_status_line;
conn->send_head = conn_send_head;
conn->error = conn_error;
conn->redirect = conn_redirect;
conn->serve_file = serve_file;
conn->chunk_send = conn_chunk_send;
conn->chunk_printf = conn_chunk_printf;
conn->chunk_vprintf = conn_chunk_vprintf;
conn->chunk_end = conn_chunk_end;
conn->get_addr = conn_get_addr;
conn->get_method = conn_get_method;
conn->get_method_str = conn_get_method_str;
conn->get_path = conn_get_path;
conn->get_query = conn_get_query;
conn->get_header = conn_get_header;
conn->get_body = conn_get_body;
conn->extract_body = conn_extract_body;
conn_init_cb(&conn->com);
return conn;
}

55
src/connection.h
View File

@ -25,28 +25,22 @@
#ifndef LIBUHTTPD_CONNECTION_H
#define LIBUHTTPD_CONNECTION_H
#include <ev.h>
#include <stdarg.h>
#include <arpa/inet.h>
#include "http_parser.h"
#include "buffer.h"
#include "config.h"
#include "uhttpd.h"
#define UHTTPD_CONNECTION_TIMEOUT 30.0
#define UHTTPD_MAX_HEADER_NUM 50
#define CONN_F_SEND_AND_CLOSE (1 << 0) /* Push remaining data and close */
#define CONN_F_SSL_HANDSHAKE_DONE (1 << 1) /* SSL hanshake has completed */
#define CONN_F_CLOSED (1 << 1) /* closed */
#define CONN_F_SSL_HANDSHAKE_DONE (1 << 2) /* SSL hanshake has completed */
struct uh_server;
struct uh_str {
const char *p;
size_t len;
};
struct uh_server_internal;
struct uh_request {
size_t length; /* The total length of the request which still remain in buffer */
struct {
ssize_t offset;
size_t length;
@ -66,12 +60,14 @@ struct uh_request {
} headers[UHTTPD_MAX_HEADER_NUM];
struct {
bool consumed; /* Indicates whether the extract_body is called */
ssize_t offset;
size_t length;
} body;
};
struct uh_connection {
struct uh_connection_internal {
struct uh_connection com;
int sock;
#if UHTTPD_SSL_SUPPORT
void *ssl;
@ -79,7 +75,7 @@ struct uh_connection {
uint8_t flags;
struct {
int fd;
int size;
uint64_t size;
} file;
struct ev_io ior;
struct ev_io iow;
@ -88,7 +84,7 @@ struct uh_connection {
ev_tstamp activity;
struct ev_timer timer;
struct uh_request req;
struct uh_server *srv;
struct uh_server_internal *srv;
union {
struct sockaddr sa;
struct sockaddr_in sin;
@ -96,34 +92,13 @@ struct uh_connection {
} addr; /* peer address */
struct http_parser parser;
struct http_parser_url url_parser;
struct uh_connection *prev;
struct uh_connection *next;
struct uh_connection_internal *prev;
struct uh_connection_internal *next;
void (*handler)(struct uh_connection *conn, int event);
void (*done)(struct uh_connection *conn); /* Must be called at last, if not call 'error', 'redirect' and 'serve_file' */
void (*send)(struct uh_connection *conn, const void *data, ssize_t len);
void (*send_file)(struct uh_connection *conn, const char *path);
void (*printf)(struct uh_connection *conn, const char *format, ...);
void (*vprintf)(struct uh_connection *conn, const char *format, va_list arg);
void (*send_status_line)(struct uh_connection *conn, int code, const char *extra_headers);
void (*send_head)(struct uh_connection *conn, int code, int content_length, const char *extra_headers);
void (*error)(struct uh_connection *conn, int code, const char *reason);
void (*redirect)(struct uh_connection *conn, int code, const char *location, ...);
void (*serve_file)(struct uh_connection *conn, const char *docroot, const char *index_page);
void (*chunk_send)(struct uh_connection *conn, const void *data, ssize_t len);
void (*chunk_printf)(struct uh_connection *conn, const char *format, ...);
void (*chunk_vprintf)(struct uh_connection *conn, const char *format, va_list arg);
void (*chunk_end)(struct uh_connection *conn);
const struct sockaddr *(*get_addr)(struct uh_connection *conn); /* peer address */
enum http_method (*get_method)(struct uh_connection *conn);
const char *(*get_method_str)(struct uh_connection *conn);
struct uh_str (*get_path)(struct uh_connection *conn);
struct uh_str (*get_query)(struct uh_connection *conn);
struct uh_str (*get_header)(struct uh_connection *conn, const char *name);
struct uh_str (*get_body)(struct uh_connection *conn);
/* The remain body data will be discurd after this function called */
struct uh_str (*extract_body)(struct uh_connection *conn);
};
struct uh_connection *uh_new_connection(struct uh_server *srv, int sock, struct sockaddr *addr);
struct uh_connection_internal *uh_new_connection(struct uh_listener *l, int sock, struct sockaddr *addr);
void conn_free(struct uh_connection_internal *conn);
#endif

147
src/file.c
View File

@ -34,15 +34,17 @@
#include <time.h>
#include <fcntl.h>
#include <inttypes.h>
#include <ctype.h>
#include "connection.h"
#include "uhttpd_internal.h"
#include "mimetypes.h"
#include "log.h"
#include "utils.h"
#include "file.h"
static const char *file_mktag(struct stat *s, char *buf, int len)
{
snprintf(buf, len, "\"%" PRIx64 "-%" PRIx64 "-%" PRIx64 "\"",
(uint64_t)s->st_ino, s->st_size, (uint64_t)s->st_mtime);
(uint64_t)s->st_ino, (uint64_t)s->st_size, (uint64_t)s->st_mtime);
return buf;
}
@ -152,12 +154,115 @@ static void file_if_gzip(struct uh_connection *conn, const char *path, const cha
conn->printf(conn, "Content-Encoding: gzip\r\n");
}
void serve_file(struct uh_connection *conn, const char *docroot, const char *index_page)
static bool file_range(struct uh_connection *conn, uint64_t size, uint64_t *start, uint64_t *end, bool *ranged)
{
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
const struct uh_str hdr = conn->get_header(conn, "Range");
int content_length;
const char *reason;
const char *p, *e;
char buf[32];
int i;
*start = 0;
*end = size - 1;
if (!hdr.p) {
*ranged = false;
return true;
}
if (hdr.len < 8)
goto err;
p = hdr.p;
e = hdr.p + hdr.len;
if (strncmp(p, "bytes=", 6))
goto err;
p += 6;
i = 0;
while (p < e) {
if (i >= sizeof(buf) - 1)
goto err;
if (isdigit(*p)) {
buf[i++] = *p++;
continue;
}
if (*p != '-')
goto err;
p++;
buf[i] = '\0';
break;
}
*start = strtoull(buf, NULL, 0);
i = 0;
while (p < e) {
if (i >= (sizeof(buf) - 1) || !isdigit(*p))
goto err;
buf[i++] = *p++;
}
buf[i] = '\0';
*end = strtoull(buf, NULL, 0);
if (*start >= size)
goto err;
if (*end == 0)
*end = size - 1;
if (*end < *start)
goto err;
if (*end > size - 1)
*end = size - 1;
*ranged = true;
return true;
err:
reason = http_status_str(HTTP_STATUS_RANGE_NOT_SATISFIABLE);
content_length = strlen(reason);
conn->send_status_line(conn, HTTP_STATUS_RANGE_NOT_SATISFIABLE, "Content-Type: text/plain\r\nConnection: close\r\n");
conn->printf(conn, "Content-Length: %d\r\n", content_length);
conn->printf(conn, "Content-Range: bytes */%" PRIu64 "\r\n", size);
conn->send(conn, "\r\n", 2);
conn->send(conn, reason, content_length);
conni->flags |= CONN_F_SEND_AND_CLOSE;
conn->done(conn);
return false;
}
void serve_file(struct uh_connection *conn)
{
struct uh_connection_internal *conni = (struct uh_connection_internal *)conn;
const struct uh_str path = conn->get_path(conn);
static char fullpath[512];
struct uh_server_internal *srv = conni->srv;
const char *docroot = srv->docroot;
const char *index_page = srv->index_page;
static char fullpath[PATH_MAX];
uint64_t start, end;
int docroot_len;
const char *mime;
struct stat st;
bool ranged;
if (!docroot || !docroot[0])
docroot = ".";
@ -165,13 +270,16 @@ void serve_file(struct uh_connection *conn, const char *docroot, const char *ind
if (!index_page || !index_page[0])
index_page = "index.html";
strcpy(fullpath, docroot);
docroot_len = strlen(docroot);
memcpy(fullpath, docroot, docroot_len);
if (!strncmp(path.p, "/", path.len)) {
strcat(fullpath, "/");
strcat(fullpath, index_page);
} else {
strncat(fullpath, path.p, path.len);
fullpath[docroot_len] = '/';
strcpy(fullpath + docroot_len + 1, index_page);
} else if (urldecode(fullpath + docroot_len, PATH_MAX - docroot_len, path.p, path.len) < 0) {
conn->error(conn, HTTP_STATUS_NOT_FOUND, NULL);
return;
}
if (stat(fullpath, &st) < 0) {
@ -206,6 +314,9 @@ void serve_file(struct uh_connection *conn, const char *docroot, const char *ind
return;
}
if (!file_range(conn, st.st_size, &start, &end, &ranged))
return;
if (!file_if_modified_since(conn, &st) ||
!file_if_range(conn, &st) ||
!file_if_unmodified_since(conn, &st)) {
@ -213,21 +324,29 @@ void serve_file(struct uh_connection *conn, const char *docroot, const char *ind
return;
}
conn->send_status_line(conn, HTTP_STATUS_OK, NULL);
if (ranged)
conn->send_status_line(conn, HTTP_STATUS_PARTIAL_CONTENT, NULL);
else
conn->send_status_line(conn, HTTP_STATUS_OK, NULL);
file_response_ok_hdrs(conn, &st);
mime = file_mime_lookup(fullpath);
conn->printf(conn, "Content-Type: %s\r\n", mime);
conn->printf(conn, "Content-Length: %" PRIu64 "\r\n", st.st_size);
conn->printf(conn, "Content-Length: %" PRIu64 "\r\n", end - start + 1);
file_if_gzip(conn, fullpath, mime);
if (ranged)
conn->printf(conn, "Content-Range: bytes %" PRIu64 "-%" PRIu64 "/%" PRIu64 "\r\n", start, end, (uint64_t)st.st_size);
else
file_if_gzip(conn, fullpath, mime);
conn->printf(conn, "\r\n");
if (conn->get_method(conn) == HTTP_HEAD)
return;
conn->send_file(conn, fullpath);
conn->send_file(conn, fullpath, start, end - start + 1);
conn->done(conn);
}

2
src/file.h
View File

@ -27,6 +27,6 @@
#include "connection.h"
void serve_file(struct uh_connection *conn, const char *docroot, const char *index_page);
void serve_file(struct uh_connection *conn);
#endif

3
src/log.h
View File

@ -40,6 +40,7 @@ void uh_log_close();
#define uh_log_info(fmt...) uh_log(LOG_INFO, fmt)
#define uh_log_err(fmt...) uh_log(LOG_ERR, fmt)
void __uh_log(const char *filename, int line, int priority, const char *fmt, ...);
void __uh_log(const char *filename, int line, int priority, const char *fmt, ...)
__attribute__((format(printf, 4, 5)));
#endif

1
src/ssl.c
View File

@ -26,6 +26,7 @@
#include <errno.h>
#include "ssl.h"
#include "log.h"
#if UHTTPD_SSL_SUPPORT

1
src/ssl.h
View File

@ -26,7 +26,6 @@
#define LIBUHTTPD_SSL_H
#include "config.h"
#include "log.h"
#if UHTTPD_SSL_SUPPORT

350
src/uhttpd.c
View File

@ -27,34 +27,34 @@
#include <unistd.h>
#include <errno.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#ifdef HAVE_DLOPEN
#include <dlfcn.h>
#endif
#include "uhttpd.h"
#include "uhttpd_internal.h"
#include "connection.h"
#include "utils.h"
#include "ssl.h"
#include "log.h"
void conn_free(struct uh_connection *conn);
static void uh_server_free(struct uh_server *srv)
{
struct uh_connection *conn = srv->conns;
struct uh_path_handler *h = srv->handlers;
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
struct uh_connection_internal *conn = srvi->conns;
struct uh_path_handler *h = srvi->handlers;
struct uh_listener *l = srvi->listeners;
#ifdef HAVE_DLOPEN
struct uh_plugin *p = srv->plugins;
struct uh_plugin *p = srvi->plugins;
#endif
ev_io_stop(srv->loop, &srv->ior);
if (srvi->docroot)
free(srvi->docroot);
if (srv->sock > 0)
close(srv->sock);
if (srvi->index_page)
free(srvi->index_page);
while (conn) {
struct uh_connection *next = conn->next;
struct uh_connection_internal *next = conn->next;
conn_free(conn);
conn = next;
}
@ -65,6 +65,18 @@ static void uh_server_free(struct uh_server *srv)
free(temp);
}
while (l) {
struct uh_listener *temp = l;
ev_io_stop(srvi->loop, &l->ior);
if (l->sock > 0)
close(l->sock);
l = l->next;
free(temp);
}
#ifdef HAVE_DLOPEN
while (p) {
struct uh_plugin *temp = p;
@ -75,14 +87,15 @@ static void uh_server_free(struct uh_server *srv)
#endif
#if UHTTPD_SSL_SUPPORT
uh_ssl_ctx_free(srv->ssl_ctx);
uh_ssl_ctx_free(srvi->ssl_ctx);
#endif
}
static void uh_accept_cb(struct ev_loop *loop, struct ev_io *w, int revents)
{
struct uh_server *srv = container_of(w, struct uh_server, ior);
struct uh_connection *conn;
struct uh_listener *l = container_of(w, struct uh_listener, ior);
struct uh_server_internal *srv = l->srv;
struct uh_connection_internal *conn;
union {
struct sockaddr sa;
struct sockaddr_in sin;
@ -93,9 +106,10 @@ static void uh_accept_cb(struct ev_loop *loop, struct ev_io *w, int revents)
int port;
int sock;
sock = accept4(srv->sock, (struct sockaddr *)&addr, &addr_len, SOCK_NONBLOCK | SOCK_CLOEXEC);
sock = accept4(l->sock, (struct sockaddr *)&addr, &addr_len, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (sock < 0) {
uh_log_err("accept: %s\n", strerror(errno));
if (errno != EAGAIN)
uh_log_err("accept: %s\n", strerror(errno));
return;
}
@ -104,7 +118,21 @@ static void uh_accept_cb(struct ev_loop *loop, struct ev_io *w, int revents)
uh_log_debug("New Connection from: %s %d\n", addr_str, port);
}
conn = uh_new_connection(srv, sock, &addr.sa);
if (l->ssl) {
#if UHTTPD_SSL_SUPPORT
if (!srv->ssl_ctx) {
uh_log_err("SSL not initialized\n");
close(sock);
return;
}
#else
close(sock);
uh_log_err("SSL not enabled when build\n");
return;
#endif
}
conn = uh_new_connection(l, sock, &addr.sa);
if (!conn)
return;
@ -118,20 +146,17 @@ static void uh_accept_cb(struct ev_loop *loop, struct ev_io *w, int revents)
srv->conns = conn;
}
struct uh_server *uh_server_new(struct ev_loop *loop, const char *host, int port)
struct uh_server *uh_server_new(struct ev_loop *loop)
{
struct uh_server *srv;
srv = malloc(sizeof(struct uh_server));
srv = malloc(sizeof(struct uh_server_internal));
if (!srv) {
uh_log_err("malloc: %s\n", strerror(errno));
return NULL;
}
if (uh_server_init(srv, loop, host, port) < 0) {
free(srv);
return NULL;
}
uh_server_init(srv, loop);
return srv;
}
@ -139,14 +164,16 @@ struct uh_server *uh_server_new(struct ev_loop *loop, const char *host, int port
#if UHTTPD_SSL_SUPPORT
static int uh_server_ssl_init(struct uh_server *srv, const char *cert, const char *key)
{
srv->ssl_ctx = uh_ssl_ctx_init(cert, key);
return srv->ssl_ctx ? 0 : -1;
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
srvi->ssl_ctx = uh_ssl_ctx_init(cert, key);
return srvi->ssl_ctx ? 0 : -1;
}
#endif
static int uh_load_plugin(struct uh_server *srv, const char *path)
{
#ifdef HAVE_DLOPEN
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
struct uh_plugin_handler *h;
struct uh_plugin *p;
void *dlh;
@ -179,13 +206,13 @@ static int uh_load_plugin(struct uh_server *srv, const char *path)
p->h = h;
p->dlh = dlh;
if (!srv->plugins) {
srv->plugins = p;
if (!srvi->plugins) {
srvi->plugins = p;
return 0;
}
p->next = srv->plugins;
srv->plugins = p;
p->next = srvi->plugins;
srvi->plugins = p;
return 0;
#else
@ -196,6 +223,7 @@ static int uh_load_plugin(struct uh_server *srv, const char *path)
static int uh_add_path_handler(struct uh_server *srv, const char *path, uh_path_handler_prototype handler)
{
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
struct uh_path_handler *h;
h = calloc(1, sizeof(struct uh_path_handler) + strlen(path) + 1);
@ -207,111 +235,229 @@ static int uh_add_path_handler(struct uh_server *srv, const char *path, uh_path_
h->handler = handler;
strcpy(h->path, path);
if (!srv->handlers) {
srv->handlers = h;
if (!srvi->handlers) {
srvi->handlers = h;
return 0;
}
h->next = srv->handlers;
srv->handlers = h;
h->next = srvi->handlers;
srvi->handlers = h;
return 0;
}
int uh_server_init(struct uh_server *srv, struct ev_loop *loop, const char *host, int port)
static void uh_set_conn_abort_cb(struct uh_server *srv, uh_con_closed_cb_prototype cb)
{
union {
struct sockaddr sa;
struct sockaddr_in sin;
struct sockaddr_in6 sin6;
} addr;
char addr_str[INET6_ADDRSTRLEN];
socklen_t addrlen;
int sock = -1;
int opt = 1;
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
if (!host || *host == '\0') {
addr.sin.sin_family = AF_INET;
addr.sin.sin_addr.s_addr = htonl(INADDR_ANY);
}
srvi->conn_closed_cb = cb;
}
if (inet_pton(AF_INET, host, &addr.sin.sin_addr) == 1) {
addr.sa.sa_family = AF_INET;
} else if (inet_pton(AF_INET6, host, &addr.sin6.sin6_addr) == 1) {
addr.sa.sa_family = AF_INET6;
} else {
static struct addrinfo hints = {
.ai_family = AF_UNSPEC,
.ai_socktype = SOCK_STREAM,
.ai_flags = AI_PASSIVE
};
struct addrinfo *ais;
int status;
static void uh_set_default_handler(struct uh_server *srv, uh_path_handler_prototype handler)
{
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
status = getaddrinfo(host, NULL, &hints, &ais);
if (status != 0) {
uh_log_err("getaddrinfo(): %s\n", gai_strerror(status));
return -1;
}
srvi->default_handler = handler;
}
memcpy(&addr, ais->ai_addr, ais->ai_addrlen);
freeaddrinfo(ais);
}
static int uh_set_docroot(struct uh_server *srv, const char *path)
{
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
if (addr.sa.sa_family == AF_INET) {
addr.sin.sin_port = ntohs(port);
addrlen = sizeof(addr.sin);
inet_ntop(AF_INET, &addr.sin.sin_addr, addr_str, sizeof(addr_str));
} else {
addr.sin6.sin6_port = ntohs(port);
addrlen = sizeof(addr.sin6);
inet_ntop(AF_INET6, &addr.sin6.sin6_addr, addr_str, sizeof(addr_str));
}
if (srvi->docroot)
free(srvi->docroot);
sock = socket(addr.sa.sa_family, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (sock < 0) {
uh_log_err("socket: %s\n", strerror(errno));
srvi->docroot = strdup(path);
if (!srvi->docroot) {
uh_log_err("strdup: %s\n", strerror(errno));
return -1;
}
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int)) < 0) {
uh_log_err("setsockopt: %s\n", strerror(errno));
goto err;
return 0;
}
static int uh_set_index_page(struct uh_server *srv, const char *name)
{
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
if (srvi->index_page)
free(srvi->index_page);
srvi->index_page = strdup(name);
if (!srvi->index_page) {
uh_log_err("strdup: %s\n", strerror(errno));
return -1;
}
if (bind(sock, &addr.sa, addrlen) < 0) {
close(sock);
uh_log_err("bind: %s\n", strerror(errno));
goto err;
return 0;
}
static struct ev_loop *uh_get_loop(struct uh_server *srv)
{
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
return srvi->loop;
}
static int parse_address(const char *addr, char **host, char **port)
{
static char buf[256];
char *s;
int l;
strcpy(buf, addr);
*host = NULL;
*port = buf;
s = strrchr(buf, ':');
if (!s)
return -1;
*host = buf;
*port = s + 1;
*s = 0;
if (*host && **host == '[') {
l = strlen(*host);
if (l >= 2) {
(*host)[l - 1] = 0;
(*host)++;
}
}
listen(sock, SOMAXCONN);
if ((*host)[0] == '\0')
*host = "0";
if (uh_log_get_threshold() == LOG_DEBUG) {
saddr2str(&addr.sa, addr_str, sizeof(addr_str), &port);
uh_log_debug("Listen on: %s %d\n", addr_str, port);
return 0;
}
static int uh_server_listen(struct uh_server *srv, const char *addr, bool ssl)
{
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
struct uh_listener *l;
char *host, *port;
struct addrinfo *addrs = NULL, *p = NULL;
static struct addrinfo hints = {
.ai_family = AF_UNSPEC,
.ai_socktype = SOCK_STREAM,
.ai_flags = AI_PASSIVE,
};
char addr_str[INET6_ADDRSTRLEN];
int bound = 0;
int on = 1;
int status;
int sock;
if (parse_address(addr, &host, &port) < 0) {
uh_log_err("invalid address\n");
return -1;
}
memset(srv, 0, sizeof(struct uh_server));
status = getaddrinfo(host, port, &hints, &addrs);
if (status != 0) {
uh_log_err("getaddrinfo(): %s\n", gai_strerror(status));
return -1;
}
srv->loop = loop ? loop : EV_DEFAULT;
srv->sock = sock;
/* try to bind a new socket to each found address */
for (p = addrs; p; p = p->ai_next) {
sock = socket(p->ai_family, p->ai_socktype | SOCK_NONBLOCK | SOCK_CLOEXEC, p->ai_protocol);
if (sock < 0) {
uh_log_err("socket: %s\n", strerror(errno));
continue;
}
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int)) < 0) {
uh_log_err("setsockopt: %s\n", strerror(errno));
goto err;
}
/* required to get parallel v4 + v6 working */
if (p->ai_family == AF_INET6 && setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(int)) < 0) {
uh_log_err("setsockopt: %s\n", strerror(errno));
goto err;
}
setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(int));
if (bind(sock, p->ai_addr, p->ai_addrlen) < 0) {
uh_log_err("bind: %s\n", strerror(errno));
goto err;
}
if (listen(sock, SOMAXCONN) < 0) {
uh_log_err("bind: %s\n", strerror(errno));
goto err;
}
l = calloc(1, sizeof(struct uh_listener));
if (!l) {
uh_log_err("calloc: %s\n", strerror(errno));
goto err;
}
l->sock = sock;
l->ssl = ssl;
l->srv = srvi;
ev_io_init(&l->ior, uh_accept_cb, sock, EV_READ);
ev_io_start(srvi->loop, &l->ior);
if (!srvi->listeners) {
srvi->listeners = l;
} else {
l->next = srvi->listeners;
srvi->listeners = l;
}
if (p->ai_family == AF_INET) {
struct sockaddr_in *ina = (struct sockaddr_in *)p->ai_addr;
inet_ntop(p->ai_family, &ina->sin_addr, addr_str, sizeof(addr_str));
uh_log_debug("Listen on: %s:%d with ssl %s\n", addr_str, ntohs(ina->sin_port), ssl ? "on" : "off");
} else {
struct sockaddr_in6 *in6a = (struct sockaddr_in6 *)p->ai_addr;
inet_ntop(p->ai_family, &in6a->sin6_addr, addr_str, sizeof(addr_str));
uh_log_debug("Listen on: [%s]:%d with ssl %s\n", addr_str, ntohs(in6a->sin6_port), ssl ? "on" : "off");
}
bound++;
continue;
err:
if (sock > -1)
close(sock);
}
freeaddrinfo(addrs);
return bound;
}
void uh_server_init(struct uh_server *srv, struct ev_loop *loop)
{
struct uh_server_internal *srvi = (struct uh_server_internal *)srv;
memset(srvi, 0, sizeof(struct uh_server_internal));
srvi->loop = loop ? loop : EV_DEFAULT;
srv->get_loop = uh_get_loop;
srv->free = uh_server_free;
srv->listen = uh_server_listen;
#if UHTTPD_SSL_SUPPORT
srv->ssl_init = uh_server_ssl_init;
#endif
srv->load_plugin = uh_load_plugin;
srv->set_conn_closed_cb = uh_set_conn_abort_cb;
srv->set_default_handler = uh_set_default_handler;
srv->add_path_handler = uh_add_path_handler;
ev_io_init(&srv->ior, uh_accept_cb, sock, EV_READ);
ev_io_start(srv->loop, &srv->ior);
return 0;
err:
close(sock);
return -1;
srv->set_docroot = uh_set_docroot;
srv->set_index_page = uh_set_index_page;
}

109
src/uhttpd.h
View File

@ -25,14 +25,91 @@
#ifndef LIBUHTTPD_UHTTPD_H
#define LIBUHTTPD_UHTTPD_H
#include <sys/types.h>
#include <stdbool.h>
#include <stdarg.h>
#include <ev.h>
#include "connection.h"
#include "http_parser.h"
#include "config.h"
#include "utils.h"
#include "log.h"
struct uh_str {
const char *p;
size_t len;
};
enum {
UH_EV_HEAD_COMPLETE,
UH_EV_BODY,
UH_EV_COMPLETE
};
struct uh_server;
struct uh_connection {
struct uh_server *(*get_server)(struct uh_connection *conn);
struct ev_loop *(*get_loop)(struct uh_connection *conn);
/*
** Indicates the end of request processing
** Must be called at last, if not call 'error', 'redirect' and 'serve_file'
*/
void (*done)(struct uh_connection *conn);
void (*send)(struct uh_connection *conn, const void *data, ssize_t len);
void (*send_file)(struct uh_connection *conn, const char *path, off_t offset, int64_t len);
void (*printf)(struct uh_connection *conn, const char *format, ...) __attribute__((format(printf, 2, 3)));
void (*vprintf)(struct uh_connection *conn, const char *format, va_list arg);
void (*send_status_line)(struct uh_connection *conn, int code, const char *extra_headers);
void (*send_head)(struct uh_connection *conn, int code, int64_t content_length, const char *extra_headers);
void (*error)(struct uh_connection *conn, int code, const char *reason);
void (*redirect)(struct uh_connection *conn, int code, const char *location, ...) __attribute__((format(printf, 3, 4)));
void (*serve_file)(struct uh_connection *conn);
void (*chunk_send)(struct uh_connection *conn, const void *data, ssize_t len);
void (*chunk_printf)(struct uh_connection *conn, const char *format, ...) __attribute__((format(printf, 2, 3)));
void (*chunk_vprintf)(struct uh_connection *conn, const char *format, va_list arg);
void (*chunk_end)(struct uh_connection *conn);
const struct sockaddr *(*get_addr)(struct uh_connection *conn); /* peer address */
enum http_method (*get_method)(struct uh_connection *conn);
const char *(*get_method_str)(struct uh_connection *conn);
struct uh_str (*get_path)(struct uh_connection *conn);
struct uh_str (*get_query)(struct uh_connection *conn);
struct uh_str (*get_header)(struct uh_connection *conn, const char *name);
void (*traverse_headers)(struct uh_connection *conn,
bool (*cb)(const struct uh_str name, const struct uh_str value, void *arg), void *arg);
uint64_t (*get_content_length)(struct uh_connection *conn);
struct uh_str (*get_body)(struct uh_connection *conn);
/* The remain body data will be discurd after this function called */
struct uh_str (*extract_body)(struct uh_connection *conn);
void (*close)(struct uh_connection *conn); /* close low level TCP connection */
void *userdata;
};
typedef void (*uh_con_closed_cb_prototype)(struct uh_connection *conn);
typedef void (*uh_path_handler_prototype)(struct uh_connection *conn, int event);
struct uh_server {
struct ev_loop *(*get_loop)(struct uh_server *srv);
void (*free)(struct uh_server *srv);
/*
** listen an address, multiple call allowed
** returns the number of successful listen
**
** :80 0:80 0.0.0.0:80 [::]:80
** localhost:80 [::1]:80
*/
int (*listen)(struct uh_server *srv, const char *addr, bool ssl);
#if UHTTPD_SSL_SUPPORT
int (*ssl_init)(struct uh_server *srv, const char *cert, const char *key);
#endif
int (*load_plugin)(struct uh_server *srv, const char *path);
void (*set_conn_closed_cb)(struct uh_server *srv, uh_con_closed_cb_prototype cb);
void (*set_default_handler)(struct uh_server *srv, uh_path_handler_prototype handler);
int (*add_path_handler)(struct uh_server *srv, const char *path, uh_path_handler_prototype handler);
int (*set_docroot)(struct uh_server *srv, const char *path);
int (*set_index_page)(struct uh_server *srv, const char *name);
};
struct uh_plugin_handler {
const char *path;
uh_path_handler_prototype handler;
@ -44,44 +121,18 @@ struct uh_plugin {
struct uh_plugin *next;
};
enum {
UH_EV_HEAD_COMPLETE,
UH_EV_BODY,
UH_EV_COMPLETE
};
struct uh_path_handler {
uh_path_handler_prototype handler;
struct uh_path_handler *next;
char path[0];
};
struct uh_server {
int sock;
struct ev_loop *loop;
struct ev_io ior;
struct uh_connection *conns;
void (*free)(struct uh_server *srv);
void (*default_handler)(struct uh_connection *conn, int event);
#if UHTTPD_SSL_SUPPORT
void *ssl_ctx;
int (*ssl_init)(struct uh_server *srv, const char *cert, const char *key);
#endif
struct uh_plugin *plugins;
int (*load_plugin)(struct uh_server *srv, const char *path);
struct uh_path_handler *handlers;
int (*add_path_handler)(struct uh_server *srv, const char *path, uh_path_handler_prototype handler);
};
/*
* uh_server_new - creat an uh_server struct and init it
* @loop: If NULL will use EV_DEFAULT
* @host: If NULL will listen on "0.0.0.0"
* @port: port to listen on
*/
struct uh_server *uh_server_new(struct ev_loop *loop, const char *host, int port);
struct uh_server *uh_server_new(struct ev_loop *loop);
int uh_server_init(struct uh_server *srv, struct ev_loop *loop, const char *host, int port);
void uh_server_init(struct uh_server *srv, struct ev_loop *loop);
#endif

59
src/uhttpd_internal.h 100644
View File

@ -0,0 +1,59 @@
/*
* MIT License
*
* Copyright (c) 2019 Jianhui Zhao <zhaojh329@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef LIBUHTTPD_UHTTPD_INTERNAL_H
#define LIBUHTTPD_UHTTPD_INTERNAL_H
#include <arpa/inet.h>
#include "uhttpd.h"
struct uh_server_internal;
struct uh_connection_internal;
struct uh_listener {
int sock;
bool ssl;
struct ev_io ior;
struct uh_server_internal *srv;
struct uh_listener *next;
};
struct uh_server_internal {
struct uh_server com;
char *docroot;
char *index_page;
struct ev_loop *loop;
struct uh_listener *listeners;
struct uh_connection_internal *conns;
void (*conn_closed_cb)(struct uh_connection *conn);
void (*default_handler)(struct uh_connection *conn, int event);
#if UHTTPD_SSL_SUPPORT
void *ssl_ctx;
#endif
struct uh_plugin *plugins;
struct uh_path_handler *handlers;
};
#endif

45
src/utils.c
View File

@ -27,6 +27,8 @@
#include <inttypes.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <ctype.h>
#include "utils.h"
@ -44,3 +46,46 @@ const char *saddr2str(struct sockaddr *addr, char buf[], int len, int *port)
return buf;
}
bool support_so_reuseport()
{
bool ok = false;
int on = 1;
int sock;
sock = socket(AF_INET, SOCK_STREAM, 0);
if (!setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(int)))
ok = true;
close(sock);
return ok;
}
int urldecode(char *buf, int blen, const char *src, int slen)
{
int i;
int len = 0;
#define hex(x) \
(((x) <= '9') ? ((x) - '0') : \
(((x) <= 'F') ? ((x) - 'A' + 10) : \
((x) - 'a' + 10)))
for (i = 0; (i < slen) && (len < blen); i++) {
if (src[i] != '%') {
buf[len++] = src[i];
continue;
}
if (i + 2 >= slen || !isxdigit(src[i + 1]) || !isxdigit(src[i + 2]))
return -2;
buf[len++] = (char)(16 * hex(src[i+1]) + hex(src[i+2]));
i += 2;
}
buf[len] = 0;
return (i == slen) ? len : -1;
}

12
src/utils.h
View File

@ -28,8 +28,7 @@
#include <stddef.h>
#include <stdbool.h>
#include <inttypes.h>
#include "config.h"
#include <sys/socket.h>
#ifndef container_of
#define container_of(ptr, type, member) \
@ -41,4 +40,13 @@
const char *saddr2str(struct sockaddr *addr, char buf[], int len, int *port);
bool support_so_reuseport();
/*
** blen is the size of buf; slen is the length of src. The input-string need
** not be, and the output string will not be, null-terminated. Returns the
** length of the decoded string, -1 on buffer overflow, -2 on malformed string.
*/
int urldecode(char *buf, int blen, const char *src, int slen);
#endif