void service_anvil_global_init(void)
{
struct service_anvil_global *anvil;
anvil = i_new(struct service_anvil_global, 1);
if (pipe(anvil->status_fd) < 0)
i_fatal("pipe() failed: %m");
if (pipe(anvil->blocking_fd) < 0)
i_fatal("pipe() failed: %m");
if (pipe(anvil->nonblocking_fd) < 0)
i_fatal("pipe() failed: %m");
if (socketpair(AF_UNIX, SOCK_STREAM, 0, anvil->log_fdpass_fd) < 0)
i_fatal("socketpair() failed: %m");
fd_set_nonblock(anvil->status_fd[0], TRUE);
fd_set_nonblock(anvil->status_fd[1], TRUE);
fd_set_nonblock(anvil->nonblocking_fd[1], TRUE);
fd_close_on_exec(anvil->status_fd[0], TRUE);
fd_close_on_exec(anvil->status_fd[1], TRUE);
fd_close_on_exec(anvil->blocking_fd[0], TRUE);
fd_close_on_exec(anvil->blocking_fd[1], TRUE);
fd_close_on_exec(anvil->nonblocking_fd[0], TRUE);
fd_close_on_exec(anvil->nonblocking_fd[1], TRUE);
fd_close_on_exec(anvil->log_fdpass_fd[0], TRUE);
fd_close_on_exec(anvil->log_fdpass_fd[1], TRUE);
anvil->kills =
service_process_notify_init(anvil->nonblocking_fd[1],
service_process_write_anvil_kill);
service_anvil_global = anvil;
}
int log_error_cycle(server *srv) {
/* only cycle if the error log is a file */
if (srv->errorlog_mode == ERRORLOG_FILE) {
const char *logfile = srv->srvconf.errorlog_file->ptr;
/* already check of opening time */
int new_fd;
if (-1 == (new_fd = open_logfile_or_pipe(srv, logfile))) {
/* write to old log */
log_error_write(srv, __FILE__, __LINE__, "SSSSS",
"cycling errorlog '", logfile,
"' failed: ", strerror(errno),
", falling back to syslog()");
close(srv->errorlog_fd);
srv->errorlog_fd = -1;
#ifdef HAVE_SYSLOG_H
srv->errorlog_mode = ERRORLOG_SYSLOG;
#endif
} else {
/* ok, new log is open, close the old one */
close(srv->errorlog_fd);
srv->errorlog_fd = new_fd;
fd_close_on_exec(srv->errorlog_fd);
}
}
return 0;
}
int fdevent_linux_sysepoll_init(fdevents *ev) {
ev->type = FDEVENT_HANDLER_LINUX_SYSEPOLL;
#define SET(x) \
ev->x = fdevent_linux_sysepoll_##x;
SET(free);
SET(poll);
SET(event_del);
SET(event_set);
SET(event_next_fdndx);
SET(event_get_fd);
SET(event_get_revent);
if (-1 == (ev->epoll_fd = epoll_create(ev->maxfds))) {
log_error_write(ev->srv, __FILE__, __LINE__, "SSS",
"epoll_create failed (", strerror(errno), "), try to set server.event-handler = \"poll\" or \"select\"");
return -1;
}
fd_close_on_exec(ev->epoll_fd);
ev->epoll_events = malloc(ev->maxfds * sizeof(*ev->epoll_events));
force_assert(NULL != ev->epoll_events);
return 0;
}
int fdevent_fcntl_set(fdevents *ev, int fd) {
fd_close_on_exec(fd);
if ((ev) && (ev->fcntl_set)) return ev->fcntl_set(ev, fd);
#ifdef O_NONBLOCK
return fcntl(fd, F_SETFL, O_NONBLOCK | O_RDWR);
#else
return 0;
#endif
}
enum io_notify_result
io_add_notify(const char *path, const char *source_filename,
unsigned int source_linenum,
io_callback_t *callback, void *context, struct io **io_r)
{
struct ioloop_notify_handler_context *ctx =
current_ioloop->notify_handler_context;
struct kevent ev;
struct io_notify *io;
int fd;
if (ctx == NULL)
ctx = io_loop_notify_handler_init();
fd = open(path, O_RDONLY);
if (fd == -1) {
/* ESTALE could happen with NFS. Don't bother giving an error
message then. */
if (errno != ENOENT && errno != ESTALE)
i_error("open(%s) for kq notify failed: %m", path);
return IO_NOTIFY_NOTFOUND;
}
fd_close_on_exec(fd, TRUE);
io = i_new(struct io_notify, 1);
io->io.condition = IO_NOTIFY;
io->io.source_filename = source_filename;
io->io.source_linenum = source_linenum;
io->io.callback = callback;
io->io.context = context;
io->io.ioloop = current_ioloop;
io->refcount = 1;
io->fd = fd;
/* EV_CLEAR flag is needed because the EVFILT_VNODE filter reports
event state transitions and not the current state. With this flag,
the same event is only returned once. */
MY_EV_SET(&ev, fd, EVFILT_VNODE, EV_ADD | EV_CLEAR,
NOTE_DELETE | NOTE_RENAME | NOTE_WRITE | NOTE_EXTEND |
NOTE_REVOKE, 0, io);
if (kevent(ctx->kq, &ev, 1, NULL, 0, NULL) < 0) {
i_error("kevent(%d, %s) for notify failed: %m", fd, path);
i_close_fd(&fd);
i_free(io);
return IO_NOTIFY_NOSUPPORT;
}
if (ctx->event_io == NULL) {
ctx->event_io = io_add(ctx->kq, IO_READ, event_callback,
io->io.ioloop->notify_handler_context);
}
DLLIST_PREPEND(&ctx->notifies, io);
*io_r = &io->io;
return IO_NOTIFY_ADDED;
}
void io_loop_handler_init(struct ioloop *ioloop, unsigned int initial_fd_count)
{
struct ioloop_handler_context *ctx;
ioloop->handler_context = ctx = i_new(struct ioloop_handler_context, 1);
ctx->kq = kqueue();
if (ctx->kq < 0)
i_fatal("kqueue() in io_loop_handler_init() failed: %m");
fd_close_on_exec(ctx->kq, TRUE);
i_array_init(&ctx->events, initial_fd_count);
}
static struct ioloop_notify_handler_context *io_loop_notify_handler_init(void)
{
struct ioloop_notify_handler_context *ctx;
ctx = current_ioloop->notify_handler_context =
i_new(struct ioloop_notify_handler_context, 1);
ctx->kq = kqueue();
if (ctx->kq < 0)
i_fatal("kqueue(notify) failed: %m");
fd_close_on_exec(ctx->kq, TRUE);
return ctx;
}
int log_error_open(server *srv) {
#ifdef HAVE_SYSLOG_H
/* perhaps someone wants to use syslog() */
openlog("lighttpd", LOG_CONS | LOG_PID, LOG_DAEMON);
#endif
srv->errorlog_mode = ERRORLOG_FD;
srv->errorlog_fd = STDERR_FILENO;
if (srv->srvconf.errorlog_use_syslog) {
srv->errorlog_mode = ERRORLOG_SYSLOG;
} else if (!buffer_string_is_empty(srv->srvconf.errorlog_file)) {
const char *logfile = srv->srvconf.errorlog_file->ptr;
if (-1 == (srv->errorlog_fd = open_logfile_or_pipe(srv, logfile))) {
return -1;
}
srv->errorlog_mode = (logfile[0] == '|') ? ERRORLOG_PIPE : ERRORLOG_FILE;
}
log_error_write(srv, __FILE__, __LINE__, "s", "server started");
if (srv->errorlog_mode == ERRORLOG_FD && !srv->srvconf.dont_daemonize) {
/* We can only log to stderr in dont-daemonize mode;
* if we do daemonize and no errorlog file is specified, we log into /dev/null
*/
srv->errorlog_fd = -1;
}
if (!buffer_string_is_empty(srv->srvconf.breakagelog_file)) {
int breakage_fd;
const char *logfile = srv->srvconf.breakagelog_file->ptr;
if (srv->errorlog_mode == ERRORLOG_FD) {
srv->errorlog_fd = dup(STDERR_FILENO);
fd_close_on_exec(srv->errorlog_fd);
}
if (-1 == (breakage_fd = open_logfile_or_pipe(srv, logfile))) {
return -1;
}
if (STDERR_FILENO != breakage_fd) {
dup2(breakage_fd, STDERR_FILENO);
close(breakage_fd);
}
} else if (!srv->srvconf.dont_daemonize) {
/* move stderr to /dev/null */
openDevNull(STDERR_FILENO);
}
return 0;
}
static void movable_mmap_init(void)
{
#if MAP_ANONYMOUS == 0
/* mmap()ing /dev/zero should be the same with some platforms */
zero_fd = open("/dev/zero", O_RDWR);
if (zero_fd == -1)
i_fatal("Can't open /dev/zero for creating anonymous mmap: %m");
fd_close_on_exec(zero_fd, TRUE);
#endif
page_size = getpagesize();
header_size = page_size;
}
int fdevent_fcntl_set(fdevents *ev, int fd) {
fd_close_on_exec(fd);
if ((ev) && (ev->fcntl_set)) {
fprintf(dbgfile, "fdevent_fcntl_set: call fcntl_set\n");
fflush(dbgfile);
return ev->fcntl_set(ev, fd);
}
#ifdef o_nonblock
fprintf(dbgfile, "fdevent_fcntl_set: call fcntl\n");
fflush(dbgfile);
return fcntl(fd, f_SETFL, O_NONBLOCK | O_RDWR);
#else
return 0;
#endif
}
void io_loop_handler_init(struct ioloop *ioloop, unsigned int initial_fd_count)
{
struct ioloop_handler_context *ctx;
ioloop->handler_context = ctx = i_new(struct ioloop_handler_context, 1);
i_array_init(&ctx->events, initial_fd_count);
i_array_init(&ctx->fd_index, initial_fd_count);
ctx->epfd = epoll_create(initial_fd_count);
if (ctx->epfd < 0) {
if (errno != EMFILE)
i_fatal("epoll_create(): %m");
else {
i_fatal("epoll_create(): %m (you may need to increase "
"/proc/sys/fs/epoll/max_user_instances)");
}
}
fd_close_on_exec(ctx->epfd, TRUE);
}
void random_init(void)
{
unsigned int seed;
if (init_refcount++ > 0)
return;
urandom_fd = open(DEV_URANDOM_PATH, O_RDONLY);
if (urandom_fd == -1) {
if (errno == ENOENT) {
i_fatal(DEV_URANDOM_PATH" doesn't exist, "
"currently we require it");
} else {
i_fatal("Can't open "DEV_URANDOM_PATH": %m");
}
}
random_fill(&seed, sizeof(seed));
rand_set_seed(seed);
fd_close_on_exec(urandom_fd, TRUE);
}
int main(int argc,char **argv)
{
server *srv=NULL;
//step 1 : initialize server
if( (srv= server_init()) ==NULL){
fprintf(stderr,"failed to initialize server in [%s|%d|%s]\n",__FILE__,__LINE__,__FUNCTION__);
return -1;
}
//step 2 : parameter parse
char opt_chr;
while( (opt_chr=getopt(argc,argv,"f:hvD"))!=-1 ){
switch(opt_chr){
/*configuration file path */
case 'f':{
buffer_copy_string(srv->config->minihttpd_global_config_filepath,optarg);
break;
}
/* show help */
case 'h':{
print_help();
server_free(srv);
return 0;
}
case 'v':{
fprintf(stdout,"%s-%s",srv->config->service_name->ptr,srv->config->version_info->ptr);
server_free(srv);
return 0;
}
case 'D':{
srv->dont_daemonize=1;
break;
}
default:{
print_help();
server_free(srv);
return -1;
}
}
}
//step 3 :check if all configuraiton is legal
if(buffer_is_empty(srv->config->service_root_dir)){
fprintf(stderr,"[%s|%d|%s]:please specify minihttp root dir in configuration file\n",
__FILE__,__LINE__,__FUNCTION__);
server_free(srv);
return -1;
}
/*parse the mime configuration file */
if(buffer_is_empty(srv->config->mimetype_filepath)
|| (srv->config->table= mime_table_initialize( (const char*)srv->config->mimetype_filepath->ptr) )==NULL){
fprintf(stderr,"invalid mime configuration file is specified,pls check it..\n");
server_free(srv);
return -1;
}
//step4 :server started
srv->uid=getuid();
srv->gid=getgid();
if(srv->uid==0) { //we are root
struct rlimit res_limit;
if(getrlimit(RLIMIT_NOFILE,&res_limit)!=0){
fprintf(stderr,"[%s|%d|%s]: failed to get file descriptor max number for current process!\n",
__FILE__,__LINE__,__FUNCTION__);
server_free(srv);
return -1;
}
res_limit.rlim_cur=srv->config->max_fd;
res_limit.rlim_max=srv->config->max_fd;
if(setrlimit(RLIMIT_NOFILE,&res_limit)!=0){
fprintf(stderr,"[%s|%d|%s]: failed call setrlimit(RLIMIT_NOFILE,) for current process!\n",
__FILE__,__LINE__,__FUNCTION__);
server_free(srv);
return -1;
}
}else{
struct rlimit res_limit;
if(getrlimit(RLIMIT_NOFILE,&res_limit)!=0){
fprintf(stderr,"[%s|%d|%s]: failed to get file descriptor max number for current process!\n",
__FILE__,__LINE__,__FUNCTION__);
server_free(srv);
return -1;
}
if(srv->config->max_fd< res_limit.rlim_cur)
res_limit.rlim_cur=srv->config->max_fd;
else if(srv->config->max_fd<=res_limit.rlim_max)
res_limit.rlim_cur=srv->config->max_fd;
if(setrlimit(RLIMIT_NOFILE,&res_limit)!=0){
fprintf(stderr,"[%s|%d|%s]: failed call setrlimit(RLIMIT_NOFILE,) for current process!\n",
__FILE__,__LINE__,__FUNCTION__);
server_free(srv);
return -1;
}
}
//step 5: become a daemon process if dont_daemonize=0;
if(!srv->dont_daemonize){
daemonize((const char*)srv->config->service_name->ptr);
}
//step 6: open log file for error log, by default we use syslog.
// if the minihttpd log filepath is specified manually or server dont_daemonize=1,
// we set mode = LOG_MODE_FILE;
if(!buffer_is_empty(srv->config->log_filename) || srv->dont_daemonize ){
if(buffer_is_empty(srv->config->log_filename))
buffer_copy_string(srv->config->log_filename,MINIHTTPD_DEFAULT_LOG_FILEPATH);
srv->log_fd= open((const char*)srv->config->log_filename->ptr,O_WRONLY|O_CREAT|O_TRUNC,
S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
if(srv->log_fd<0){
server_free(srv);
return -1;
}
fd_close_on_exec(srv->log_fd);
srv->mode=server::LOG_MODE_FILE;
}
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_INFO,"%s is start now...",(const char*)srv->config->service_name->ptr);
//step 7 : create listening tcp socket(we only support ipv4 now)
struct sockaddr_in * addr= (struct sockaddr_in*)&srv->server_addr;
memset(addr,0,sizeof(*addr));
addr->sin_family=AF_INET;
addr->sin_addr.s_addr=htonl(INADDR_ANY);
addr->sin_port=htons(srv->config->listenint_port);
srv->listening_socket_fd= create_tcp_socket((struct sockaddr*)addr,srv->config->max_listening_number);
if(srv->listening_socket_fd<0){
log_to_backend(srv, MINIHTTPD_LOG_LEVEL_ERROR,"failed to create listening tcp socket on port:%d",
srv->config->listenint_port);
server_free(srv);
return -1;
}
/*
step 8: setup signal handler
signo: SIGCHLD
signo: SIGPIPE: unix domain socket pipe is broken
signo: SIGINT: user intend to shutdown the minihttpd server
if SIGINT is kill to the server proces for twice, the minihtpd server is going to shutdown
signo: SIGTERM: exit minihttpd service now
*/
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_flags=0;
act.sa_handler=signal_handler;
sigaction(SIGPIPE,&act,NULL);
sigaction(SIGCHLD,&act,NULL);
sigaction(SIGINT,&act,NULL);
sigaction(SIGTERM,&act,NULL);
/*
step 9: fork worker child process and transfter accept socket file descriptor to worker process
the only tasks for main processis :
1) to call accept to wait for connection and pick one worker process to handle the connection
2) wait all worker process to finish before exit.
*/
for(uint32_t worker_process_id=0;worker_process_id< srv->worker_number ;worker_process_id++) {
server_child * child= &srv->child[worker_process_id];
//create unix domain socket
if(socketpair(AF_UNIX,SOCK_STREAM,0,child->unix_domain_socket_fd)<0){
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_ERROR,"failed to create unix domain socket for worker%d",
worker_process_id);
close(srv->listening_socket_fd);
server_free(srv);
return -1;
}
child->sent_connection_number=0;
int unix_domain_socket_child_fd=child->unix_domain_socket_fd[1];
fd_set_nonblocking(unix_domain_socket_child_fd);
child->pid=fork();
if(child->pid <0){ //we can not fork worker process, this should not be happened
close(srv->listening_socket_fd);
server_free(srv) ;
return -1;
}
else if(child->pid ==0) { /* worker process */
/*we should use p_worker only in the child worker process */
#if 0
minihttpd_running_log(srv->log_fd,MINIHTTPD_LOG_LEVEL_INFO,__FILE__,__LINE__,__FUNCTION__,
"worker(pid=%d) is starting.....",getpid());
#endif
worker * server_worker = (worker*)malloc(sizeof(worker));
memset(server_worker,0,sizeof(worker));
server_worker->worker_id= worker_process_id;
server_worker->unix_domain_socekt_fd=unix_domain_socket_child_fd;
server_worker->log_filepath=buffer_init();
server_worker->global_config= srv->config;
/*step1 : get current file descriptor max number (it should be same as parent process
which we have set the resouces)*/
struct rlimit limit;
if(getrlimit(RLIMIT_NOFILE,&limit)<0){
exit(-1); // terminated the worker
}
//close unnecessary file descriptor
for(uint32_t file_descriptor_index=0;file_descriptor_index< limit.rlim_cur;file_descriptor_index++){
if(file_descriptor_index> STDERR_FILENO && file_descriptor_index != unix_domain_socket_child_fd){
close(file_descriptor_index);
}
}
//step 2: set event handler
server_worker->ev= fdevent_initialize(limit.rlim_cur);
/*support max connection number */
uint32_t worker_support_max_connections=limit.rlim_cur/2;
worker_connection_initialize(server_worker, worker_support_max_connections);
//step 3 : register unix domain socket event
fdevents_register_fd(server_worker->ev,server_worker->unix_domain_socekt_fd,
unix_domain_socket_handle,server_worker);
//EPOLLHUP |EPOLLERR events is set by default
fdevents_set_events(server_worker->ev,server_worker->unix_domain_socekt_fd,EPOLLIN);
//step 4 : open log file for worker to log debug/info/warning/error
if(buffer_is_empty(server_worker->log_filepath)){
char worker_log_filepath[255];
snprintf(worker_log_filepath,sizeof(worker_log_filepath),
MINIHTTPD_WORKER_CONFIG_PATH"%u.log", server_worker->worker_id );
buffer_append_string(server_worker->log_filepath,worker_log_filepath);
}
server_worker->log_fd= open((const char*)server_worker->log_filepath->ptr, O_WRONLY|O_CREAT|O_TRUNC,
S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
if(server_worker->log_fd<0){
exit(-2);
}
//step 5 : setup timer and expect timer will expire with internal 1 seconds
time(&server_worker->cur_ts);
int timer_fd=timerfd_create(CLOCK_REALTIME,TFD_NONBLOCK);
struct itimerspec timer_spec;
timer_spec.it_value.tv_sec=1;
timer_spec.it_value.tv_nsec=0;
timer_spec.it_interval.tv_sec=1;
timer_spec.it_interval.tv_nsec=0;
timerfd_settime(timer_fd,0,&timer_spec,NULL);
// setup timer experation events handler
fdevents_register_fd(server_worker->ev, timer_fd,worker_timer_expire_handler,
server_worker);
fdevents_set_events(server_worker->ev,timer_fd,EPOLLIN);
/* main loop for worker: epoll event loop for unix domain socket and connections */
while(server_shutdown==0 || server_worker->cur_connection_number >0 ) {
int n=epoll_wait(server_worker->ev->epoll_fd, server_worker->ev->epoll_events,
server_worker->ev->max_epoll_events,-1);
if(n<0 ){
if(errno!=EINTR){
minihttpd_running_log(server_worker->log_fd,MINIHTTPD_LOG_LEVEL_ERROR
,__FILE__,__LINE__,__FUNCTION__,
"failed to call epoll with errno=%d",errno);
}
continue;
}
else if(n==0){
//we should not get to here
continue;
}else {
for(uint32_t event_index=0;event_index<n;event_index++){
struct epoll_event * event= &server_worker->ev->epoll_events[event_index];
assert(event!=NULL);
int connection_socket_fd= event->data.fd;
event_handle handler=fdevents_get_handle(server_worker->ev,connection_socket_fd);
void * event_ctx=fdevents_get_context(server_worker->ev, connection_socket_fd);
assert(handler!=NULL);
int handle_status= handler(connection_socket_fd,event_ctx,event->events);
minihttpd_running_log(server_worker->log_fd,handle_status==0?
MINIHTTPD_LOG_LEVEL_INFO:MINIHTTPD_LOG_LEVEL_ERROR,
__FILE__,__LINE__,__FUNCTION__,"the epoll event is already handled!");
}
}
}
minihttpd_running_log(server_worker->log_fd,MINIHTTPD_LOG_LEVEL_INFO,
__FILE__,__LINE__,__FUNCTION__,"child worker process has finished all client requests!\n");
/*free all connections */
worker_free_connectons(server_worker);
/* unregister timer file descriptor */
fdevents_unset_event(server_worker->ev,timer_fd);
fdevents_unregister_fd(server_worker->ev,timer_fd);
close(timer_fd);
/* unregister unix domain socket hanlde events and handler context */
fdevents_unset_event(server_worker->ev,server_worker->unix_domain_socekt_fd);
fdevents_unregister_fd(server_worker->ev,server_worker->unix_domain_socekt_fd);
close(server_worker->unix_domain_socekt_fd);
/* free fevents resources */
close(server_worker->ev->epoll_fd);
fdevent_free(server_worker->ev);
//close the log file
close(server_worker->log_fd);
buffer_free(server_worker->log_filepath);
/* free worker */
free( (void*) server_worker);
exit(0); //termianted the worker
}
//close the unix domain socket worker file descriptor;
close(child->unix_domain_socket_fd[1]);
// child worker is running
child->worker_running=1;
//parent process
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_INFO,"worker process %d is already created!",worker_process_id);
}
//main loop to accept client connection and re-transfter to worker process
while(!server_shutdown) {
/*
log signal events after signal si handled by signal handler
*/
if(signal_pipe_handled){
/* if unix domain socket pipe is broken and we still write data to the pipe */
}
if(signal_child_handled){
/*a child worker process has terminated */
int worker_exit_status;
pid_t exit_worker_pid;
while( (exit_worker_pid= waitpid(-1,&worker_exit_status,WNOHANG))>0){
if(WIFEXITED(worker_exit_status)){
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_ERROR,"worker child process(pid=%d) has exited normally with exit" \
"status=%d",exit_worker_pid,WEXITSTATUS(worker_exit_status));
}
else if(WIFSIGNALED(worker_exit_status)){
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_ERROR,"worker child process(pid=%d) is killed by signal(%d)",
exit_worker_pid,WTERMSIG(worker_exit_status))
}
else{
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_ERROR,"worker child process(pid=%d) has exited unexpected", exit_worker_pid);
}
//remove the worker from available worker list and do not send socket file descriptor to it
for(uint32_t child_worker_id=0;child_worker_id< srv->worker_number;child_worker_id++){
if(srv->child[child_worker_id].pid==exit_worker_pid)
srv->child[child_worker_id].worker_running=0;
}
}
signal_child_handled=0;
}
//we block here to wait connection(only IPV4 is supported now )
struct sockaddr_in client_addr;
socklen_t client_addr_length=sizeof(client_addr);
int connection_fd =accept(srv->listening_socket_fd,(struct sockaddr*)&client_addr,(socklen_t*)& client_addr_length);
if(connection_fd<0){
switch(errno){
case EINTR:
// the connection is reset by client
case ECONNABORTED:
continue;
case EMFILE: //file descriptor is all used now, need to send file descriptor to worker soon
break;
default: {
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_ERROR,"failed to call accept() with errno=%d\n",errno);
break;
}
}
}
else{
/*
pick up a worker process and send the @conneciton_fd to it
the pick algorithm is round-robin,;
but for the draft version, we just pick a worker that we has sent the min connections
*/
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_INFO,"client connection is accepted,pick a worker to handle it.");
uint32_t pick_worker_index= srv->worker_number;
uint32_t min_sent_connections=0xFFFFFFFF;
for(uint32_t worker_process_id=0; worker_process_id<srv->worker_number;worker_process_id++){
if(srv->child[worker_process_id].sent_connection_number < min_sent_connections
&& srv->child[worker_process_id].worker_running) {
min_sent_connections= srv->child[worker_process_id].sent_connection_number;
pick_worker_index= worker_process_id;
}
}
if(pick_worker_index>= srv->worker_number){
/* we can not handle it as all child worker has exited...*/
close(connection_fd);
continue;
}
/*set file descriptor to nonblocking and set close_on_exec flag*/
fd_set_nonblocking(connection_fd);
fd_close_on_exec(connection_fd);
if(unix_domain_socket_sendfd(srv->child[pick_worker_index].unix_domain_socket_fd[0],
connection_fd)<0){
log_to_backend(srv,MINIHTTPD_LOG_LEVEL_ERROR,"failed to send the connection file descriptor to worker!");
close(connection_fd); //just close it to tell the client,we can not handle it now.
continue;
}
srv->child[pick_worker_index].sent_connection_number++;
//close the file descriptor as it is already marked in flight
close(connection_fd);
}
}
static int network_server_init(server *srv, buffer *host_token, specific_config *s) {
int val;
socklen_t addr_len;
server_socket *srv_socket;
unsigned int port = 0;
const char *host;
buffer *b;
int err;
#ifdef __WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
/* Tell the user that we could not find a usable */
/* WinSock DLL. */
return -1;
}
#endif
err = -1;
srv_socket = calloc(1, sizeof(*srv_socket));
force_assert(NULL != srv_socket);
srv_socket->addr.plain.sa_family = AF_INET; /* default */
srv_socket->fd = -1;
srv_socket->fde_ndx = -1;
srv_socket->srv_token = buffer_init();
buffer_copy_buffer(srv_socket->srv_token, host_token);
b = buffer_init();
buffer_copy_buffer(b, host_token);
host = b->ptr;
if (host[0] == '/') {
/* host is a unix-domain-socket */
#ifdef HAVE_SYS_UN_H
srv_socket->addr.plain.sa_family = AF_UNIX;
#else
log_error_write(srv, __FILE__, __LINE__, "s",
"ERROR: Unix Domain sockets are not supported.");
goto error_free_socket;
#endif
} else {
/* ipv4:port
* [ipv6]:port
*/
size_t len = buffer_string_length(b);
char *sp = NULL;
if (0 == len) {
log_error_write(srv, __FILE__, __LINE__, "s", "value of $SERVER[\"socket\"] must not be empty");
goto error_free_socket;
}
if ((b->ptr[0] == '[' && b->ptr[len-1] == ']') || NULL == (sp = strrchr(b->ptr, ':'))) {
/* use server.port if set in config, or else default from config_set_defaults() */
port = srv->srvconf.port;
sp = b->ptr + len; /* point to '\0' at end of string so end of IPv6 address can be found below */
} else {
/* found ip:port separator at *sp; port doesn't end in ']', so *sp hopefully doesn't split an IPv6 address */
*sp = '\0';
port = strtol(sp+1, NULL, 10);
}
/* check for [ and ] */
if (b->ptr[0] == '[' && *(sp-1) == ']') {
*(sp-1) = '\0';
host++;
s->use_ipv6 = 1;
}
if (port == 0 || port > 65535) {
log_error_write(srv, __FILE__, __LINE__, "sd", "port not set or out of range:", port);
goto error_free_socket;
}
}
if (*host == '\0') host = NULL;
#ifdef HAVE_IPV6
if (s->use_ipv6) {
srv_socket->addr.plain.sa_family = AF_INET6;
}
#endif
switch(srv_socket->addr.plain.sa_family) {
#ifdef HAVE_IPV6
case AF_INET6:
memset(&srv_socket->addr, 0, sizeof(struct sockaddr_in6));
srv_socket->addr.ipv6.sin6_family = AF_INET6;
if (host == NULL) {
srv_socket->addr.ipv6.sin6_addr = in6addr_any;
log_error_write(srv, __FILE__, __LINE__, "s", "warning: please use server.use-ipv6 only for hostnames, not without server.bind / empty address; your config will break if the kernel default for IPV6_V6ONLY changes");
} else {
struct addrinfo hints, *res;
int r;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (0 != (r = getaddrinfo(host, NULL, &hints, &res))) {
log_error_write(srv, __FILE__, __LINE__,
"sssss", "getaddrinfo failed: ",
gai_strerror(r), "'", host, "'");
goto error_free_socket;
}
memcpy(&(srv_socket->addr), res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
}
srv_socket->addr.ipv6.sin6_port = htons(port);
addr_len = sizeof(struct sockaddr_in6);
break;
#endif
case AF_INET:
memset(&srv_socket->addr, 0, sizeof(struct sockaddr_in));
srv_socket->addr.ipv4.sin_family = AF_INET;
if (host == NULL) {
srv_socket->addr.ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
} else {
struct hostent *he;
if (NULL == (he = gethostbyname(host))) {
log_error_write(srv, __FILE__, __LINE__,
"sds", "gethostbyname failed: ",
h_errno, host);
goto error_free_socket;
}
if (he->h_addrtype != AF_INET) {
log_error_write(srv, __FILE__, __LINE__, "sd", "addr-type != AF_INET: ", he->h_addrtype);
goto error_free_socket;
}
if (he->h_length != sizeof(struct in_addr)) {
log_error_write(srv, __FILE__, __LINE__, "sd", "addr-length != sizeof(in_addr): ", he->h_length);
goto error_free_socket;
}
memcpy(&(srv_socket->addr.ipv4.sin_addr.s_addr), he->h_addr_list[0], he->h_length);
}
srv_socket->addr.ipv4.sin_port = htons(port);
addr_len = sizeof(struct sockaddr_in);
break;
#ifdef HAVE_SYS_UN_H
case AF_UNIX:
memset(&srv_socket->addr, 0, sizeof(struct sockaddr_un));
srv_socket->addr.un.sun_family = AF_UNIX;
{
size_t hostlen = strlen(host) + 1;
if (hostlen > sizeof(srv_socket->addr.un.sun_path)) {
log_error_write(srv, __FILE__, __LINE__, "sS", "unix socket filename too long:", host);
goto error_free_socket;
}
memcpy(srv_socket->addr.un.sun_path, host, hostlen);
#if defined(SUN_LEN)
addr_len = SUN_LEN(&srv_socket->addr.un);
#else
/* stevens says: */
addr_len = hostlen + sizeof(srv_socket->addr.un.sun_family);
#endif
}
break;
#endif
default:
goto error_free_socket;
}
if (srv->srvconf.preflight_check) {
err = 0;
goto error_free_socket;
}
if (srv->sockets_disabled) { /* lighttpd -1 (one-shot mode) */
#ifdef USE_OPENSSL
if (s->ssl_enabled) srv_socket->ssl_ctx = s->ssl_ctx;
#endif
goto srv_sockets_append;
}
#ifdef HAVE_SYS_UN_H
if (AF_UNIX == srv_socket->addr.plain.sa_family) {
/* check if the socket exists and try to connect to it. */
if (-1 == (srv_socket->fd = socket(srv_socket->addr.plain.sa_family, SOCK_STREAM, 0))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socket failed:", strerror(errno));
goto error_free_socket;
}
if (0 == connect(srv_socket->fd, (struct sockaddr *) &(srv_socket->addr), addr_len)) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"server socket is still in use:",
host);
goto error_free_socket;
}
/* connect failed */
switch(errno) {
case ECONNREFUSED:
unlink(host);
break;
case ENOENT:
break;
default:
log_error_write(srv, __FILE__, __LINE__, "sds",
"testing socket failed:",
host, strerror(errno));
goto error_free_socket;
}
} else
#endif
{
if (-1 == (srv_socket->fd = socket(srv_socket->addr.plain.sa_family, SOCK_STREAM, IPPROTO_TCP))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socket failed:", strerror(errno));
goto error_free_socket;
}
#ifdef HAVE_IPV6
if (AF_INET6 == srv_socket->addr.plain.sa_family
&& host != NULL) {
if (s->set_v6only) {
val = 1;
if (-1 == setsockopt(srv_socket->fd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socketsockopt(IPV6_V6ONLY) failed:", strerror(errno));
goto error_free_socket;
}
} else {
log_error_write(srv, __FILE__, __LINE__, "s", "warning: server.set-v6only will be removed soon, update your config to have different sockets for ipv4 and ipv6");
}
}
#endif
}
/* set FD_CLOEXEC now, fdevent_fcntl_set is called later; needed for pipe-logger forks */
fd_close_on_exec(srv_socket->fd);
/* */
srv->cur_fds = srv_socket->fd;
val = 1;
if (setsockopt(srv_socket->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socketsockopt(SO_REUSEADDR) failed:", strerror(errno));
goto error_free_socket;
}
if (0 != bind(srv_socket->fd, (struct sockaddr *) &(srv_socket->addr), addr_len)) {
switch(srv_socket->addr.plain.sa_family) {
case AF_UNIX:
log_error_write(srv, __FILE__, __LINE__, "sds",
"can't bind to socket:",
host, strerror(errno));
break;
default:
log_error_write(srv, __FILE__, __LINE__, "ssds",
"can't bind to port:",
host, port, strerror(errno));
break;
}
goto error_free_socket;
}
if (-1 == listen(srv_socket->fd, s->listen_backlog)) {
log_error_write(srv, __FILE__, __LINE__, "ss", "listen failed: ", strerror(errno));
goto error_free_socket;
}
if (s->ssl_enabled) {
#ifdef USE_OPENSSL
if (NULL == (srv_socket->ssl_ctx = s->ssl_ctx)) {
log_error_write(srv, __FILE__, __LINE__, "s", "ssl.pemfile has to be set");
goto error_free_socket;
}
#else
log_error_write(srv, __FILE__, __LINE__, "ss", "SSL:",
"ssl requested but openssl support is not compiled in");
goto error_free_socket;
#endif
#ifdef TCP_DEFER_ACCEPT
} else if (s->defer_accept) {
int v = s->defer_accept;
if (-1 == setsockopt(srv_socket->fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &v, sizeof(v))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "can't set TCP_DEFER_ACCEPT: ", strerror(errno));
}
#endif
#if defined(__FreeBSD__) || defined(__NetBSD__) \
|| defined(__OpenBSD__) || defined(__DragonflyBSD__)
} else if (!buffer_is_empty(s->bsd_accept_filter)
&& (buffer_is_equal_string(s->bsd_accept_filter, CONST_STR_LEN("httpready"))
|| buffer_is_equal_string(s->bsd_accept_filter, CONST_STR_LEN("dataready")))) {
#ifdef SO_ACCEPTFILTER
/* FreeBSD accf_http filter */
struct accept_filter_arg afa;
memset(&afa, 0, sizeof(afa));
strncpy(afa.af_name, s->bsd_accept_filter->ptr, sizeof(afa.af_name));
if (setsockopt(srv_socket->fd, SOL_SOCKET, SO_ACCEPTFILTER, &afa, sizeof(afa)) < 0) {
if (errno != ENOENT) {
log_error_write(srv, __FILE__, __LINE__, "SBss", "can't set accept-filter '", s->bsd_accept_filter, "':", strerror(errno));
}
}
#endif
#endif
}
srv_sockets_append:
srv_socket->is_ssl = s->ssl_enabled;
if (srv->srv_sockets.size == 0) {
srv->srv_sockets.size = 4;
srv->srv_sockets.used = 0;
srv->srv_sockets.ptr = malloc(srv->srv_sockets.size * sizeof(server_socket*));
force_assert(NULL != srv->srv_sockets.ptr);
} else if (srv->srv_sockets.used == srv->srv_sockets.size) {
srv->srv_sockets.size += 4;
srv->srv_sockets.ptr = realloc(srv->srv_sockets.ptr, srv->srv_sockets.size * sizeof(server_socket*));
force_assert(NULL != srv->srv_sockets.ptr);
}
srv->srv_sockets.ptr[srv->srv_sockets.used++] = srv_socket;
buffer_free(b);
return 0;
error_free_socket:
if (srv_socket->fd != -1) {
/* check if server fd are already registered */
if (srv_socket->fde_ndx != -1) {
fdevent_event_del(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd);
fdevent_unregister(srv->ev, srv_socket->fd);
}
close(srv_socket->fd);
}
buffer_free(srv_socket->srv_token);
free(srv_socket);
buffer_free(b);
return err; /* -1 if error; 0 if srv->srvconf.preflight_check successful */
}
int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
chunk *c;
for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
int chunk_finished = 0;
switch(c->type) {
case MEM_CHUNK: {
char * offset;
off_t toSend;
ssize_t r;
size_t num_chunks, i;
struct iovec *chunks;
chunk *tc;
size_t num_bytes = 0;
/* build writev list
*
* 1. limit: num_chunks < MAX_CHUNKS
* 2. limit: num_bytes < max_bytes
*/
for (num_chunks = 0, tc = c; tc && tc->type == MEM_CHUNK && num_chunks < MAX_CHUNKS; num_chunks++, tc = tc->next);
chunks = calloc(num_chunks, sizeof(*chunks));
for(tc = c, i = 0; i < num_chunks; tc = tc->next, i++) {
if (buffer_string_is_empty(tc->mem)) {
chunks[i].iov_base = tc->mem->ptr;
chunks[i].iov_len = 0;
} else {
offset = tc->mem->ptr + tc->offset;
toSend = buffer_string_length(tc->mem) - tc->offset;
chunks[i].iov_base = offset;
/* protect the return value of writev() */
if (toSend > max_bytes ||
(off_t) num_bytes + toSend > max_bytes) {
chunks[i].iov_len = max_bytes - num_bytes;
num_chunks = i + 1;
break;
} else {
chunks[i].iov_len = toSend;
}
num_bytes += toSend;
}
}
if ((r = writev(fd, chunks, num_chunks)) < 0) {
switch (errno) {
case EAGAIN:
case EINTR:
r = 0;
break;
case EPIPE:
case ECONNRESET:
free(chunks);
return -2;
default:
log_error_write(srv, __FILE__, __LINE__, "ssd",
"writev failed:", strerror(errno), fd);
free(chunks);
return -1;
}
}
cq->bytes_out += r;
max_bytes -= r;
/* check which chunks have been written */
for(i = 0, tc = c; i < num_chunks; i++, tc = tc->next) {
if (r >= (ssize_t)chunks[i].iov_len) {
/* written */
r -= chunks[i].iov_len;
tc->offset += chunks[i].iov_len;
if (chunk_finished) {
/* skip the chunks from further touches */
c = c->next;
} else {
/* chunks_written + c = c->next is done in the for()*/
chunk_finished = 1;
}
} else {
/* partially written */
tc->offset += r;
chunk_finished = 0;
break;
}
}
free(chunks);
break;
}
case FILE_CHUNK: {
ssize_t r;
off_t abs_offset;
off_t toSend;
stat_cache_entry *sce = NULL;
#define KByte * 1024
#define MByte * 1024 KByte
#define GByte * 1024 MByte
const off_t we_want_to_mmap = 512 KByte;
char *start = NULL;
if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) {
log_error_write(srv, __FILE__, __LINE__, "sb",
strerror(errno), c->file.name);
return -1;
}
abs_offset = c->file.start + c->offset;
if (abs_offset > sce->st.st_size) {
log_error_write(srv, __FILE__, __LINE__, "sb",
"file was shrinked:", c->file.name);
return -1;
}
/* mmap the buffer
* - first mmap
* - new mmap as the we are at the end of the last one */
if (c->file.mmap.start == MAP_FAILED ||
abs_offset == (off_t)(c->file.mmap.offset + c->file.mmap.length)) {
/* Optimizations for the future:
*
* adaptive mem-mapping
* the problem:
* we mmap() the whole file. If someone has alot large files and 32bit
* machine the virtual address area will be unrun and we will have a failing
* mmap() call.
* solution:
* only mmap 16M in one chunk and move the window as soon as we have finished
* the first 8M
*
* read-ahead buffering
* the problem:
* sending out several large files in parallel trashes the read-ahead of the
* kernel leading to long wait-for-seek times.
* solutions: (increasing complexity)
* 1. use madvise
* 2. use a internal read-ahead buffer in the chunk-structure
* 3. use non-blocking IO for file-transfers
* */
/* all mmap()ed areas are 512kb expect the last which might be smaller */
off_t we_want_to_send;
size_t to_mmap;
/* this is a remap, move the mmap-offset */
if (c->file.mmap.start != MAP_FAILED) {
munmap(c->file.mmap.start, c->file.mmap.length);
c->file.mmap.offset += we_want_to_mmap;
} else {
/* in case the range-offset is after the first mmap()ed area we skip the area */
c->file.mmap.offset = 0;
while (c->file.mmap.offset + we_want_to_mmap < c->file.start) {
c->file.mmap.offset += we_want_to_mmap;
}
}
/* length is rel, c->offset too, assume there is no limit at the mmap-boundaries */
we_want_to_send = c->file.length - c->offset;
to_mmap = (c->file.start + c->file.length) - c->file.mmap.offset;
/* we have more to send than we can mmap() at once */
if (abs_offset + we_want_to_send > c->file.mmap.offset + we_want_to_mmap) {
we_want_to_send = (c->file.mmap.offset + we_want_to_mmap) - abs_offset;
to_mmap = we_want_to_mmap;
}
if (-1 == c->file.fd) { /* open the file if not already open */
if (-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
log_error_write(srv, __FILE__, __LINE__, "sbs", "open failed for:", c->file.name, strerror(errno));
return -1;
}
fd_close_on_exec(c->file.fd);
}
if (MAP_FAILED == (c->file.mmap.start = mmap(NULL, to_mmap, PROT_READ, MAP_SHARED, c->file.fd, c->file.mmap.offset))) {
log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed:",
strerror(errno), c->file.name, c->file.fd);
return -1;
}
c->file.mmap.length = to_mmap;
#ifdef LOCAL_BUFFERING
buffer_copy_string_len(c->mem, c->file.mmap.start, c->file.mmap.length);
#else
#ifdef HAVE_MADVISE
/* don't advise files < 64Kb */
if (c->file.mmap.length > (64 KByte)) {
/* darwin 7 is returning EINVAL all the time and I don't know how to
* detect this at runtime.i
*
* ignore the return value for now */
madvise(c->file.mmap.start, c->file.mmap.length, MADV_WILLNEED);
}
#endif
#endif
/* chunk_reset() or chunk_free() will cleanup for us */
}
/* to_send = abs_mmap_end - abs_offset */
toSend = (c->file.mmap.offset + c->file.mmap.length) - (abs_offset);
if (toSend < 0) {
log_error_write(srv, __FILE__, __LINE__, "soooo",
"toSend is negative:",
toSend,
c->file.mmap.length,
abs_offset,
c->file.mmap.offset);
force_assert(toSend < 0);
}
if (toSend > max_bytes) toSend = max_bytes;
#ifdef LOCAL_BUFFERING
start = c->mem->ptr;
#else
start = c->file.mmap.start;
#endif
if ((r = write(fd, start + (abs_offset - c->file.mmap.offset), toSend)) < 0) {
switch (errno) {
case EAGAIN:
case EINTR:
r = 0;
break;
case EPIPE:
case ECONNRESET:
return -2;
default:
log_error_write(srv, __FILE__, __LINE__, "ssd",
"write failed:", strerror(errno), fd);
return -1;
}
}
c->offset += r;
cq->bytes_out += r;
max_bytes -= r;
if (c->offset == c->file.length) {
chunk_finished = 1;
/* we don't need the mmaping anymore */
if (c->file.mmap.start != MAP_FAILED) {
munmap(c->file.mmap.start, c->file.mmap.length);
c->file.mmap.start = MAP_FAILED;
}
}
break;
}
default:
log_error_write(srv, __FILE__, __LINE__, "ds", c, "type not known");
return -1;
}
if (!chunk_finished) {
/* not finished yet */
break;
}
}
return 0;
}
int network_open_file_chunk(server *srv, connection *con, chunkqueue *cq) {
chunk* const c = cq->first;
off_t file_size, offset, toSend;
force_assert(NULL != c);
force_assert(FILE_CHUNK == c->type || SMB_CHUNK == c->type);
force_assert(c->offset >= 0 && c->offset <= c->file.length);
//Cdbg(1,"0 c->file.start=%lld, c->offset=%lld, c->file.length=%lld", c->file.start, c->offset, c->file.length);
offset = c->file.start + c->offset;
toSend = c->file.length - c->offset;
if (-1 == c->file.fd) {
stat_cache_entry *sce = NULL;
if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) {
log_error_write(srv, __FILE__, __LINE__, "ssb", "stat-cache failed:", strerror(errno), c->file.name);
return -1;
}
if( c->type == SMB_CHUNK ){
if (-1 == (c->file.fd = smbc_wrapper_open(con,c->file.name->ptr, O_RDONLY, 0755))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "open failed: ", strerror(errno));
return -1;
}
}
else{
if (-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY|O_NOCTTY))) {
log_error_write(srv, __FILE__, __LINE__, "ssb", "open failed:", strerror(errno), c->file.name);
return -1;
}
fd_close_on_exec(c->file.fd);
}
file_size = sce->st.st_size;
}
else {
struct stat st;
if( c->type == SMB_CHUNK ){
if (-1 == smbc_wrapper_stat(con, c->file.name->ptr, &st)) {
log_error_write(srv, __FILE__, __LINE__, "ss", "smbc_wrapper_stat failed:", strerror(errno));
return -1;
}
}
else{
if (-1 == fstat(c->file.fd, &st)) {
log_error_write(srv, __FILE__, __LINE__, "ss", "fstat failed:", strerror(errno));
return -1;
}
}
file_size = st.st_size;
}
//Cdbg(1,"1 file_size=%d, toSend=%d, offset=%d", file_size, toSend, offset);
if (offset > file_size || toSend > file_size || offset > file_size - toSend) {
//Cdbg(1,"2 file_size=%d", file_size);
log_error_write(srv, __FILE__, __LINE__, "sb", "file was shrinked:", c->file.name);
return -1;
}
return 0;
}
int open_logfile_or_pipe(server *srv, const char* logfile) {
int fd;
if (logfile[0] == '|') {
#ifdef HAVE_FORK
/* create write pipe and spawn process */
int to_log_fds[2];
if (pipe(to_log_fds)) {
log_error_write(srv, __FILE__, __LINE__, "ss", "pipe failed: ", strerror(errno));
return -1;
}
/* fork, execve */
switch (fork()) {
case 0:
/* child */
close(STDIN_FILENO);
/* dup the filehandle to STDIN */
if (to_log_fds[0] != STDIN_FILENO) {
if (STDIN_FILENO != dup2(to_log_fds[0], STDIN_FILENO)) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"dup2 failed: ", strerror(errno));
exit(-1);
}
close(to_log_fds[0]);
}
close(to_log_fds[1]);
#ifndef FD_CLOEXEC
{
int i;
/* we don't need the client socket */
for (i = 3; i < 256; i++) {
close(i);
}
}
#endif
/* close old stderr */
openDevNull(STDERR_FILENO);
/* exec the log-process (skip the | ) */
execl("/bin/sh", "sh", "-c", logfile + 1, NULL);
log_error_write(srv, __FILE__, __LINE__, "sss",
"spawning log process failed: ", strerror(errno),
logfile + 1);
exit(-1);
break;
case -1:
/* error */
log_error_write(srv, __FILE__, __LINE__, "ss", "fork failed: ", strerror(errno));
return -1;
default:
close(to_log_fds[0]);
fd = to_log_fds[1];
break;
}
#else
return -1;
#endif
} else if (-1 == (fd = open(logfile, O_APPEND | O_WRONLY | O_CREAT | O_LARGEFILE, 0644))) {
log_error_write(srv, __FILE__, __LINE__, "SSSS",
"opening errorlog '", logfile,
"' failed: ", strerror(errno));
return -1;
}
fd_close_on_exec(fd);
return fd;
}
static int mod_rrd_create_pipe(server *srv, plugin_data *p) {
#ifdef HAVE_FORK
pid_t pid;
int to_rrdtool_fds[2];
int from_rrdtool_fds[2];
if (pipe(to_rrdtool_fds)) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"pipe failed: ", strerror(errno));
return -1;
}
if (pipe(from_rrdtool_fds)) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"pipe failed: ", strerror(errno));
return -1;
}
/* fork, execve */
switch (pid = fork()) {
case 0: {
/* child */
char **args;
int argc;
int i = 0;
char *dash = "-";
/* move stdout to from_rrdtool_fd[1] */
close(STDOUT_FILENO);
dup2(from_rrdtool_fds[1], STDOUT_FILENO);
close(from_rrdtool_fds[1]);
/* not needed */
close(from_rrdtool_fds[0]);
/* move the stdin to to_rrdtool_fd[0] */
close(STDIN_FILENO);
dup2(to_rrdtool_fds[0], STDIN_FILENO);
close(to_rrdtool_fds[0]);
/* not needed */
close(to_rrdtool_fds[1]);
/* set up args */
argc = 3;
args = malloc(sizeof(*args) * argc);
i = 0;
args[i++] = p->conf.path_rrdtool_bin->ptr;
args[i++] = dash;
args[i ] = NULL;
/* we don't need the client socket */
for (i = 3; i < 256; i++) {
close(i);
}
/* exec the cgi */
execv(args[0], args);
/* log_error_write(srv, __FILE__, __LINE__, "sss", "spawing rrdtool failed: ", strerror(errno), args[0]); */
/* */
SEGFAULT();
break;
}
case -1:
/* error */
log_error_write(srv, __FILE__, __LINE__, "ss", "fork failed: ", strerror(errno));
break;
default: {
/* father */
close(from_rrdtool_fds[1]);
close(to_rrdtool_fds[0]);
/* register PID and wait for them asyncronously */
p->write_fd = to_rrdtool_fds[1];
p->read_fd = from_rrdtool_fds[0];
p->rrdtool_pid = pid;
fd_close_on_exec(p->write_fd);
fd_close_on_exec(p->read_fd);
break;
}
}
return 0;
#else
return -1;
#endif
}
int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
chunk *c;
for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
int chunk_finished = 0;
switch(c->type) {
case MEM_CHUNK: {
char * offset;
off_t toSend;
ssize_t r;
size_t num_chunks, i;
struct iovec chunks[UIO_MAXIOV];
chunk *tc;
size_t num_bytes = 0;
/* build writev list
*
* 1. limit: num_chunks < UIO_MAXIOV
* 2. limit: num_bytes < max_bytes
*/
for (num_chunks = 0, tc = c;
tc && tc->type == MEM_CHUNK && num_chunks < UIO_MAXIOV;
tc = tc->next, num_chunks++);
for (tc = c, i = 0; i < num_chunks; tc = tc->next, i++) {
if (buffer_string_is_empty(tc->mem)) {
chunks[i].iov_base = tc->mem->ptr;
chunks[i].iov_len = 0;
} else {
offset = tc->mem->ptr + tc->offset;
toSend = buffer_string_length(tc->mem) - tc->offset;
chunks[i].iov_base = offset;
/* protect the return value of writev() */
if (toSend > max_bytes ||
(off_t) num_bytes + toSend > max_bytes) {
chunks[i].iov_len = max_bytes - num_bytes;
num_chunks = i + 1;
break;
} else {
chunks[i].iov_len = toSend;
}
num_bytes += toSend;
}
}
if ((r = writev(fd, chunks, num_chunks)) < 0) {
switch (errno) {
case EAGAIN:
case EINTR:
r = 0;
break;
case EPIPE:
case ECONNRESET:
return -2;
default:
log_error_write(srv, __FILE__, __LINE__, "ssd",
"writev failed:", strerror(errno), fd);
return -1;
}
}
/* check which chunks have been written */
cq->bytes_out += r;
max_bytes -= r;
for(i = 0, tc = c; i < num_chunks; i++, tc = tc->next) {
if (r >= (ssize_t)chunks[i].iov_len) {
/* written */
r -= chunks[i].iov_len;
tc->offset += chunks[i].iov_len;
if (chunk_finished) {
/* skip the chunks from further touches */
c = c->next;
} else {
/* chunks_written + c = c->next is done in the for()*/
chunk_finished = 1;
}
} else {
/* partially written */
tc->offset += r;
chunk_finished = 0;
break;
}
}
break;
}
case FILE_CHUNK: {
ssize_t r;
off_t offset;
off_t toSend;
stat_cache_entry *sce = NULL;
offset = c->file.start + c->offset;
toSend = c->file.length - c->offset;
if (toSend > max_bytes) toSend = max_bytes;
/* open file if not already opened */
if (-1 == c->file.fd) {
if (-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "open failed: ", strerror(errno));
return -1;
}
fd_close_on_exec(c->file.fd);
#ifdef HAVE_POSIX_FADVISE
/* tell the kernel that we want to stream the file */
if (-1 == posix_fadvise(c->file.fd, 0, 0, POSIX_FADV_SEQUENTIAL)) {
if (ENOSYS != errno) {
log_error_write(srv, __FILE__, __LINE__, "ssd",
"posix_fadvise failed:", strerror(errno), c->file.fd);
}
}
#endif
}
if (-1 == (r = sendfile(fd, c->file.fd, &offset, toSend))) {
switch (errno) {
case EAGAIN:
case EINTR:
/* ok, we can't send more, let's try later again */
r = 0;
break;
case EPIPE:
case ECONNRESET:
return -2;
default:
log_error_write(srv, __FILE__, __LINE__, "ssd",
"sendfile failed:", strerror(errno), fd);
return -1;
}
} else if (r == 0) {
int oerrno = errno;
/* We got an event to write but we wrote nothing
*
* - the file shrinked -> error
* - the remote side closed inbetween -> remote-close */
if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) {
/* file is gone ? */
return -1;
}
if (offset > sce->st.st_size) {
/* file shrinked, close the connection */
errno = oerrno;
return -1;
}
errno = oerrno;
return -2;
}
#ifdef HAVE_POSIX_FADVISE
#if 0
#define K * 1024
#define M * 1024 K
#define READ_AHEAD 4 M
/* check if we need a new chunk */
if ((c->offset & ~(READ_AHEAD - 1)) != ((c->offset + r) & ~(READ_AHEAD - 1))) {
/* tell the kernel that we want to stream the file */
if (-1 == posix_fadvise(c->file.fd, (c->offset + r) & ~(READ_AHEAD - 1), READ_AHEAD, POSIX_FADV_NOREUSE)) {
log_error_write(srv, __FILE__, __LINE__, "ssd",
"posix_fadvise failed:", strerror(errno), c->file.fd);
}
}
#endif
#endif
c->offset += r;
cq->bytes_out += r;
max_bytes -= r;
if (c->offset == c->file.length) {
chunk_finished = 1;
/* chunk_free() / chunk_reset() will cleanup for us but it is a ok to be faster :) */
if (c->file.fd != -1) {
close(c->file.fd);
c->file.fd = -1;
}
}
break;
}
default:
log_error_write(srv, __FILE__, __LINE__, "ds", c, "type not known");
return -1;
}
if (!chunk_finished) {
/* not finished yet */
break;
}
}
return 0;
}
static int network_server_init(server *srv, buffer *host_token, specific_config *s) {
int val;
socklen_t addr_len;
server_socket *srv_socket;
char *sp;
unsigned int port = 0;
const char *host;
buffer *b;
int is_unix_domain_socket = 0;
int fd;
#ifdef __WIN32
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
/* Tell the user that we could not find a usable */
/* WinSock DLL. */
return -1;
}
#endif
srv_socket = calloc(1, sizeof(*srv_socket));
srv_socket->fd = -1;
srv_socket->fde_ndx = -1;
srv_socket->srv_token = buffer_init();
buffer_copy_string_buffer(srv_socket->srv_token, host_token);
b = buffer_init();
buffer_copy_string_buffer(b, host_token);
/* ipv4:port
* [ipv6]:port
*/
if (NULL == (sp = strrchr(b->ptr, ':'))) {
log_error_write(srv, __FILE__, __LINE__, "sb", "value of $SERVER[\"socket\"] has to be \"ip:port\".", b);
goto error_free_socket;
}
host = b->ptr;
/* check for [ and ] */
if (b->ptr[0] == '[' && *(sp-1) == ']') {
*(sp-1) = '\0';
host++;
s->use_ipv6 = 1;
}
*(sp++) = '\0';
port = strtol(sp, NULL, 10);
if (host[0] == '/') {
/* host is a unix-domain-socket */
is_unix_domain_socket = 1;
} else if (port == 0 || port > 65535) {
log_error_write(srv, __FILE__, __LINE__, "sd", "port out of range:", port);
goto error_free_socket;
}
if (*host == '\0') host = NULL;
if (is_unix_domain_socket) {
#ifdef HAVE_SYS_UN_H
srv_socket->addr.plain.sa_family = AF_UNIX;
if (-1 == (srv_socket->fd = socket(srv_socket->addr.plain.sa_family, SOCK_STREAM, 0))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socket failed:", strerror(errno));
goto error_free_socket;
}
#else
log_error_write(srv, __FILE__, __LINE__, "s",
"ERROR: Unix Domain sockets are not supported.");
goto error_free_socket;
#endif
}
#ifdef HAVE_IPV6
if (s->use_ipv6) {
srv_socket->addr.plain.sa_family = AF_INET6;
if (-1 == (srv_socket->fd = socket(srv_socket->addr.plain.sa_family, SOCK_STREAM, IPPROTO_TCP))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socket failed:", strerror(errno));
goto error_free_socket;
}
}
#endif
if (srv_socket->fd == -1) {
srv_socket->addr.plain.sa_family = AF_INET;
if (-1 == (srv_socket->fd = socket(srv_socket->addr.plain.sa_family, SOCK_STREAM, IPPROTO_TCP))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socket failed:", strerror(errno));
goto error_free_socket;
}
}
/* set FD_CLOEXEC now, fdevent_fcntl_set is called later; needed for pipe-logger forks */
fd_close_on_exec(srv_socket->fd);
/* */
srv->cur_fds = srv_socket->fd;
val = 1;
if (setsockopt(srv_socket->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socketsockopt(SO_REUSEADDR) failed:", strerror(errno));
goto error_free_socket;
}
switch(srv_socket->addr.plain.sa_family) {
#ifdef HAVE_IPV6
case AF_INET6:
memset(&srv_socket->addr, 0, sizeof(struct sockaddr_in6));
srv_socket->addr.ipv6.sin6_family = AF_INET6;
if (host == NULL) {
srv_socket->addr.ipv6.sin6_addr = in6addr_any;
log_error_write(srv, __FILE__, __LINE__, "s", "warning: please use server.use-ipv6 only for hostnames, not without server.bind / empty address; your config will break if the kernel default for IPV6_V6ONLY changes");
} else {
struct addrinfo hints, *res;
int r;
if (s->set_v6only) {
val = 1;
if (-1 == setsockopt(srv_socket->fd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "socketsockopt(IPV6_V6ONLY) failed:", strerror(errno));
goto error_free_socket;
}
} else {
log_error_write(srv, __FILE__, __LINE__, "s", "warning: server.set-v6only will be removed soon, update your config to have different sockets for ipv4 and ipv6");
}
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (0 != (r = getaddrinfo(host, NULL, &hints, &res))) {
log_error_write(srv, __FILE__, __LINE__,
"sssss", "getaddrinfo failed: ",
gai_strerror(r), "'", host, "'");
goto error_free_socket;
}
memcpy(&(srv_socket->addr), res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
}
srv_socket->addr.ipv6.sin6_port = htons(port);
addr_len = sizeof(struct sockaddr_in6);
break;
#endif
case AF_INET:
memset(&srv_socket->addr, 0, sizeof(struct sockaddr_in));
srv_socket->addr.ipv4.sin_family = AF_INET;
if (host == NULL) {
srv_socket->addr.ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
} else {
struct hostent *he;
if (NULL == (he = gethostbyname(host))) {
log_error_write(srv, __FILE__, __LINE__,
"sds", "gethostbyname failed: ",
h_errno, host);
goto error_free_socket;
}
if (he->h_addrtype != AF_INET) {
log_error_write(srv, __FILE__, __LINE__, "sd", "addr-type != AF_INET: ", he->h_addrtype);
goto error_free_socket;
}
if (he->h_length != sizeof(struct in_addr)) {
log_error_write(srv, __FILE__, __LINE__, "sd", "addr-length != sizeof(in_addr): ", he->h_length);
goto error_free_socket;
}
memcpy(&(srv_socket->addr.ipv4.sin_addr.s_addr), he->h_addr_list[0], he->h_length);
}
srv_socket->addr.ipv4.sin_port = htons(port);
addr_len = sizeof(struct sockaddr_in);
break;
case AF_UNIX:
{
size_t hostlen = strlen(host) + 1;
if (hostlen > sizeof(srv_socket->addr.un.sun_path)) {
log_error_write(srv, __FILE__, __LINE__, "sS", "unix socket filename too long:", host);
goto error_free_socket;
}
memcpy(srv_socket->addr.un.sun_path, host, hostlen);
}
srv_socket->addr.un.sun_family = AF_UNIX;
#ifdef SUN_LEN
addr_len = SUN_LEN(&srv_socket->addr.un);
#else
/* stevens says: */
addr_len = hostlen + sizeof(srv_socket->addr.un.sun_family);
#endif
/* check if the socket exists and try to connect to it. */
if (-1 != (fd = connect(srv_socket->fd, (struct sockaddr *) &(srv_socket->addr), addr_len))) {
close(fd);
log_error_write(srv, __FILE__, __LINE__, "ss",
"server socket is still in use:",
host);
goto error_free_socket;
}
/* connect failed */
switch(errno) {
case ECONNREFUSED:
unlink(host);
break;
case ENOENT:
break;
default:
log_error_write(srv, __FILE__, __LINE__, "sds",
"testing socket failed:",
host, strerror(errno));
goto error_free_socket;
}
break;
default:
goto error_free_socket;
}
if (0 != bind(srv_socket->fd, (struct sockaddr *) &(srv_socket->addr), addr_len)) {
switch(srv_socket->addr.plain.sa_family) {
case AF_UNIX:
log_error_write(srv, __FILE__, __LINE__, "sds",
"can't bind to socket:",
host, strerror(errno));
break;
default:
log_error_write(srv, __FILE__, __LINE__, "ssds",
"can't bind to port:",
host, port, strerror(errno));
break;
}
goto error_free_socket;
}
if (-1 == listen(srv_socket->fd, 128 * 8)) {
log_error_write(srv, __FILE__, __LINE__, "ss", "listen failed: ", strerror(errno));
goto error_free_socket;
}
if (s->ssl_enabled) {
#ifdef USE_OPENSSL
if (NULL == (srv_socket->ssl_ctx = s->ssl_ctx)) {
log_error_write(srv, __FILE__, __LINE__, "s", "ssl.pemfile has to be set");
goto error_free_socket;
}
#else
log_error_write(srv, __FILE__, __LINE__, "ss", "SSL:",
"ssl requested but openssl support is not compiled in");
goto error_free_socket;
#endif
#ifdef TCP_DEFER_ACCEPT
} else if (s->defer_accept) {
int v = s->defer_accept;
if (-1 == setsockopt(srv_socket->fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &v, sizeof(v))) {
log_error_write(srv, __FILE__, __LINE__, "ss", "can't set TCP_DEFER_ACCEPT: ", strerror(errno));
}
#endif
} else {
#ifdef SO_ACCEPTFILTER
/* FreeBSD accf_http filter */
struct accept_filter_arg afa;
memset(&afa, 0, sizeof(afa));
strcpy(afa.af_name, "httpready");
if (setsockopt(srv_socket->fd, SOL_SOCKET, SO_ACCEPTFILTER, &afa, sizeof(afa)) < 0) {
if (errno != ENOENT) {
log_error_write(srv, __FILE__, __LINE__, "ss", "can't set accept-filter 'httpready': ", strerror(errno));
}
}
#endif
}
srv_socket->is_ssl = s->ssl_enabled;
if (srv->srv_sockets.size == 0) {
srv->srv_sockets.size = 4;
srv->srv_sockets.used = 0;
srv->srv_sockets.ptr = malloc(srv->srv_sockets.size * sizeof(server_socket*));
} else if (srv->srv_sockets.used == srv->srv_sockets.size) {
srv->srv_sockets.size += 4;
srv->srv_sockets.ptr = realloc(srv->srv_sockets.ptr, srv->srv_sockets.size * sizeof(server_socket*));
}
srv->srv_sockets.ptr[srv->srv_sockets.used++] = srv_socket;
buffer_free(b);
return 0;
error_free_socket:
if (srv_socket->fd != -1) {
/* check if server fd are already registered */
if (srv_socket->fde_ndx != -1) {
fdevent_event_del(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd);
fdevent_unregister(srv->ev, srv_socket->fd);
}
close(srv_socket->fd);
}
buffer_free(srv_socket->srv_token);
free(srv_socket);
buffer_free(b);
return -1;
}