NIM_EXTERNC N_NOINLINE(void, stdlib_timesInit)(void) {
tzset();
}
int
main(int argc, char **argv)
{
int c;
int forkaway = 0;
FILE *pidfile;
const char *pidpath = "/var/run/tvheadend.pid";
struct group *grp;
struct passwd *pw;
const char *usernam = NULL;
const char *groupnam = NULL;
int logfacility = LOG_DAEMON;
int createdefault = 0;
sigset_t set;
const char *homedir;
const char *rawts_input = NULL;
const char *join_transport = NULL;
const char *confpath = NULL;
char *p, *endp;
uint32_t adapter_mask = 0xffffffff;
int crash = 0;
// make sure the timezone is set
tzset();
while((c = getopt(argc, argv, "Aa:fp:u:g:c:Chdr:j:s")) != -1) {
switch(c) {
case 'a':
adapter_mask = 0x0;
p = strtok(optarg, ",");
if (p != NULL) {
do {
int adapter = strtol(p, &endp, 10);
if (*endp != 0 || adapter < 0 || adapter > 31) {
fprintf(stderr, "Invalid adapter number '%s'\n", p);
return 1;
}
adapter_mask |= (1 << adapter);
} while ((p = strtok(NULL, ",")) != NULL);
if (adapter_mask == 0x0) {
fprintf(stderr, "No adapters specified!\n");
return 1;
}
} else {
usage(argv[0]);
}
break;
case 'A':
crash = 1;
break;
case 'f':
forkaway = 1;
break;
case 'p':
pidpath = optarg;
break;
case 'u':
usernam = optarg;
break;
case 'g':
groupnam = optarg;
break;
case 'c':
confpath = optarg;
break;
case 'd':
log_debug_to_console = 1;
break;
case 's':
log_debug_to_syslog = 1;
break;
case 'C':
createdefault = 1;
break;
case 'r':
rawts_input = optarg;
break;
case 'j':
join_transport = optarg;
break;
default:
usage(argv[0]);
}
}
signal(SIGPIPE, handle_sigpipe);
if(forkaway) {
grp = getgrnam(groupnam ?: "video");
pw = usernam ? getpwnam(usernam) : NULL;
if(daemon(0, 0)) {
exit(2);
}
pidfile = fopen(pidpath, "w+");
if(pidfile != NULL) {
fprintf(pidfile, "%d\n", getpid());
fclose(pidfile);
}
if(grp != NULL) {
setgid(grp->gr_gid);
} else {
setgid(1);
}
if (pw != NULL) {
gid_t glist[10];
int gnum = get_user_groups(pw, glist, 10);
setgroups(gnum, glist);
setuid(pw->pw_uid);
homedir = pw->pw_dir;
setenv("HOME", homedir, 1);
} else {
setuid(1);
}
umask(0);
}
log_stderr = !forkaway;
log_decorate = isatty(2);
sigfillset(&set);
sigprocmask(SIG_BLOCK, &set, NULL);
openlog("tvheadend", LOG_PID, logfacility);
hts_settings_init(confpath);
pthread_mutex_init(&ffmpeg_lock, NULL);
pthread_mutex_init(&fork_lock, NULL);
pthread_mutex_init(&global_lock, NULL);
pthread_mutex_lock(&global_lock);
time(&dispatch_clock);
trap_init(argv[0]);
/**
* Initialize subsystems
*/
xmltv_init(); /* Must be initialized before channels */
service_init();
channels_init();
access_init(createdefault);
tcp_server_init();
#if ENABLE_LINUXDVB
dvb_init(adapter_mask);
#endif
iptv_input_init();
#if ENABLE_V4L
v4l_init();
#endif
http_server_init();
webui_init(tvheadend_dataroot());
serviceprobe_init();
cwc_init();
capmt_init();
epg_init();
dvr_init();
htsp_init();
ffdecsa_init();
if(rawts_input != NULL)
rawts_init(rawts_input);
if(join_transport != NULL)
subscription_dummy_join(join_transport, 1);
#ifdef CONFIG_AVAHI
avahi_init();
#endif
pthread_mutex_unlock(&global_lock);
/**
* Wait for SIGTERM / SIGINT, but only in this thread
*/
running = 1;
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGINT);
signal(SIGTERM, doexit);
signal(SIGINT, doexit);
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
tvhlog(LOG_NOTICE, "START", "HTS Tvheadend version %s started, "
"running as PID:%d UID:%d GID:%d, settings located in '%s', "
"dataroot: %s",
tvheadend_version,
getpid(), getuid(), getgid(), hts_settings_get_root(),
tvheadend_dataroot() ?: "<Embedded file system>");
if(crash)
abort();
mainloop();
epg_save();
tvhlog(LOG_NOTICE, "STOP", "Exiting HTS Tvheadend");
if(forkaway)
unlink("/var/run/tvheadend.pid");
return 0;
}
/*
******************
* 程序的入口点
*****************
*/
int main(int argc, char **argv)
{
server *srv = NULL;
int print_config = 0;
int test_config = 0;
int i_am_root;
int o;
int num_childs = 0;
int pid_fd = -1, fd;
size_t i;
#ifdef HAVE_SIGACTION
struct sigaction act;
#endif
#ifdef HAVE_GETRLIMIT
struct rlimit rlim;
#endif
#ifdef USE_ALARM
struct itimerval interval;
interval.it_interval.tv_sec = 1;
interval.it_interval.tv_usec = 0;
interval.it_value.tv_sec = 1;
interval.it_value.tv_usec = 0;
#endif
/*
* for nice %b handling in strfime()
*/
setlocale(LC_TIME, "C");
if (NULL == (srv = server_init()))
{
fprintf(stderr, "did this really happen?\n");
return -1;
}
/*
* init structs done
*/
srv->srvconf.port = 0;
//
#ifdef HAVE_GETUID
i_am_root = (getuid() == 0);
#else
i_am_root = 0;
#endif
//程序将被设置为守护进程。
srv->srvconf.dont_daemonize = 0;
//处理参数。
while (-1 != (o = getopt(argc, argv, "f:m:hvVDpt")))
{
switch (o)
{
case 'f':
if (config_read(srv, optarg))
{
server_free(srv);
return -1;
}
break;
case 'm':
buffer_copy_string(srv->srvconf.modules_dir, optarg);
break;
case 'p':
print_config = 1;
break;
case 't':
test_config = 1;
break;
case 'D':
srv->srvconf.dont_daemonize = 1;
break;
case 'v':
show_version();
return 0;
case 'V':
show_features();
return 0;
case 'h':
show_help();
return 0;
default:
show_help();
server_free(srv);
return -1;
}
}
if (!srv->config_storage)
{
log_error_write(srv, __FILE__, __LINE__, "s",
"No configuration available. Try using -f option.");
server_free(srv);
return -1;
}
if (print_config)
{
data_unset *dc = srv->config_context->data[0];
if (dc)
{
dc->print(dc, 0);
fprintf(stdout, "\n");
} else
{
/*
* shouldn't happend
*/
fprintf(stderr, "global config not found\n");
}
}
if (test_config) //没有进行任何测试。。。
{
printf("Syntax OK\n");
}
if (test_config || print_config)
{
server_free(srv);
return 0;
}
/*
* close stdin and stdout, as they are not needed
* 关闭标准输入和标准输出。
*/
openDevNull(STDIN_FILENO);
openDevNull(STDOUT_FILENO);
//设置为默认的配置。
if (0 != config_set_defaults(srv))
{
log_error_write(srv, __FILE__, __LINE__, "s",
"setting default values failed");
server_free(srv);
return -1;
}
/*
* UID handling
*/
#ifdef HAVE_GETUID
//检查有效用户ID和有效组ID是否是0（root）。
if (!i_am_root && (geteuid() == 0 || getegid() == 0))
{
/*
* we are setuid-root
* 程序的实际用户ID不是0,也就是程序不是由超级用户运行的，但是程序的有效用户ID
* 或者有效组ID是超级用户（组），因此，程序可以访问任何文件而不受限制！这样很
* 不安全。因此程序退出并提示用户。
*/
log_error_write(srv, __FILE__, __LINE__, "s",
"Are you nuts ? Don't apply a SUID bit to this binary");
server_free(srv);
return -1;
}
#endif
/*
* check document-root
*/
if (srv->config_storage[0]->document_root->used <= 1)
{
log_error_write(srv, __FILE__, __LINE__, "s",
"document-root is not set\n");
server_free(srv);
return -1;
}
/*
* 加载插件
*
* 插件是以动态链接库的形式存在的。在配置文件中，要配置好插件的链接库的
* 路径位置和库中函数的名称。在这个函数中，通过这些配置，获得函数的入口
* 地址。
* 可以看到，这个函数的调用是在整个程序的初始化阶段，而且只调用了这一次，
* 因此，在服务器运行之前，要配置好所有的插件。
* 如果想增加插件，只能重启服务器。
*
* 在实现plugins_load函数的时候，同时也有一个用于加载静态链接库的版本，
* 但函数并没有什么实质性的实现。
*
*/
if (plugins_load(srv))
{
log_error_write(srv, __FILE__, __LINE__, "s",
"loading plugins finally failed");
plugins_free(srv);
server_free(srv);
return -1;
}
/*
* open pid file BEFORE chroot
* 打开pid文件，并将进程号写入pid文件。
*/
if (srv->srvconf.pid_file->used)
{
if (-1 ==
(pid_fd =
open(srv->srvconf.pid_file->ptr,
O_WRONLY | O_CREAT | O_EXCL | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)))
/**
* O_EXCL和O_CREAT同时使用，测试文件是否存在，如果存在
* 则报错。
*/
{
//pid文件打开失败。。。
struct stat st;
if (errno != EEXIST) //不是报文件已经存在的错误。
{
log_error_write(srv, __FILE__, __LINE__, "sbs",
"opening pid-file failed:",
srv->srvconf.pid_file, strerror(errno));
return -1;
}
//pid文件已经存在，测试文件的状态。
if (0 != stat(srv->srvconf.pid_file->ptr, &st))
{
log_error_write(srv, __FILE__, __LINE__, "sbs",
"stating existing pid-file failed:",
srv->srvconf.pid_file, strerror(errno));
}
if (!S_ISREG(st.st_mode)) //pid文件是普通文件。
{
log_error_write(srv, __FILE__, __LINE__, "sb",
"pid-file exists and isn't regular file:",
srv->srvconf.pid_file);
return -1;
}
//重新打开pid文件。
//这里不在使用O_EXCL参数，由于pid文件已经存在且是普通文件，则覆盖原先的文件。
if (-1 ==
(pid_fd =
open(srv->srvconf.pid_file->ptr,
O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)))
{
log_error_write(srv, __FILE__, __LINE__, "sbs",
"opening pid-file failed:",
srv->srvconf.pid_file, strerror(errno));
return -1;
}
}
}
if (srv->event_handler == FDEVENT_HANDLER_SELECT)
{
/*
* select limits itself as it is a hard limit and will lead to a segfault
* we add some safety
* select的硬限制。减去200是为了增加安全性，防止出现段错误。
*/
srv->max_fds = FD_SETSIZE - 200;
}
else
{
srv->max_fds = 4096;
}
//程序是在超级用户模式下运行的。
if (i_am_root)
{
struct group *grp = NULL;
struct passwd *pwd = NULL;
int use_rlimit = 1;
#ifdef HAVE_VALGRIND_VALGRIND_H
if (RUNNING_ON_VALGRIND)
use_rlimit = 0;
#endif
#ifdef HAVE_GETRLIMIT
/**
* getrlimit和setrlimit函数用于查询和修改进程的资源限制。
*
* include <sys/resource.h>
* int getrlimit(int resource, struct rlimit *rlim);
* int setrlimit(int resource, const struct rlimit *rlim);
* 返回：若成功为0，出错为非0
*
* 对这两个函数的每一次调用都指定一个资源以及一个指向下列结构的指针。
*
* struct rlimit
* {
* rlim_t rlim_cur; //软限制：当前限制
* rlim_t rlim_max; //硬限制：rlimcur的最大值
* }；
*
* 这两个函数不属于POSIX.1，但SVR4和4.3+BSD提供它们。SVR4在上面的结构中使用基本系统数据类型rlim_t。
* 其它系统则将这两个成员定义为整型或长整型。
*
* 程序中使用的参数RLIMIT_NOFILE：Specifies a value one greater than the maximum file descriptor
* number that can be opened by this process. 设置最大的文件打开数，且实际打开的文件数要比这个数
* 小一。
*
* 详细使用：man getrlimit
*/
if (0 != getrlimit(RLIMIT_NOFILE, &rlim)) //获得当前的文件打开数限制。
{
log_error_write(srv, __FILE__, __LINE__,
"ss", "couldn't get 'max filedescriptors'", strerror(errno));
return -1;
}
if (use_rlimit && srv->srvconf.max_fds)
{
/*
* set rlimits. 设置限制。
*/
rlim.rlim_cur = srv->srvconf.max_fds; //软限制。
rlim.rlim_max = srv->srvconf.max_fds; //硬限制。
if (0 != setrlimit(RLIMIT_NOFILE, &rlim))
{
log_error_write(srv, __FILE__, __LINE__,
"ss", "couldn't set 'max filedescriptors'", strerror(errno));
return -1;
}
}
//根据实际设置情况，重新设置max_fds。
if (srv->event_handler == FDEVENT_HANDLER_SELECT)
{
srv->max_fds = rlim.rlim_cur < FD_SETSIZE - 200 ? rlim.rlim_cur : FD_SETSIZE - 200;
}
else
{
srv->max_fds = rlim.rlim_cur;
}
/*
* set core file rlimit, if enable_cores is set
* 设置core文件的限制。如果设置了enable_cores。
*/
if (use_rlimit && srv->srvconf.enable_cores
&& getrlimit(RLIMIT_CORE, &rlim) == 0)
{
rlim.rlim_cur = rlim.rlim_max;
setrlimit(RLIMIT_CORE, &rlim);
}
#endif
if (srv->event_handler == FDEVENT_HANDLER_SELECT)
{
/*
* don't raise the limit above FD_SET_SIZE
*/
if (srv->max_fds > FD_SETSIZE - 200)
{
log_error_write(srv, __FILE__, __LINE__, "sd",
"can't raise max filedescriptors above",
FD_SETSIZE - 200,
"if event-handler is 'select'. Use 'poll' or something else or reduce server.max-fds.");
return -1;
}
}
#ifdef HAVE_PWD_H
/*
* set user and group 设置用户和组。
*/
if (srv->srvconf.username->used)
{
//根据配置中的用户名获取用户信息。
if (NULL == (pwd = getpwnam(srv->srvconf.username->ptr)))
{
log_error_write(srv, __FILE__, __LINE__, "sb", "can't find username", srv->srvconf.username);
return -1;
}
if (pwd->pw_uid == 0)
{
log_error_write(srv, __FILE__, __LINE__, "s", "I will not set uid to 0\n");
return -1;
}
}
if (srv->srvconf.groupname->used)
{
//根据上面得到的用户所在的组的组名，获得组的信息。
if (NULL == (grp = getgrnam(srv->srvconf.groupname->ptr)))
{
log_error_write(srv, __FILE__, __LINE__, "sb", "can't find groupname", srv->srvconf.groupname);
return -1;
}
if (grp->gr_gid == 0)
{
log_error_write(srv, __FILE__, __LINE__, "s", "I will not set gid to 0\n");
return -1;
}
}
#endif
/*
* we need root-perms for port < 1024
* 使用超级用户模式获得小于1024的端口。初始化网络。
* 创建监听socket，绑定地址并开始监听。
*/
if (0 != network_init(srv))
{
plugins_free(srv);
server_free(srv);
return -1;
}
#ifdef HAVE_PWD_H
/*
* Change group before chroot, when we have access
* to /etc/group
* */
if (srv->srvconf.groupname->used)
{
setgid(grp->gr_gid);
setgroups(0, NULL); //返回用户组的数目。
if (srv->srvconf.username->used)
{
//Initialize the group access list by reading the group database /etc/group and using all groups of which
//user is a member. The additional group group is also added to the list.
initgroups(srv->srvconf.username->ptr, grp->gr_gid);
}
}
#endif
#ifdef HAVE_CHROOT
if (srv->srvconf.changeroot->used)
{
//The tzset() function initializes the tzname variable from the TZ environment variable.
//This function is automatically called by the other time conversion functions that depend
//on the time zone.
//In a SysV-like environment it will also set the variables time-zone (seconds West of GMT)
//and daylight
//(0 if this time zone does not have any daylight saving time rules, nonzero if there is a
//time during the year when daylight saving time applies).
tzset();
//设置程序所参考的根目录，将被所有的子进程继承。
//也就是对于本程序而言，"/"并不是系统的根目录，而是这设置的目录。
if (-1 == chroot(srv->srvconf.changeroot->ptr))
{
log_error_write(srv, __FILE__, __LINE__, "ss", "chroot failed: ", strerror(errno));
return -1;
}
//修改工作目录.
/*
* 注意：
* 由于前面已经设置了根目录。因此这里将工作目录切换到"/"并不是系统的根目录，而是
* 上面通过函数chroot设置的根目录。
*/
if (-1 == chdir("/"))
{
log_error_write(srv, __FILE__, __LINE__, "ss", "chdir failed: ", strerror(errno));
return -1;
}
}
#endif
#ifdef HAVE_PWD_H
/*
* drop root privs 放弃超级管理员权限。
*/
if (srv->srvconf.username->used)
{
setuid(pwd->pw_uid);
}
#endif
#if defined(HAVE_SYS_PRCTL_H) && defined(PR_SET_DUMPABLE)
/**
* on IRIX 6.5.30 they have prctl() but no DUMPABLE
*/
if (srv->srvconf.enable_cores)
{
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
#endif
}
/*
* 下面的是程序在非root用户下执行的设置。
*/
else
{
#ifdef HAVE_GETRLIMIT
if (0 != getrlimit(RLIMIT_NOFILE, &rlim))
{
log_error_write(srv, __FILE__, __LINE__,
"ss", "couldn't get 'max filedescriptors'",
strerror(errno));
return -1;
}
/**
* we are not root can can't increase the fd-limit, but we can reduce it
* 我们不是root，不能增加fd-limit，但我们可以减少。
*/
if (srv->srvconf.max_fds && srv->srvconf.max_fds < rlim.rlim_cur)
{
/*
* set rlimits
*/
rlim.rlim_cur = srv->srvconf.max_fds; //只能设置软限制。
if (0 != setrlimit(RLIMIT_NOFILE, &rlim))
{
log_error_write(srv, __FILE__, __LINE__,
"ss", "couldn't set 'max filedescriptors'",
strerror(errno));
return -1;
}
}
if (srv->event_handler == FDEVENT_HANDLER_SELECT)
{
srv->max_fds = rlim.rlim_cur < FD_SETSIZE - 200 ? rlim.rlim_cur : FD_SETSIZE - 200;
}
else
{
srv->max_fds = rlim.rlim_cur;
}
/*
* set core file rlimit, if enable_cores is set
*/
if (srv->srvconf.enable_cores && getrlimit(RLIMIT_CORE, &rlim) == 0)
{
rlim.rlim_cur = rlim.rlim_max;
setrlimit(RLIMIT_CORE, &rlim);
}
#endif
if (srv->event_handler == FDEVENT_HANDLER_SELECT)
{
/*
* don't raise the limit above FD_SET_SIZE
*/
if (srv->max_fds > FD_SETSIZE - 200)
{
log_error_write(srv, __FILE__, __LINE__, "sd",
"can't raise max filedescriptors above", FD_SETSIZE - 200,
"if event-handler is 'select'. Use 'poll' or something else or reduce server.max-fds.");
return -1;
}
}
if (0 != network_init(srv))
{
plugins_free(srv);
server_free(srv);
return -1;
}
}
/*
* set max-conns 设置最大连接数。
*/
if (srv->srvconf.max_conns > srv->max_fds)
{
/*
* we can't have more connections than max-fds
* 最大连接数要小于最大文件打开数(max-fds)
*/
srv->max_conns = srv->max_fds;
}
else if (srv->srvconf.max_conns)
{
/*
* otherwise respect the wishes of the user
* 根据用户设置。
*/
srv->max_conns = srv->srvconf.max_conns;
}
else
{
/*
* or use the default 默认。
*/
srv->max_conns = srv->max_fds;
}
/*
* 在前面的plugins_load函数中，已经所有的插件读入到系统中，并对插件中含有
* 的各种函数，确定入口地址。
* 在这里，程序对所有插件进行登记造册，确定插件中含有的功能，并计入表中(srv->plugins_slot)
*
*/
if (HANDLER_GO_ON != plugins_call_init(srv))
{
log_error_write(srv, __FILE__, __LINE__, "s",
"Initialization of plugins failed. Going down.");
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
#ifdef HAVE_FORK
/*
* network is up, let's deamonize ourself
* 设置为守护进程。
*/
if (srv->srvconf.dont_daemonize == 0)
daemonize();
#endif
srv->gid = getgid();
srv->uid = getuid();
/*
* write pid file 写pid文件。
*/
if (pid_fd != -1)
{
buffer_copy_long(srv->tmp_buf, getpid());
buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN("\n"));
write(pid_fd, srv->tmp_buf->ptr, srv->tmp_buf->used - 1);
close(pid_fd);
pid_fd = -1;
}
/*
* Close stderr ASAP in the child process to make sure that nothing is
* being written to that fd which may not be valid anymore.
* 关闭向标准输出的输出，打开日志文件。
*/
if (-1 == log_error_open(srv))
{
log_error_write(srv, __FILE__, __LINE__, "s",
"Opening errorlog failed. Going down.");
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
//将插件设置为默认配置
if (HANDLER_GO_ON != plugins_call_set_defaults(srv))
{
log_error_write(srv, __FILE__, __LINE__, "s",
"Configuration of plugins failed. Going down.");
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
/*
* dump unused config-keys
*/
for (i = 0; i < srv->config_context->used; i++)
{
array *config = ((data_config *) srv->config_context->data[i])->value;
size_t j;
for (j = 0; config && j < config->used; j++)
{
data_unset *du = config->data[j];
/*
* all var.* is known as user defined variable
*/
if (strncmp(du->key->ptr, "var.", sizeof("var.") - 1) == 0)
{
continue;
}
if (NULL == array_get_element(srv->config_touched, du->key->ptr))
{
log_error_write(srv, __FILE__, __LINE__, "sbs",
"WARNING: unknown config-key:", du->key,
"(ignored)");
}
}
}
if (srv->config_unsupported)
{
log_error_write(srv, __FILE__, __LINE__, "s",
"Configuration contains unsupported keys. Going down.");
}
if (srv->config_deprecated)
{
log_error_write(srv, __FILE__, __LINE__, "s",
"Configuration contains deprecated keys. Going down.");
}
if (srv->config_unsupported || srv->config_deprecated)
{
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
//设置一些信号的处理方法。
//SIGPIPE:在写管道时，读管道的进程终止，产生此信号。
#ifdef HAVE_SIGACTION
memset(&act, 0, sizeof(act));
act.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &act, NULL);
sigaction(SIGUSR1, &act, NULL);
# if defined(SA_SIGINFO)
act.sa_sigaction = sigaction_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
# else
act.sa_handler = signal_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
# endif
sigaction(SIGINT, &act, NULL);
sigaction(SIGTERM, &act, NULL);
sigaction(SIGHUP, &act, NULL);
sigaction(SIGALRM, &act, NULL);
sigaction(SIGCHLD, &act, NULL);
#elif defined(HAVE_SIGNAL)
/*
* ignore the SIGPIPE from sendfile()
*/
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGALRM, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGHUP, signal_handler);
signal(SIGCHLD, signal_handler);
signal(SIGINT, signal_handler);
#endif
#ifdef USE_ALARM
signal(SIGALRM, signal_handler);
/*
* setup periodic timer (1 second)
* The system provides each process with three interval timers, each decrementing in a distinct time domain.
* When any timer expires a signal is sent to the process, and the timer (potentially) restarts.
*
* ITIMER_REAL decrements in real time, and delivers SIGALRM upon expiration.
* ITIMER_VIRTUAL decrements only when the process is executing, and delivers SIGVTALRM upon expiration.
* ITIMER_PROF decrements both when the process executes and when the system is executing on
* behalf of the process.
* Coupled with ITIMER_VIRTUAL, this timer is usually used to profile the time spent
* by the application in user and kernel space.
* SIGPROF is delivered upon expiration.
* Timer values are defined by the following structures:
* struct itimerval
* {
* struct timeval it_interval; //next value
* struct timeval it_value; //current value
* };
* struct timeval
* {
* long tv_sec; // seconds
* long tv_usec; //microseconds
* };
* The function getitimer() fills the structure indicated by value with the current setting for the timer
* indicated by which (one of ITIMER_REAL, ITIMER_VIRTUAL, or ITIMER_PROF). The element it_value is
* set to the amount of time remaining on the timer, or zero ifthe timer is disabled.
* Similarly, it_interval is set to the reset value. The function setitimer() sets the indicated timer to the
* value in value. If ovalue is nonzero, the old value of the timer is stored there.
*/
if (setitimer(ITIMER_REAL, &interval, NULL))
{
log_error_write(srv, __FILE__, __LINE__, "s", "setting timer failed");
return -1;
}
getitimer(ITIMER_REAL, &interval);
#endif
#ifdef HAVE_FORK
/*
* *************************
* start watcher and workers
* *************************
*
* 下面程序将产生多个子进程。这些子进程成为worker，也就是用于接受处理用户的连接的进程。而当前的主进程将
* 成为watcher，主要工作就是监视workers的工作状态，当有worker因为意外而退出时，产生新的worker。
* 在程序退出时，watcher负责停止所有的workers并清理资源。
*/
num_childs = srv->srvconf.max_worker;//最大worker数。
if (num_childs > 0)
{
int child = 0;
while (!child && !srv_shutdown && !graceful_shutdown)
{
if (num_childs > 0) //继续产生worker
{
switch (fork())
{
case -1:
return -1;
case 0:
child = 1;
break;
default:
num_childs--;
break;
}
}
else //watcher
{
/**
* 当产生了足够的worker时，watcher就在这个while中不断的循环。
* 一但发现有worker退出（进程死亡），立即产生新的worker。
* 如果发生错误并接受到SIGHUP信号，向所有的进程（父进程及其子进程）包括自己发送SIGHUP信号。
* 并退出。
*/
int status;
if (-1 != wait(&status))
{
/**
* one of our workers went away
*/
num_childs++;
}
else
{
switch (errno)
{
case EINTR:
/**
* if we receive a SIGHUP we have to close our logs ourself as we don't
* have the mainloop who can help us here
*/
if (handle_sig_hup)
{
handle_sig_hup = 0;
log_error_cycle(srv);
/**
* forward to all procs in the process-group
* 向所有进程发送SIGHUP信号。（父进程及其子进程）
* we also send it ourself
*/
if (!forwarded_sig_hup)
{
forwarded_sig_hup = 1;
kill(0, SIGHUP);
}
}
break;
default:
break;
}
}
}
}
/**
* for the parent this is the exit-point
* *****************************************************
* 父进程，也就是watcher在执行完这个if语句中就直接退出了。
* 后面是worker执行的代码。
* *****************************************************
*/
if (!child)
{
/**
* kill all children too 。杀死所有的子进程。
*/
if (graceful_shutdown)
{
kill(0, SIGINT);
}
else if (srv_shutdown)
{
kill(0, SIGTERM);
}
log_error_close(srv);
network_close(srv);
connections_free(srv);
plugins_free(srv);
server_free(srv);
return 0;
}
}
#endif
/*
* **************************
* 从这开始是worker执行的代码。
* **************************
*/
if (NULL == (srv->ev = fdevent_init(srv->max_fds + 1, srv->event_handler)))
{
log_error_write(srv, __FILE__, __LINE__, "s", "fdevent_init failed");
return -1;
}
/*
* kqueue() is called here, select resets its internals,
* all server sockets get their handlers
* 将监听socket注册到fd events系统中。
* 在注册的时候为每个socket都同时注册了一个处理函数，用来处理这个socket的IO事件。
* 对于在这次调用中注册的监听socket，注册的处理函数是：network_server_handle_fdevent。
* 这个处理函数用来建立socket连接。
* */
if (0 != network_register_fdevents(srv))
{
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
/*
* might fail if user is using fam (not gamin) and famd isn't running
* famd没有运行，则运行失败。。。
*/
if (NULL == (srv->stat_cache = stat_cache_init()))
{
log_error_write(srv, __FILE__, __LINE__, "s",
"stat-cache could not be setup, dieing.");
return -1;
}
#ifdef HAVE_FAM_H
/*
* setup FAM 设置FAM。
*/
if (srv->srvconf.stat_cache_engine == STAT_CACHE_ENGINE_FAM)
{
if (0 != FAMOpen2(srv->stat_cache->fam, "lighttpd"))
{
log_error_write(srv, __FILE__, __LINE__, "s",
"could not open a fam connection, dieing.");
return -1;
}
#ifdef HAVE_FAMNOEXISTS
FAMNoExists(srv->stat_cache->fam);
#endif
srv->stat_cache->fam_fcce_ndx = -1;
fdevent_register(srv->ev,
FAMCONNECTION_GETFD(srv->stat_cache->fam),
stat_cache_handle_fdevent, NULL);
fdevent_event_add(srv->ev, &(srv->stat_cache->fam_fcce_ndx),
FAMCONNECTION_GETFD(srv->stat_cache->fam),
FDEVENT_IN);
}
#endif
/*
* get the current number of FDs 获得当前可用的fd值
*/
srv->cur_fds = open("/dev/null", O_RDONLY);
close(srv->cur_fds);
for (i = 0; i < srv->srv_sockets.used; i++)
{
server_socket *srv_socket = srv->srv_sockets.ptr[i];
/*
* close fd on exec (cgi)
*/
if (-1 == fdevent_fcntl_set(srv->ev, srv_socket->fd))
{
log_error_write(srv, __FILE__, __LINE__, "ss", "fcntl failed:", strerror(errno));
return -1;
}
}
/*
* main-loop
* *******************
* worker工作的主循环。
* *******************
*/
while (!srv_shutdown)
{
int n;
size_t ndx;
time_t min_ts;
/**
* 收到SIGHUP信号。主要是重新开始日志的周期并提示插件。
* 这个信号表示连接已经断开，通常是做一些清理和准备工作，等待下一次的连接。
*/
if (handle_sig_hup)
{
handler_t r;
/*
* reset notification 重置
*/
handle_sig_hup = 0;
/*
* cycle logfiles
* 重新开始新一轮日志。
* 这里使用了switch而不是if语句，有意思。。。
* 调用插件关于SIGHUP信号的处理函数。
* 这个函数貌似也没实现。。。
*/
switch (r = plugins_call_handle_sighup(srv))
{
case HANDLER_GO_ON:
break;
default:
log_error_write(srv, __FILE__, __LINE__, "sd", "sighup-handler return with an error", r);
break;
}
if (-1 == log_error_cycle(srv))
{
log_error_write(srv, __FILE__, __LINE__, "s", "cycling errorlog failed, dying");
return -1;
}
else
{
#ifdef HAVE_SIGACTION
log_error_write(srv, __FILE__, __LINE__, "sdsd", "logfiles cycled UID =",
last_sighup_info.si_uid, "PID =", last_sighup_info.si_pid);
#else
log_error_write(srv, __FILE__, __LINE__, "s", "logfiles cycled");
#endif
}
}
/**
* alarm函数发出的信号，表示一秒钟已经过去了。
*/
if (handle_sig_alarm)
{
/*
* a new second 新的一秒开始了。。。
*/
#ifdef USE_ALARM
/*
* reset notification 重置
*/
handle_sig_alarm = 0;
#endif
/*
* get current time 当前时间。精确到一秒
*/
min_ts = time(NULL);
/**
* 这里判断和服务器记录的当前时间是否相同。
* 相同，则表示服务器还在这一秒中，继续处理请求等。
* 如果不相同，则进入了一个新的周期（当然周期是一秒）。这就要做一些触发和检查以及清理的动作。
* 如插件的触发连接的超时清理状态缓存等。
* 其中，最主要的工作是检查连接的超时。
*/
if (min_ts != srv->cur_ts)
{
int cs = 0;
connections *conns = srv->conns;
handler_t r;
switch (r = plugins_call_handle_trigger(srv))
{
case HANDLER_GO_ON:
break;
case HANDLER_ERROR:
log_error_write(srv, __FILE__, __LINE__, "s", "one of the triggers failed");
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
/*
* trigger waitpid 么意思？？
*/
srv->cur_ts = min_ts;
/*
* cleanup stat-cache 清理状态缓存。每秒钟清理一次。
*/
stat_cache_trigger_cleanup(srv);
/**
* check all connections for timeouts 检查所有的连接是否超时。
*/
for (ndx = 0; ndx < conns->used; ndx++)
{
int changed = 0;
connection *con;
int t_diff;
con = conns->ptr[ndx];
//连接的状态是在读
if (con->state == CON_STATE_READ || con->state == CON_STATE_READ_POST)
{
if (con->request_count == 1) //连接正在处理一个请求
{
if (srv->cur_ts - con->read_idle_ts > con->conf.max_read_idle)
{
/*
* time - out
*/
#if 0
log_error_write(srv, __FILE__, __LINE__, "sd",
"connection closed - read-timeout:", con->fd);
#endif
connection_set_state(srv, con, CON_STATE_ERROR);
changed = 1;
}
} //这个连接同时处理多个请求
else
{
if (srv->cur_ts - con->read_idle_ts > con->conf.max_keep_alive_idle)
{
/*
* time - out
*/
#if 0
log_error_write(srv, __FILE__, __LINE__, "sd",
"connection closed - read-timeout:", con->fd);
#endif
connection_set_state(srv, con, CON_STATE_ERROR);
changed = 1;
}
}
}
//连接的状态是写
if ((con->state == CON_STATE_WRITE) && (con->write_request_ts != 0))
{
#if 0
if (srv->cur_ts - con->write_request_ts > 60)
{
log_error_write(srv, __FILE__, __LINE__, "sdd",
"connection closed - pre-write-request-timeout:",
con->fd, srv->cur_ts - con->write_request_ts);
}
#endif
if (srv->cur_ts - con->write_request_ts > con->conf.max_write_idle)
{
/*
* time - out
*/
#if 1
log_error_write(srv, __FILE__, __LINE__, "sbsosds", "NOTE: a request for",
con->request.uri, "timed out after writing", con->bytes_written, "bytes. We waited",
(int) con->conf. max_write_idle,
"seconds. If this a problem increase server.max-write-idle");
#endif
connection_set_state(srv, con, CON_STATE_ERROR);
changed = 1;
}
}
/*
* we don't like div by zero 防止除0。。。
*/
if (0 == (t_diff = srv->cur_ts - con->connection_start))
t_diff = 1;
/**
* 下面的if语句不是用来判断连接是否超时。
* lighttpd对每个连接设置了一个kbytes_per_second，这个变量设定每个连接在一秒钟内多能传输的最大数据量。
* 如果传送的数据大于这个值，那么这个连接将停止传输数据，被追加到作业队列中等待下一次处理。
* 作者这样做估计是为了平衡各个连接之间的数据传输。
*/
if (con->traffic_limit_reached &&
(con->conf.kbytes_per_second == 0
|| ((con->bytes_written / t_diff) < con->conf.kbytes_per_second * 1024)))
{
/*
* enable connection again
*/
con->traffic_limit_reached = 0;
changed = 1;
}
if (changed)
{
connection_state_machine(srv, con);
}
con->bytes_written_cur_second = 0;
*(con->conf.global_bytes_per_second_cnt_ptr) = 0;
#if 0
if (cs == 0)
{
fprintf(stderr, "connection-state: ");
cs = 1;
}
fprintf(stderr, "c[%d,%d]: %s ", con->fd, con->fcgi.fd, connection_get_state(con->state));
#endif
}//end of for( ndx = 0; ...
if (cs == 1)
fprintf(stderr, "\n");
}//end of if (min_ts != srv->cur_ts)...
}//end of if (handle_sig_alarm)...
if (srv->sockets_disabled)
{
/*
* our server sockets are disabled, why ?
* 服务器socket连接失效。为什么捏？？？后面的服务器过载处理中。。。
*
* 将所有连接重新加入的fdevent中。
*/
if ((srv->cur_fds + srv->want_fds < srv->max_fds * 0.8) && /* we have enough unused fds */
(srv->conns->used < srv->max_conns * 0.9) && (0 == graceful_shutdown))
{
for (i = 0; i < srv->srv_sockets.used; i++)
{
server_socket *srv_socket = srv->srv_sockets.ptr[i];
fdevent_event_add(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd, FDEVENT_IN);
}
log_error_write(srv, __FILE__, __LINE__, "s", "[note] sockets enabled again");
srv->sockets_disabled = 0;
}
}
else
{
/*
* 下面处理服务器过载的情况。
*/
if ((srv->cur_fds + srv->want_fds > srv->max_fds * 0.9) || /* out of fds */
(srv->conns->used > srv->max_conns) || /* out of connections */
(graceful_shutdown)) /* graceful_shutdown */
{
/*
* disable server-fds 关闭所有的服务socket
*/
for (i = 0; i < srv->srv_sockets.used; i++)
{
server_socket *srv_socket = srv->srv_sockets.ptr[i];
fdevent_event_del(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd);
if (graceful_shutdown)
{
/*
* we don't want this socket anymore, closing it right
* away will make it possible for the next lighttpd to
* take over (graceful restart)
*/
fdevent_unregister(srv->ev, srv_socket->fd);
close(srv_socket->fd);
srv_socket->fd = -1;
/*
* network_close() will cleanup after us
*/
if (srv->srvconf.pid_file->used && srv->srvconf.changeroot->used == 0)
{
if (0 != unlink(srv->srvconf.pid_file->ptr))
{
if (errno != EACCES && errno != EPERM)
{
log_error_write(srv, __FILE__, __LINE__, "sbds", "unlink failed for:",
srv -> srvconf.pid_file, errno, strerror(errno));
}
}
}
}
}//end of for(i = 0; ...
if (graceful_shutdown)
{
log_error_write(srv, __FILE__, __LINE__, "s", "[note] graceful shutdown started");
}
else if (srv->conns->used > srv->max_conns)
{
log_error_write(srv, __FILE__, __LINE__, "s","[note] sockets disabled, connection limit reached");
}
else
{
log_error_write(srv, __FILE__, __LINE__, "s", "[note] sockets disabled, out-of-fds");
}
srv->sockets_disabled = 1; //服务器过载了，socket失效。
}
}
if (graceful_shutdown && srv->conns->used == 0)
{
/*
* we are in graceful shutdown phase and all connections are closed
* we are ready to terminate without harming anyone
*/
srv_shutdown = 1;
}
/*
* we still have some fds to share
*/
if (srv->want_fds)
{
/*
* check the fdwaitqueue for waiting fds
*/
int free_fds = srv->max_fds - srv->cur_fds - 16;
connection *con;
for (; free_fds > 0 && NULL != (con = fdwaitqueue_unshift(srv, srv->fdwaitqueue)); free_fds--)
{
connection_state_machine(srv, con);
srv->want_fds--;
}
}
/**
**********************************************************
* 至此，上面那些杂七杂八的事全部处理结束。下面，干正事！！
* 也就是处理服务请求。
**********************************************************
*/
//启动事件轮询。底层使用的是IO多路转接。
if ((n = fdevent_poll(srv->ev, 1000)) > 0)
{
/*
* n is the number of events n是事件的数量（服务请求啦，文件读写啦什么的。。。）
*/
int revents;
int fd_ndx;
#if 0
if (n > 0)
{
log_error_write(srv, __FILE__, __LINE__, "sd", "polls:", n);
}
#endif
fd_ndx = -1;
/**
* 这个循环中逐个的处理已经准备好的请求，知道所有的请求处理结束。
*/
do
{
fdevent_handler handler;
void *context;
handler_t r;
fd_ndx = fdevent_event_next_fdndx(srv->ev, fd_ndx);
revents = fdevent_event_get_revent(srv->ev, fd_ndx);
fd = fdevent_event_get_fd(srv->ev, fd_ndx);
handler = fdevent_get_handler(srv->ev, fd);
context = fdevent_get_context(srv->ev, fd);
/*
* connection_handle_fdevent needs a joblist_append
*/
#if 0
log_error_write(srv, __FILE__, __LINE__, "sdd",
"event for", fd, revents);
#endif
/**
* 这里，调用请求的处理函数handler处理请求！
* 这才是重点中的重点！！
*/
switch (r = (*handler) (srv, context, revents))
{
case HANDLER_FINISHED:
case HANDLER_GO_ON:
case HANDLER_WAIT_FOR_EVENT:
case HANDLER_WAIT_FOR_FD:
break;
case HANDLER_ERROR:
/*
* should never happen
*/
SEGFAULT();
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
}while (--n > 0);
//到这里，本次的请求都处理结束了。。。累啊！
}
else if (n < 0 && errno != EINTR)
{
log_error_write(srv, __FILE__, __LINE__, "ss", "fdevent_poll failed:", strerror(errno));
}
//由于上面处理的都是发生了IO事件的描述符，这些描述符的状态都被正确的设置了。
//对于没有发生IO事件的描述符，其状态机的状态也需要设置，
//下面的循环就是对剩下的描述符进行处理。
for (ndx = 0; ndx < srv->joblist->used; ndx++)
{
connection *con = srv->joblist->ptr[ndx];
handler_t r;
connection_state_machine(srv, con);
switch (r = plugins_call_handle_joblist(srv, con))
{
case HANDLER_FINISHED:
case HANDLER_GO_ON:
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
con->in_joblist = 0;
}
srv->joblist->used = 0;
} /* end of main loop */
/*
* 主循环的结束
*/
if (srv->srvconf.pid_file->used && srv->srvconf.changeroot->used == 0 && 0 == graceful_shutdown)
{
if (0 != unlink(srv->srvconf.pid_file->ptr))
{
if (errno != EACCES && errno != EPERM)
{
log_error_write(srv, __FILE__, __LINE__, "sbds", "unlink failed for:",
srv->srvconf.pid_file, errno, strerror(errno));
}
}
}
#ifdef HAVE_SIGACTION
log_error_write(srv, __FILE__, __LINE__, "sdsd", "server stopped by UID =",
last_sigterm_info.si_uid,"PID =", last_sigterm_info.si_pid);
#else
log_error_write(srv, __FILE__, __LINE__, "s", "server stopped");
#endif
/*
* clean-up
*/
log_error_close(srv);
network_close(srv);
connections_free(srv);
plugins_free(srv);
server_free(srv);
return 0;
}
Time* Time::from_array(STATE, Object* self,
Fixnum* sec, Fixnum* min, Fixnum* hour,
Fixnum* mday, Fixnum* mon, Fixnum* year, Fixnum* usec,
Fixnum* isdst, Object* from_gmt) {
struct tm tm;
tm.tm_sec = sec->to_native();
if(tm.tm_sec < 0 || tm.tm_sec > 60) {
Exception::argument_error(state, "sec must be in 0..60");
}
tm.tm_min = min->to_native();
if(tm.tm_min < 0 || tm.tm_min > 60) {
Exception::argument_error(state, "min must be in 0..60");
}
tm.tm_hour = hour->to_native();
if(tm.tm_hour < 0 || tm.tm_hour > 24) {
Exception::argument_error(state, "hour must be in 0..24");
}
tm.tm_mday = mday->to_native();
if(tm.tm_mday < 1 || tm.tm_mday > 31) {
Exception::argument_error(state, "mday must be in 1..31");
}
tm.tm_mon = mon->to_native() - 1;
if(tm.tm_mon < 0 || tm.tm_mon > 11) {
Exception::argument_error(state, "mon must be in 0..11");
}
tm.tm_wday = -1;
#ifdef HAVE_TM_GMTOFF
tm.tm_gmtoff = 0;
#endif
#ifdef HAVE_TM_ZONE
tm.tm_zone = 0;
#endif
tm.tm_year = year->to_native() - 1900;
tm.tm_isdst = isdst->to_native();
time_t seconds = -1;
if(RTEST(from_gmt)) {
seconds = ::timegm(&tm);
} else {
tzset();
seconds = ::mktime(&tm);
}
int err = 0;
if(seconds == -1) {
int utc_p = from_gmt->true_p() ? 1 : 0;
seconds = mktime_extended(&tm, utc_p, &err);
}
if(err) return (Time*)Primitives::failure();
Time* obj = state->new_object<Time>(as<Class>(self));
obj->seconds_ = seconds;
obj->microseconds_ = usec->to_native();
obj->is_gmt(state, RTEST(from_gmt) ? Qtrue : Qfalse);
return obj;
}
void
ns_os_tzset(void) {
#ifdef HAVE_TZSET
tzset();
#endif
}
int
main( int argc, char** argv )
{
char* cp;
struct passwd* pwd;
uid_t uid;
gid_t gid;
char cwd[MAXPATHLEN];
FILE* logfp;
int num_ready;
int cnum, ridx;
connecttab* c;
httpd_conn* hc;
httpd_sockaddr sa4;
httpd_sockaddr sa6;
int gotv4, gotv6;
struct timeval tv;
argv0 = argv[0];
cp = strrchr( argv0, '/' );
if ( cp != (char*) 0 )
++cp;
else
cp = argv0;
openlog( cp, LOG_NDELAY|LOG_PID, LOG_FACILITY );
/* Handle command-line arguments. */
parse_args( argc, argv );
/* Check port number. */
if ( port <= 0 )
{
syslog( LOG_CRIT, "illegal port number" );
(void) fprintf( stderr, "%s: illegal port number\n", argv0 );
exit( 1 );
}
/* Read zone info now, in case we chroot(). */
tzset();
/* Look up hostname now, in case we chroot(). */
lookup_hostname( &sa4, sizeof(sa4), &gotv4, &sa6, sizeof(sa6), &gotv6 );
if ( ! ( gotv4 || gotv6 ) )
{
syslog( LOG_ERR, "can't find any valid address" );
(void) fprintf( stderr, "%s: can't find any valid address\n", argv0 );
exit( 1 );
}
/* Throttle file. */
numthrottles = 0;
maxthrottles = 0;
throttles = (throttletab*) 0;
if ( throttlefile != (char*) 0 )
read_throttlefile( throttlefile );
/* Log file. */
if ( logfile != (char*) 0 )
{
if ( strcmp( logfile, "/dev/null" ) == 0 )
{
no_log = 1;
logfp = (FILE*) 0;
}
else
{
logfp = fopen( logfile, "a" );
if ( logfp == (FILE*) 0 )
{
syslog( LOG_CRIT, "%.80s - %m", logfile );
perror( logfile );
exit( 1 );
}
(void) fcntl( fileno( logfp ), F_SETFD, 1 );
}
}
else
logfp = (FILE*) 0;
/* Figure out uid/gid from user. */
pwd = getpwnam( user );
if ( pwd == (struct passwd*) 0 )
{
syslog( LOG_CRIT, "unknown user - '%.80s'", user );
(void) fprintf( stderr, "%s: unknown user - '%s'\n", argv0, user );
exit( 1 );
}
uid = pwd->pw_uid;
gid = pwd->pw_gid;
/* Switch directories if requested. */
if ( dir != (char*) 0 )
{
if ( chdir( dir ) < 0 )
{
syslog( LOG_CRIT, "chdir - %m" );
perror( "chdir" );
exit( 1 );
}
}
#ifdef USE_USER_DIR
else if ( getuid() == 0 )
{
/* No explicit directory was specified, we're root, and the
** USE_USER_DIR option is set - switch to the specified user's
** home dir.
*/
if ( chdir( pwd->pw_dir ) < 0 )
{
syslog( LOG_CRIT, "chdir - %m" );
perror( "chdir" );
exit( 1 );
}
}
#endif /* USE_USER_DIR */
/* Get current directory. */
(void) getcwd( cwd, sizeof(cwd) - 1 );
if ( cwd[strlen( cwd ) - 1] != '/' )
(void) strcat( cwd, "/" );
if ( ! debug )
{
/* We're not going to use stdin stdout or stderr from here on, so close
** them to save file descriptors.
*/
(void) fclose( stdin );
(void) fclose( stdout );
(void) fclose( stderr );
/* Daemonize - make ourselves a subprocess. */
#ifdef HAVE_DAEMON
if ( daemon( 1, 1 ) < 0 )
{
syslog( LOG_CRIT, "daemon - %m" );
exit( 1 );
}
#else /* HAVE_DAEMON */
switch ( fork() )
{
case 0:
break;
case -1:
syslog( LOG_CRIT, "fork - %m" );
exit( 1 );
default:
exit( 0 );
}
#ifdef HAVE_SETSID
(void) setsid();
#endif /* HAVE_SETSID */
#endif /* HAVE_DAEMON */
}
else
{
/* Even if we don't daemonize, we still want to disown our parent
** process.
*/
#ifdef HAVE_SETSID
(void) setsid();
#endif /* HAVE_SETSID */
}
if ( pidfile != (char*) 0 )
{
/* Write the PID file. */
FILE* pidfp = fopen( pidfile, "w" );
if ( pidfp == (FILE*) 0 )
{
syslog( LOG_CRIT, "%.80s - %m", pidfile );
exit( 1 );
}
(void) fprintf( pidfp, "%d\n", (int) getpid() );
(void) fclose( pidfp );
}
/* Chroot if requested. */
if ( do_chroot )
{
if ( chroot( cwd ) < 0 )
{
syslog( LOG_CRIT, "chroot - %m" );
perror( "chroot" );
exit( 1 );
}
(void) strcpy( cwd, "/" );
/* Always chdir to / after a chroot. */
if ( chdir( cwd ) < 0 )
{
syslog( LOG_CRIT, "chroot chdir - %m" );
perror( "chroot chdir" );
exit( 1 );
}
}
/* Set up to catch signals. */
(void) signal( SIGTERM, handle_term );
(void) signal( SIGINT, handle_term );
(void) signal( SIGPIPE, SIG_IGN ); /* get EPIPE instead */
(void) signal( SIGHUP, handle_hup );
got_usr1 = 0;
(void) signal( SIGUSR1, handle_usr1 );
(void) signal( SIGUSR2, handle_usr2 );
/* Initialize the timer package. */
tmr_init();
/* Initialize the HTTP layer. Got to do this before giving up root,
** so that we can bind to a privileged port.
*/
hs = httpd_initialize(
hostname,
gotv4 ? &sa4 : (httpd_sockaddr*) 0, gotv6 ? &sa6 : (httpd_sockaddr*) 0,
port, cgi_pattern, charset, cwd, no_log, logfp, no_symlink, do_vhost,
do_global_passwd, url_pattern, local_pattern, no_empty_referers );
if ( hs == (httpd_server*) 0 )
exit( 1 );
/* Set up the occasional timer. */
if ( tmr_create( (struct timeval*) 0, occasional, JunkClientData, OCCASIONAL_TIME * 1000L, 1 ) == (Timer*) 0 )
{
syslog( LOG_CRIT, "tmr_create(occasional) failed" );
exit( 1 );
}
if ( numthrottles > 0 )
{
/* Set up the throttles timer. */
if ( tmr_create( (struct timeval*) 0, update_throttles, JunkClientData, THROTTLE_TIME * 1000L, 1 ) == (Timer*) 0 )
{
syslog( LOG_CRIT, "tmr_create(update_throttles) failed" );
exit( 1 );
}
}
#ifdef STATS_TIME
/* Set up the stats timer. */
if ( tmr_create( (struct timeval*) 0, show_stats, JunkClientData, STATS_TIME * 1000L, 1 ) == (Timer*) 0 )
{
syslog( LOG_CRIT, "tmr_create(show_stats) failed" );
exit( 1 );
}
#endif /* STATS_TIME */
start_time = stats_time = time( (time_t*) 0 );
stats_connections = stats_bytes = 0L;
stats_simultaneous = 0;
/* If we're root, try to become someone else. */
if ( getuid() == 0 )
{
/* Set aux groups to null. */
if ( setgroups( 0, (const gid_t*) 0 ) < 0 )
{
syslog( LOG_CRIT, "setgroups - %m" );
exit( 1 );
}
/* Set primary group. */
if ( setgid( gid ) < 0 )
{
syslog( LOG_CRIT, "setgid - %m" );
exit( 1 );
}
/* Try setting aux groups correctly - not critical if this fails. */
if ( initgroups( user, gid ) < 0 )
syslog( LOG_WARNING, "initgroups - %m" );
#ifdef HAVE_SETLOGIN
/* Set login name. */
(void) setlogin( user );
#endif /* HAVE_SETLOGIN */
/* Set uid. */
if ( setuid( uid ) < 0 )
{
syslog( LOG_CRIT, "setuid - %m" );
exit( 1 );
}
/* Check for unnecessary security exposure. */
if ( ! do_chroot )
syslog(
LOG_CRIT,
"started as root without requesting chroot(), warning only" );
}
/* Initialize our connections table. */
maxconnects = fdwatch_get_nfiles();
if ( maxconnects < 0 )
{
syslog( LOG_CRIT, "fdwatch initialization failure" );
exit( 1 );
}
maxconnects -= SPARE_FDS;
connects = NEW( connecttab, maxconnects );
if ( connects == (connecttab*) 0 )
{
syslog( LOG_CRIT, "out of memory allocating a connecttab" );
exit( 1 );
}
for ( cnum = 0; cnum < maxconnects; ++cnum )
{
connects[cnum].conn_state = CNST_FREE;
connects[cnum].hc = (httpd_conn*) 0;
}
numconnects = 0;
httpd_conn_count = 0;
if ( hs != (httpd_server*) 0 )
{
if ( hs->listen4_fd != -1 )
fdwatch_add_fd( hs->listen4_fd, (void*) 0, FDW_READ );
if ( hs->listen6_fd != -1 )
fdwatch_add_fd( hs->listen6_fd, (void*) 0, FDW_READ );
}
/* Main loop. */
(void) gettimeofday( &tv, (struct timezone*) 0 );
while ( ( ! terminate ) || numconnects > 0 )
{
/* Do the fd watch. */
num_ready = fdwatch( tmr_mstimeout( &tv ) );
if ( num_ready < 0 )
{
if ( errno == EINTR )
continue; /* try again */
syslog( LOG_ERR, "fdwatch - %m" );
exit( 1 );
}
(void) gettimeofday( &tv, (struct timezone*) 0 );
if ( num_ready == 0 )
{
/* No fd's are ready - run the timers. */
tmr_run( &tv );
continue;
}
/* Is it a new connection? */
if ( hs != (httpd_server*) 0 && hs->listen6_fd != -1 &&
fdwatch_check_fd( hs->listen6_fd ) )
{
if ( handle_newconnect( &tv, hs->listen6_fd ) )
/* Go around the loop and do another fdwatch, rather than
** dropping through and processing existing connections.
** New connections always get priority.
*/
continue;
}
if ( hs != (httpd_server*) 0 && hs->listen4_fd != -1 &&
fdwatch_check_fd( hs->listen4_fd ) )
{
if ( handle_newconnect( &tv, hs->listen4_fd ) )
/* Go around the loop and do another fdwatch, rather than
** dropping through and processing existing connections.
** New connections always get priority.
*/
continue;
}
/* Find the connections that need servicing. */
for ( ridx = 0; ridx < num_ready; ++ridx )
{
c = (connecttab*) fdwatch_get_client_data( ridx );
if ( c == (connecttab*) 0 )
continue;
hc = c->hc;
if ( c->conn_state == CNST_READING &&
fdwatch_check_fd( hc->conn_fd ) )
handle_read( c, &tv );
else if ( c->conn_state == CNST_SENDING &&
fdwatch_check_fd( hc->conn_fd ) )
handle_send( c, &tv );
else if ( c->conn_state == CNST_LINGERING &&
fdwatch_check_fd( hc->conn_fd ) )
handle_linger( c, &tv );
}
tmr_run( &tv );
if ( got_usr1 && ! terminate )
{
terminate = 1;
if ( hs != (httpd_server*) 0 )
{
httpd_terminate( hs );
hs = (httpd_server*) 0;
}
}
}
/* The main loop terminated. */
shut_down();
syslog( LOG_NOTICE, "exiting" );
closelog();
exit( 0 );
}
int
main(int argc, char *argv[])
{
struct tm local;
struct timeval tv, *stv;
struct timezone tz, *stz;
int kern_offset, wall_clock, disrtcset;
size_t len;
/* Avoid time_t here, can be unsigned long or worse */
long offset, localsec, diff;
time_t initial_sec, final_sec;
int ch;
int initial_isdst = -1, final_isdst;
int need_restore = False, sleep_mode = False, looping,
init = Unknown;
sigset_t mask, emask;
while ((ch = getopt(argc, argv, "ais")) != -1)
switch((char)ch) {
case 'i': /* initial call, save offset */
if (init != Unknown)
usage();
init = True;
break;
case 'a': /* adjustment call, use saved offset */
if (init != Unknown)
usage();
init = False;
break;
case 's':
sleep_mode = True;
break;
default:
usage();
}
if (init == Unknown)
usage();
if (access(_PATH_CLOCK, F_OK) != 0)
return 0;
if (init)
sleep_mode = True;
sigemptyset(&mask);
sigemptyset(&emask);
sigaddset(&mask, SIGTERM);
openlog("adjkerntz", LOG_PID|LOG_PERROR, LOG_DAEMON);
(void) signal(SIGHUP, SIG_IGN);
if (init && daemon(0,
#ifdef DEBUG
1
#else
0
#endif
)) {
syslog(LOG_ERR, "daemon: %m");
return 1;
}
again:
(void) sigprocmask(SIG_BLOCK, &mask, NULL);
(void) signal(SIGTERM, fake);
diff = 0;
stv = NULL;
stz = NULL;
looping = False;
wall_clock = (access(_PATH_CLOCK, F_OK) == 0);
if (init && !sleep_mode) {
init = False;
if (!wall_clock)
return 0;
}
tzset();
len = sizeof(kern_offset);
if (sysctlbyname("machdep.adjkerntz", &kern_offset, &len, NULL, 0) == -1) {
syslog(LOG_ERR, "sysctl(\"machdep.adjkerntz\"): %m");
return 1;
}
/****** Critical section, do all things as fast as possible ******/
/* get local CMOS clock and possible kernel offset */
if (gettimeofday(&tv, &tz)) {
syslog(LOG_ERR, "gettimeofday: %m");
return 1;
}
/* get the actual local timezone difference */
initial_sec = tv.tv_sec;
recalculate:
local = *localtime(&initial_sec);
if (diff == 0)
initial_isdst = local.tm_isdst;
local.tm_isdst = initial_isdst;
/* calculate local CMOS diff from GMT */
localsec = mktime(&local);
if (localsec == -1) {
/*
* XXX user can only control local time, and it is
* unacceptable to fail here for init. 2:30 am in the
* middle of the nonexistent hour means 3:30 am.
*/
if (!sleep_mode) {
syslog(LOG_WARNING,
"Warning: nonexistent local time, try to run later.");
syslog(LOG_WARNING, "Giving up.");
return 1;
}
syslog(LOG_WARNING,
"Warning: nonexistent local time.");
syslog(LOG_WARNING, "Will retry after %d minutes.",
REPORT_PERIOD / 60);
(void) signal(SIGTERM, SIG_DFL);
(void) sigprocmask(SIG_UNBLOCK, &mask, NULL);
(void) sleep(REPORT_PERIOD);
goto again;
}
offset = -local.tm_gmtoff;
#ifdef DEBUG
fprintf(stderr, "Initial offset: %ld secs\n", offset);
#endif
/* correct the kerneltime for this diffs */
/* subtract kernel offset, if present, old offset too */
diff = offset - tz.tz_minuteswest * 60 - kern_offset;
if (diff != 0) {
#ifdef DEBUG
fprintf(stderr, "Initial diff: %ld secs\n", diff);
#endif
/* Yet one step for final time */
final_sec = initial_sec + diff;
/* get the actual local timezone difference */
local = *localtime(&final_sec);
final_isdst = diff < 0 ? initial_isdst : local.tm_isdst;
if (diff > 0 && initial_isdst != final_isdst) {
if (looping)
goto bad_final;
looping = True;
initial_isdst = final_isdst;
goto recalculate;
}
local.tm_isdst = final_isdst;
localsec = mktime(&local);
if (localsec == -1) {
bad_final:
/*
* XXX as above. The user has even less control,
* but perhaps we never get here.
*/
if (!sleep_mode) {
syslog(LOG_WARNING,
"Warning: nonexistent final local time, try to run later.");
syslog(LOG_WARNING, "Giving up.");
return 1;
}
syslog(LOG_WARNING,
"Warning: nonexistent final local time.");
syslog(LOG_WARNING, "Will retry after %d minutes.",
REPORT_PERIOD / 60);
(void) signal(SIGTERM, SIG_DFL);
(void) sigprocmask(SIG_UNBLOCK, &mask, NULL);
(void) sleep(REPORT_PERIOD);
goto again;
}
offset = -local.tm_gmtoff;
#ifdef DEBUG
fprintf(stderr, "Final offset: %ld secs\n", offset);
#endif
/* correct the kerneltime for this diffs */
/* subtract kernel offset, if present, old offset too */
diff = offset - tz.tz_minuteswest * 60 - kern_offset;
if (diff != 0) {
#ifdef DEBUG
fprintf(stderr, "Final diff: %ld secs\n", diff);
#endif
/*
* stv is abused as a flag. The important value
* is in `diff'.
*/
stv = &tv;
}
}
if (tz.tz_dsttime != 0 || tz.tz_minuteswest != 0) {
tz.tz_dsttime = tz.tz_minuteswest = 0; /* zone info is garbage */
stz = &tz;
}
if (!wall_clock && stz == NULL)
stv = NULL;
/* if init or UTC clock and offset/date will be changed, */
/* disable RTC modification for a while. */
if ( (init && stv != NULL)
|| ((init || !wall_clock) && kern_offset != offset)
) {
len = sizeof(disrtcset);
if (sysctlbyname("machdep.disable_rtc_set", &disrtcset, &len, NULL, 0) == -1) {
syslog(LOG_ERR, "sysctl(get: \"machdep.disable_rtc_set\"): %m");
return 1;
}
if (disrtcset == 0) {
disrtcset = 1;
need_restore = True;
if (sysctlbyname("machdep.disable_rtc_set", NULL, NULL, &disrtcset, len) == -1) {
syslog(LOG_ERR, "sysctl(set: \"machdep.disable_rtc_set\"): %m");
return 1;
}
}
}
if ( (init && (stv != NULL || stz != NULL))
|| (stz != NULL && stv == NULL)
) {
if (stv != NULL) {
/*
* Get the time again, as close as possible to
* adjusting it, to minimise drift.
* XXX we'd better not fail between here and
* restoring disrtcset, since we don't clean up
* anything.
*/
if (gettimeofday(&tv, (struct timezone *)NULL)) {
syslog(LOG_ERR, "gettimeofday: %m");
return 1;
}
tv.tv_sec += diff;
stv = &tv;
}
if (settimeofday(stv, stz)) {
syslog(LOG_ERR, "settimeofday: %m");
return 1;
}
}
/* setting machdep.adjkerntz have a side effect: resettodr(), which */
/* can be disabled by machdep.disable_rtc_set, so if init or UTC clock */
/* -- don't write RTC, else write RTC. */
if (kern_offset != offset) {
kern_offset = offset;
len = sizeof(kern_offset);
if (sysctlbyname("machdep.adjkerntz", NULL, NULL, &kern_offset, len) == -1) {
syslog(LOG_ERR, "sysctl(set: \"machdep.adjkerntz\"): %m");
return 1;
}
}
len = sizeof(wall_clock);
if (sysctlbyname("machdep.wall_cmos_clock", NULL, NULL, &wall_clock, len) == -1) {
syslog(LOG_ERR, "sysctl(set: \"machdep.wall_cmos_clock\"): %m");
return 1;
}
if (need_restore) {
need_restore = False;
disrtcset = 0;
len = sizeof(disrtcset);
if (sysctlbyname("machdep.disable_rtc_set", NULL, NULL, &disrtcset, len) == -1) {
syslog(LOG_ERR, "sysctl(set: \"machdep.disable_rtc_set\"): %m");
return 1;
}
}
/****** End of critical section ******/
if (init && wall_clock) {
sleep_mode = False;
/* wait for signals and acts like -a */
(void) sigsuspend(&emask);
goto again;
}
return 0;
}
int
main (int argc, char *argv[], char **envp)
{
int index;
set_program_name (argv[0]);
#ifdef HAVE_TZSET
tzset (); /* In case no timezone database in ~ftp. */
#endif
#ifdef HAVE_INITSETPROCTITLE
/* Save start and extent of argv for setproctitle. */
initsetproctitle (argc, argv, envp);
#endif /* HAVE_INITSETPROCTITLE */
/* Parse the command line */
iu_argp_init ("ftpd", default_program_authors);
argp_parse (&argp, argc, argv, 0, &index, NULL);
/* Bail out, wrong usage */
argc -= index;
if (argc != 0)
error (1, 0, "surplus arguments; try `%s --help' for more info",
program_name);
/* LOG_NDELAY sets up the logging connection immediately,
necessary for anonymous ftp's that chroot and can't do it later. */
openlog ("ftpd", LOG_PID | LOG_NDELAY, LOG_FTP);
freopen (PATH_DEVNULL, "w", stderr);
/* If not running via inetd, we detach and dup(fd, 0), dup(fd, 1) the
fd = accept(). tcpd is check if compile with the support */
if (daemon_mode)
{
if (server_mode (pid_file, &his_addr) < 0)
exit (1);
}
else
{
socklen_t addrlen = sizeof (his_addr);
if (getpeername (STDIN_FILENO, (struct sockaddr *) &his_addr,
&addrlen) < 0)
{
syslog (LOG_ERR, "getpeername (%s): %m", program_name);
exit (1);
}
}
signal (SIGHUP, sigquit);
signal (SIGINT, sigquit);
signal (SIGQUIT, sigquit);
signal (SIGTERM, sigquit);
signal (SIGPIPE, lostconn);
signal (SIGCHLD, SIG_IGN);
if (signal (SIGURG, myoob) == SIG_ERR)
syslog (LOG_ERR, "signal: %m");
/* Get info on the ctrl connection. */
{
socklen_t addrlen = sizeof (ctrl_addr);
if (getsockname (STDIN_FILENO, (struct sockaddr *) &ctrl_addr,
&addrlen) < 0)
{
syslog (LOG_ERR, "getsockname (%s): %m", program_name);
exit (1);
}
}
#if defined (IP_TOS) && defined (IPTOS_LOWDELAY) && defined (IPPROTO_IP)
/* To minimize delays for interactive traffic. */
{
int tos = IPTOS_LOWDELAY;
if (setsockopt (STDIN_FILENO, IPPROTO_IP, IP_TOS,
(char *) &tos, sizeof (int)) < 0)
syslog (LOG_WARNING, "setsockopt (IP_TOS): %m");
}
#endif
#ifdef SO_OOBINLINE
/* Try to handle urgent data inline. */
{
int on = 1;
if (setsockopt (STDIN_FILENO, SOL_SOCKET, SO_OOBINLINE,
(char *) &on, sizeof (on)) < 0)
syslog (LOG_ERR, "setsockopt: %m");
}
#endif
#ifdef SO_KEEPALIVE
/* Set keepalives on the socket to detect dropped connections. */
{
int keepalive = 1;
if (setsockopt (STDIN_FILENO, SOL_SOCKET, SO_KEEPALIVE,
(char *) &keepalive, sizeof (keepalive)) < 0)
syslog (LOG_WARNING, "setsockopt (SO_KEEPALIVE): %m");
}
#endif
#ifdef F_SETOWN
if (fcntl (STDIN_FILENO, F_SETOWN, getpid ()) == -1)
syslog (LOG_ERR, "fcntl F_SETOWN: %m");
#endif
dolog (&his_addr, &cred);
/* Deal with login disable. */
if (display_file (PATH_NOLOGIN, 530) == 0)
{
reply (530, "System not available.");
exit (0);
}
/* Display a Welcome message if exists,
N.B. reply(220,) must follow. */
display_file (PATH_FTPWELCOME, 220);
hostname = localhost ();
if (!hostname)
perror_reply (550, "Local resource failure: malloc");
/* Tell them we're ready to roll. */
if (!no_version)
reply (220, "%s FTP server (%s %s) ready.",
hostname, PACKAGE_NAME, PACKAGE_VERSION);
else
reply (220, "%s FTP server ready.", hostname);
/* Set the jump, if we have an error parsing,
come here and start fresh. */
setjmp (errcatch);
/* Roll. */
for (;;)
yyparse ();
}
static void
PyInit_timezone(PyObject *m) {
/* This code moved from PyInit_time wholesale to allow calling it from
time_tzset. In the future, some parts of it can be moved back
(for platforms that don't HAVE_WORKING_TZSET, when we know what they
are), and the extraneous calls to tzset(3) should be removed.
I haven't done this yet, as I don't want to change this code as
little as possible when introducing the time.tzset and time.tzsetwall
methods. This should simply be a method of doing the following once,
at the top of this function and removing the call to tzset() from
time_tzset():
#ifdef HAVE_TZSET
tzset()
#endif
And I'm lazy and hate C so nyer.
*/
#if defined(HAVE_TZNAME) && !defined(__GLIBC__) && !defined(__CYGWIN__)
PyObject *otz0, *otz1;
tzset();
#ifdef PYOS_OS2
PyModule_AddIntConstant(m, "timezone", _timezone);
#else /* !PYOS_OS2 */
PyModule_AddIntConstant(m, "timezone", timezone);
#endif /* PYOS_OS2 */
#ifdef HAVE_ALTZONE
PyModule_AddIntConstant(m, "altzone", altzone);
#else
#ifdef PYOS_OS2
PyModule_AddIntConstant(m, "altzone", _timezone-3600);
#else /* !PYOS_OS2 */
PyModule_AddIntConstant(m, "altzone", timezone-3600);
#endif /* PYOS_OS2 */
#endif
PyModule_AddIntConstant(m, "daylight", daylight);
otz0 = PyUnicode_Decode(tzname[0], strlen(tzname[0]), TZNAME_ENCODING, NULL);
otz1 = PyUnicode_Decode(tzname[1], strlen(tzname[1]), TZNAME_ENCODING, NULL);
PyModule_AddObject(m, "tzname", Py_BuildValue("(NN)", otz0, otz1));
#else /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
#ifdef HAVE_STRUCT_TM_TM_ZONE
{
#define YEAR ((time_t)((365 * 24 + 6) * 3600))
time_t t;
struct tm *p;
long janzone, julyzone;
char janname[10], julyname[10];
t = (time((time_t *)0) / YEAR) * YEAR;
p = localtime(&t);
janzone = -p->tm_gmtoff;
strncpy(janname, p->tm_zone ? p->tm_zone : " ", 9);
janname[9] = '\0';
t += YEAR/2;
p = localtime(&t);
julyzone = -p->tm_gmtoff;
strncpy(julyname, p->tm_zone ? p->tm_zone : " ", 9);
julyname[9] = '\0';
if( janzone < julyzone ) {
/* DST is reversed in the southern hemisphere */
PyModule_AddIntConstant(m, "timezone", julyzone);
PyModule_AddIntConstant(m, "altzone", janzone);
PyModule_AddIntConstant(m, "daylight",
janzone != julyzone);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)",
julyname, janname));
} else {
PyModule_AddIntConstant(m, "timezone", janzone);
PyModule_AddIntConstant(m, "altzone", julyzone);
PyModule_AddIntConstant(m, "daylight",
janzone != julyzone);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)",
janname, julyname));
}
}
#else
#endif /* HAVE_STRUCT_TM_TM_ZONE */
#ifdef __CYGWIN__
tzset();
PyModule_AddIntConstant(m, "timezone", _timezone);
PyModule_AddIntConstant(m, "altzone", _timezone-3600);
PyModule_AddIntConstant(m, "daylight", _daylight);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)", _tzname[0], _tzname[1]));
#endif /* __CYGWIN__ */
#endif /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
}
static void
_time_eval(Instance *inst)
{
struct timeval timev;
struct tm *tm, tms, tmm, tm2;
time_t tt;
int started = 0, num, i;
tzset();
gettimeofday(&timev, NULL);
tt = (time_t)(timev.tv_sec);
tm = localtime(&tt);
_clear_timestrs(inst);
if (tm)
{
int day;
// tms == current date time "saved"
// tm2 == date to look at adjusting for madj
// tm2 == month baseline @ 1st
memcpy(&tms, tm, sizeof(struct tm));
num = 0;
for (day = (0 - 6); day < (31 + 16); day++)
{
memcpy(&tmm, &tms, sizeof(struct tm));
tmm.tm_sec = 0;
tmm.tm_min = 0;
tmm.tm_hour = 10;
tmm.tm_mon += inst->madj;
tmm.tm_mday = 1; // start at the 1st of the month
tmm.tm_wday = 0; // ignored by mktime
tmm.tm_yday = 0; // ignored by mktime
tmm.tm_isdst = 0; // ignored by mktime
tt = mktime(&tmm);
tm = localtime(&tt);
memcpy(&tm2, tm, sizeof(struct tm));
tt = mktime(&tmm);
tt += (day * 60 * 60 * 24);
tm = localtime(&tt);
memcpy(&tmm, tm, sizeof(struct tm));
if (!started)
{
if (tm->tm_wday == inst->cfg->week.start) started = 1;
}
if (started)
{
int y = num / 7;
int x = num % 7;
if (y < 6)
{
inst->daynums[x][y] = tmm.tm_mday;
inst->dayvalids[x][y] = 0;
if (tmm.tm_mon == tm2.tm_mon) inst->dayvalids[x][y] = 1;
inst->daytoday[x][y] = 0;
if ((tmm.tm_mon == tms.tm_mon) &&
(tmm.tm_year == tms.tm_year) &&
(tmm.tm_mday == tms.tm_mday))
inst->daytoday[x][y] = 1;
inst->dayweekends[x][y] = 0;
for (i = inst->cfg->weekend.start;
i < (inst->cfg->weekend.start + inst->cfg->weekend.len);
i++)
{
if (tmm.tm_wday == (i % 7))
{
inst->dayweekends[x][y] = 1;
break;
}
}
if (!inst->daynames[x])
{
char buf[32];
buf[sizeof(buf) - 1] = 0;
strftime(buf, sizeof(buf) - 1, "%a", (const struct tm *)&tmm); // %A full weekeday
inst->daynames[x] = eina_stringshare_add(buf);
}
}
num++;
}
}
memcpy(&tmm, &tms, sizeof(struct tm));
tmm.tm_sec = 0;
tmm.tm_min = 0;
tmm.tm_hour = 10;
tmm.tm_mon += inst->madj;
tmm.tm_mday = 1; // start at the 1st of the month
tmm.tm_wday = 0; // ignored by mktime
tmm.tm_yday = 0; // ignored by mktime
tmm.tm_isdst = 0; // ignored by mktime
tt = mktime(&tmm);
tm = localtime(&tt);
memcpy(&tm2, tm, sizeof(struct tm));
inst->year[sizeof(inst->year) - 1] = 0;
strftime(inst->year, sizeof(inst->year) - 1, "%Y", (const struct tm *)&tm2);
inst->month[sizeof(inst->month) - 1] = 0;
strftime(inst->month, sizeof(inst->month) - 1, "%B", (const struct tm *)&tm2); // %b for short month
}
}
int main( int argc, char **argv )
#endif
{
struct timeval now_time;
int temp = -1, temp2 = -1;
bool fCopyOver = false;
#if !defined(WIN32)
moron_check( ); // Debatable weather or not this is true in WIN32 anyway :)
#endif
DONT_UPPER = false;
num_descriptors = 0;
num_logins = 0;
dlist.clear( );
mudstrlcpy( lastplayercmd, "No commands issued yet", MIL * 2 );
// Init time.
tzset( );
gettimeofday( &now_time, NULL );
current_time = now_time.tv_sec;
mudstrlcpy( str_boot_time, c_time( current_time, -1 ), MIL ); /* Records when the mud was last rebooted */
new_pfile_time_t = current_time + 86400;
mud_start_time = current_time;
// Get the port number.
mud_port = 9500;
if( argc > 1 )
{
if( !is_number( argv[1] ) )
{
fprintf( stderr, "Usage: %s [port #]\n", argv[0] );
exit( 1 );
}
else if( ( mud_port = atoi( argv[1] ) ) <= 1024 )
{
fprintf( stderr, "%s", "Port number must be above 1024.\n" );
exit( 1 );
}
if( argv[2] && argv[2][0] )
{
fCopyOver = true;
control = atoi( argv[3] );
#ifdef IMC
temp2 = atoi( argv[4] );
#endif
}
else
fCopyOver = false;
}
#if defined(WIN32)
{
/*
* Initialise Windows sockets library
*/
unsigned short wVersionRequested = MAKEWORD( 1, 1 );
WSADATA wsadata;
int err;
/*
* Need to include library: wsock32.lib for Windows Sockets
*/
err = WSAStartup( wVersionRequested, &wsadata );
if( err )
{
fprintf( stderr, "Error %i on WSAStartup\n", err );
exit( 1 );
}
/*
* standard termination signals
*/
signal( SIGINT, bailout );
signal( SIGTERM, bailout );
}
#endif /* WIN32 */
// Initialize all startup functions of the mud.
init_mud( fCopyOver, mud_port, temp, temp2 );
#if !defined(WIN32)
/*
* Set various signal traps, waiting until after completing all bootup operations
* before doing so because crashes during bootup should not be intercepted. Samson 3-11-04
*/
signal( SIGTERM, SigTerm ); /* Catch kill signals */
signal( SIGPIPE, SIG_IGN );
signal( SIGALRM, caught_alarm );
signal( SIGUSR1, SigUser1 ); /* Catch user defined signals */
signal( SIGUSR2, SigUser2 );
#endif
#ifdef MULTIPORT
signal( SIGCHLD, SigChld );
#endif
/*
* If this setting is active, intercept SIGSEGV and keep the mud running.
* Doing so sets a flag variable which if true will cause SegVio to abort()
* If game_loop is restarted and makes it through once without crashing again,
* then the flag is unset and SIGSEGV will continue to be intercepted. Samson 3-11-04
*/
if( sysdata->crashhandler == true )
set_chandler( );
log_string( "No people online yet. Suspending autonomous update handlers." );
// Sick isn't it? The whole game being run inside of one little statement..... :P
game_loop( );
// Clean up the loose ends.
close_mud( );
// That's all, folks.
log_string( "Normal termination of game." );
log_string( "Cleaning up Memory.&d" );
cleanup_memory( );
exit( 0 );
}
void
vsyslogp_r(int pri, struct syslog_data *data, const char *msgid,
const char *sdfmt, const char *msgfmt, va_list ap)
{
static const char BRCOSP[] = "]: ";
static const char CRLF[] = "\r\n";
size_t cnt, prlen, tries;
char ch, *p, *t;
struct timeval tv;
struct tm tmnow;
time_t now;
int fd, saved_errno;
#define TBUF_LEN 2048
#define FMT_LEN 1024
#define MAXTRIES 10
char tbuf[TBUF_LEN], fmt_cpy[FMT_LEN], fmt_cat[FMT_LEN] = "";
size_t tbuf_left, fmt_left, msgsdlen;
char *fmt = fmt_cat;
int signal_safe = pri & LOG_SIGNAL_SAFE;
struct iovec iov[7]; /* prog + [ + pid + ]: + fmt + crlf */
int opened, iovcnt;
pri &= ~LOG_SIGNAL_SAFE;
#define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
/* Check for invalid bits. */
if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) {
syslog_r(INTERNALLOG | signal_safe, data,
"syslog_r: unknown facility/priority: %x", pri);
pri &= LOG_PRIMASK|LOG_FACMASK;
}
/* Check priority against setlogmask values. */
if (!(LOG_MASK(LOG_PRI(pri)) & data->log_mask))
return;
saved_errno = errno;
/* Set default facility if none specified. */
if ((pri & LOG_FACMASK) == 0)
pri |= data->log_fac;
/* Build the message. */
p = tbuf;
tbuf_left = TBUF_LEN;
#define DEC() \
do { \
if (prlen >= tbuf_left) \
prlen = tbuf_left - 1; \
p += prlen; \
tbuf_left -= prlen; \
} while (/*CONSTCOND*/0)
prlen = snprintf_ss(p, tbuf_left, "<%d>1 ", pri);
DEC();
if (!signal_safe && (gettimeofday(&tv, NULL) != -1)) {
/* strftime() implies tzset(), localtime_r() doesn't. */
tzset();
now = (time_t) tv.tv_sec;
localtime_r(&now, &tmnow);
prlen = strftime(p, tbuf_left, "%FT%T", &tmnow);
DEC();
prlen = snprintf(p, tbuf_left, ".%06ld", (long)tv.tv_usec);
DEC();
prlen = strftime(p, tbuf_left-1, "%z", &tmnow);
/* strftime gives eg. "+0200", but we need "+02:00" */
if (prlen == 5) {
p[prlen+1] = p[prlen];
p[prlen] = p[prlen-1];
p[prlen-1] = p[prlen-2];
p[prlen-2] = ':';
prlen += 1;
}
} else {
prlen = snprintf_ss(p, tbuf_left, "-");
/* if gmtime_r() was signal-safe we could output the UTC-time:
gmtime_r(&now, &tmnow);
prlen = strftime(p, tbuf_left, "%FT%TZ", &tmnow);
*/
}
DEC();
prlen = snprintf_ss(p, tbuf_left, " %s ", hostname);
DEC();
if (data->log_tag == NULL)
data->log_tag = getprogname();
prlen = snprintf_ss(p, tbuf_left, "%s ",
data->log_tag ? data->log_tag : "-");
if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
iovcnt = 0;
iov[iovcnt].iov_base = p;
iov[iovcnt].iov_len = prlen - 1;
iovcnt++;
}
DEC();
if (data->log_stat & LOG_PID) {
prlen = snprintf_ss(p, tbuf_left, "%d ", getpid());
if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
iov[iovcnt].iov_base = __UNCONST("[");
iov[iovcnt].iov_len = 1;
iovcnt++;
iov[iovcnt].iov_base = p;
iov[iovcnt].iov_len = prlen - 1;
iovcnt++;
iov[iovcnt].iov_base = __UNCONST(BRCOSP);
iov[iovcnt].iov_len = 3;
iovcnt++;
}
} else {
prlen = snprintf_ss(p, tbuf_left, "- ");
if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
iov[iovcnt].iov_base = __UNCONST(BRCOSP + 1);
iov[iovcnt].iov_len = 2;
iovcnt++;
}
}
DEC();
/*
* concat the format strings, then use one vsnprintf()
*/
if (msgid != NULL && *msgid != '\0') {
strlcat(fmt_cat, msgid, FMT_LEN);
strlcat(fmt_cat, " ", FMT_LEN);
} else
strlcat(fmt_cat, "- ", FMT_LEN);
if (sdfmt != NULL && *sdfmt != '\0') {
strlcat(fmt_cat, sdfmt, FMT_LEN);
} else
strlcat(fmt_cat, "-", FMT_LEN);
if (data->log_stat & (LOG_PERROR|LOG_CONS))
msgsdlen = strlen(fmt_cat) + 1;
else
msgsdlen = 0; /* XXX: GCC */
if (msgfmt != NULL && *msgfmt != '\0') {
strlcat(fmt_cat, " ", FMT_LEN);
strlcat(fmt_cat, msgfmt, FMT_LEN);
}
/*
* We wouldn't need this mess if printf handled %m, or if
* strerror() had been invented before syslog().
*/
for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt) != '\0'; ++fmt) {
if (ch == '%' && fmt[1] == 'm') {
char ebuf[128];
++fmt;
if (signal_safe ||
strerror_r(saved_errno, ebuf, sizeof(ebuf)))
prlen = snprintf_ss(t, fmt_left, "Error %d",
saved_errno);
else
prlen = snprintf_ss(t, fmt_left, "%s", ebuf);
if (prlen >= fmt_left)
prlen = fmt_left - 1;
t += prlen;
fmt_left -= prlen;
} else if (ch == '%' && fmt[1] == '%' && fmt_left > 2) {
*t++ = '%';
*t++ = '%';
fmt++;
fmt_left -= 2;
} else {
if (fmt_left > 1) {
*t++ = ch;
fmt_left--;
}
}
}
*t = '\0';
if (signal_safe)
prlen = vsnprintf_ss(p, tbuf_left, fmt_cpy, ap);
else
prlen = vsnprintf(p, tbuf_left, fmt_cpy, ap);
if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
iov[iovcnt].iov_base = p + msgsdlen;
iov[iovcnt].iov_len = prlen - msgsdlen;
iovcnt++;
}
DEC();
cnt = p - tbuf;
/* Output to stderr if requested. */
if (data->log_stat & LOG_PERROR) {
iov[iovcnt].iov_base = __UNCONST(CRLF + 1);
iov[iovcnt].iov_len = 1;
(void)writev(STDERR_FILENO, iov, iovcnt + 1);
}
/* Get connected, output the message to the local logger. */
#ifndef __minix
if (data == &sdata)
mutex_lock(&syslog_mutex);
#endif
opened = !data->opened;
if (opened)
openlog_unlocked_r(data->log_tag, data->log_stat, 0, data);
connectlog_r(data);
/*
* If the send() failed, there are two likely scenarios:
* 1) syslogd was restarted
* 2) /dev/log is out of socket buffer space
* We attempt to reconnect to /dev/log to take care of
* case #1 and keep send()ing data to cover case #2
* to give syslogd a chance to empty its socket buffer.
*/
for (tries = 0; tries < MAXTRIES; tries++) {
if (send(data->log_file, tbuf, cnt, 0) != -1)
break;
if (errno != ENOBUFS) {
disconnectlog_r(data);
connectlog_r(data);
} else
(void)usleep(1);
}
/*
* Output the message to the console; try not to block
* as a blocking console should not stop other processes.
* Make sure the error reported is the one from the syslogd failure.
*/
if (tries == MAXTRIES && (data->log_stat & LOG_CONS) &&
(fd = open(_PATH_CONSOLE, O_WRONLY|O_NONBLOCK, 0)) >= 0) {
iov[iovcnt].iov_base = __UNCONST(CRLF);
iov[iovcnt].iov_len = 2;
(void)writev(fd, iov, iovcnt + 1);
(void)close(fd);
}
#ifndef __minix
if (data == &sdata)
mutex_unlock(&syslog_mutex);
#endif
if (data != &sdata && opened) {
/* preserve log tag */
const char *ident = data->log_tag;
closelog_r(data);
data->log_tag = ident;
}
}
/* JSON metadata dumping */
static void amf_to_json(const amf_data * data, json_t ** object) {
if (data != NULL) {
json_t * value;
amf_node * node;
time_t time;
struct tm * t;
char str[128];
char * escaped_str;
switch (data->type) {
case AMF_TYPE_NUMBER:
sprintf(str, "%.12g", data->number_data);
*object = json_new_number(str);
break;
case AMF_TYPE_BOOLEAN:
*object = (data->boolean_data) ? json_new_true() : json_new_false();
break;
case AMF_TYPE_STRING:
escaped_str = json_escape((char *)amf_string_get_bytes(data));
*object = json_new_string(escaped_str);
free(escaped_str);
break;
case AMF_TYPE_OBJECT:
*object = json_new_object();
node = amf_object_first(data);
while (node != NULL) {
amf_to_json(amf_object_get_data(node), &value);
escaped_str = json_escape((char *)amf_string_get_bytes(amf_object_get_name(node)));
json_insert_pair_into_object(*object, escaped_str, value);
free(escaped_str);
node = amf_object_next(node);
}
break;
case AMF_TYPE_NULL:
case AMF_TYPE_UNDEFINED:
*object = json_new_null();
break;
case AMF_TYPE_ASSOCIATIVE_ARRAY:
*object = json_new_object();
node = amf_associative_array_first(data);
while (node != NULL) {
amf_to_json(amf_associative_array_get_data(node), &value);
json_insert_pair_into_object(*object, (const char *)amf_string_get_bytes(amf_associative_array_get_name(node)), value);
node = amf_associative_array_next(node);
}
break;
case AMF_TYPE_ARRAY:
*object = json_new_array();
node = amf_array_first(data);
while (node != NULL) {
amf_to_json(amf_array_get(node), &value);
json_insert_child(*object, value);
node = amf_array_next(node);
}
break;
case AMF_TYPE_DATE:
time = amf_date_to_time_t(data);
tzset();
t = localtime(&time);
strftime(str, sizeof(str), "%Y-%m-%dT%H:%M:%S", t);
*object = json_new_string(str);
break;
case AMF_TYPE_XML: break;
case AMF_TYPE_CLASS: break;
default: break;
}
}
}
int
main(int argc, char **argv)
{
int ch, np, ret, Xflag = 0;
pcap_handler phandler = dump_packet;
const char *errstr = NULL;
char *pidf = NULL;
ret = 0;
closefrom(STDERR_FILENO + 1);
while ((ch = getopt(argc, argv, "Dxd:f:i:p:s:")) != -1) {
switch (ch) {
case 'D':
Debug = 1;
break;
case 'd':
delay = strtonum(optarg, 5, 60*60, &errstr);
if (errstr)
usage();
break;
case 'f':
filename = optarg;
break;
case 'i':
interface = optarg;
break;
case 'p':
pidf = optarg;
break;
case 's':
snaplen = strtonum(optarg, 0, PFLOGD_MAXSNAPLEN,
&errstr);
if (snaplen <= 0)
snaplen = DEF_SNAPLEN;
if (errstr)
snaplen = PFLOGD_MAXSNAPLEN;
break;
case 'x':
Xflag++;
break;
default:
usage();
}
}
log_debug = Debug;
argc -= optind;
argv += optind;
/* does interface exist */
if (!if_exists(interface)) {
warn("Failed to initialize: %s", interface);
logmsg(LOG_ERR, "Failed to initialize: %s", interface);
logmsg(LOG_ERR, "Exiting, init failure");
exit(1);
}
if (!Debug) {
openlog("pflogd", LOG_PID | LOG_CONS, LOG_DAEMON);
if (daemon(0, 0)) {
logmsg(LOG_WARNING, "Failed to become daemon: %s",
strerror(errno));
}
pidfile(pidf);
}
tzset();
(void)umask(S_IRWXG | S_IRWXO);
/* filter will be used by the privileged process */
if (argc) {
filter = copy_argv(argv);
if (filter == NULL)
logmsg(LOG_NOTICE, "Failed to form filter expression");
}
/* initialize pcap before dropping privileges */
if (init_pcap()) {
logmsg(LOG_ERR, "Exiting, init failure");
exit(1);
}
/* Privilege separation begins here */
if (priv_init()) {
logmsg(LOG_ERR, "unable to privsep");
exit(1);
}
setproctitle("[initializing]");
/* Process is now unprivileged and inside a chroot */
signal(SIGTERM, sig_close);
signal(SIGINT, sig_close);
signal(SIGQUIT, sig_close);
signal(SIGALRM, sig_alrm);
signal(SIGUSR1, sig_usr1);
signal(SIGHUP, sig_hup);
alarm(delay);
buffer = malloc(PFLOGD_BUFSIZE);
if (buffer == NULL) {
logmsg(LOG_WARNING, "Failed to allocate output buffer");
phandler = dump_packet_nobuf;
} else {
bufleft = buflen = PFLOGD_BUFSIZE;
bufpos = buffer;
bufpkt = 0;
}
if (reset_dump(Xflag) < 0) {
if (Xflag)
return (1);
logmsg(LOG_ERR, "Logging suspended: open error");
set_suspended(1);
} else if (Xflag)
return (0);
while (1) {
np = pcap_dispatch(hpcap, PCAP_NUM_PKTS,
phandler, (u_char *)dpcap);
if (np < 0) {
if (!if_exists(interface) == -1) {
logmsg(LOG_NOTICE, "interface %s went away",
interface);
ret = -1;
break;
}
logmsg(LOG_NOTICE, "%s", pcap_geterr(hpcap));
}
if (gotsig_close)
break;
if (gotsig_hup) {
if (reset_dump(0)) {
logmsg(LOG_ERR,
"Logging suspended: open error");
set_suspended(1);
}
gotsig_hup = 0;
}
if (gotsig_alrm) {
if (dpcap)
flush_buffer(dpcap);
else
gotsig_hup = 1;
gotsig_alrm = 0;
alarm(delay);
}
if (gotsig_usr1) {
log_pcap_stats();
gotsig_usr1 = 0;
}
}
logmsg(LOG_NOTICE, "Exiting");
if (dpcap) {
flush_buffer(dpcap);
fclose(dpcap);
}
purge_buffer();
log_pcap_stats();
pcap_close(hpcap);
if (!Debug)
closelog();
return (ret);
}
int main(int argc, char **argv) {
int result;
int error = FALSE;
char *buffer = NULL;
int display_license = FALSE;
int display_help = FALSE;
int c = 0;
struct tm *tm;
time_t current_time;
time_t test_time;
time_t saved_test_time;
time_t next_valid_time = 0L;
time_t chosen_valid_time = 0L;
char datestring[256];
host *temp_host = NULL;
hostgroup *temp_hostgroup = NULL;
hostsmember *temp_member = NULL;
timeperiod *temp_timeperiod = NULL;
int is_valid_time = 0;
int iterations = 1000;
plan_tests(6043);
/* reset program variables */
reset_variables();
printf("Reading configuration data...\n");
config_file = strdup("smallconfig/nagios.cfg");
/* read in the configuration files (main config file, resource and object config files) */
result = read_main_config_file(config_file);
ok(result == OK, "Read main configuration file okay - if fails, use nagios -v to check");
result = read_all_object_data(config_file);
ok(result == OK, "Read all object config files");
result = pre_flight_check();
ok(result == OK, "Preflight check okay");
time(¤t_time);
test_time = current_time;
saved_test_time = current_time;
temp_timeperiod = find_timeperiod("none");
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "No valid time because time period is empty");
get_next_valid_time(current_time, &next_valid_time, temp_timeperiod);
ok(current_time == next_valid_time, "There is no valid time due to timeperiod");
temp_timeperiod = find_timeperiod("24x7");
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Fine because 24x7");
get_next_valid_time(current_time, &next_valid_time, temp_timeperiod);
ok((next_valid_time - current_time) <= 2, "Next valid time should be the current_time, but with a 2 second tolerance");
/* 2009-10-25 is the day when clocks go back an hour in Europe. Bug happens during 23:00 to 00:00 */
/* This is 23:01:01 */
saved_test_time = 1256511661;
saved_test_time = saved_test_time - (24 * 60 * 60);
putenv("TZ=UTC");
tzset();
test_time = saved_test_time;
c = 0;
while(c < iterations) {
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Always OK for 24x7 with TZ=UTC, time_t=%lu", test_time);
chosen_valid_time = 0L;
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(test_time == chosen_valid_time, "get_next_valid_time always returns same time");
test_time += 1800;
c++;
}
putenv("TZ=Europe/London");
tzset();
test_time = saved_test_time;
c = 0;
while(c < iterations) {
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Always OK for 24x7 with TZ=Europe/London, time_t=%lu", test_time);
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(test_time == chosen_valid_time, "get_next_valid_time always returns same time, time_t=%lu", test_time);
test_time += 1800;
c++;
}
/* 2009-11-01 is the day when clocks go back an hour in America. Bug happens during 23:00 to 00:00 */
/* This is 23:01:01 */
saved_test_time = 1256511661;
saved_test_time = saved_test_time - (24 * 60 * 60);
putenv("TZ=America/New_York");
tzset();
test_time = saved_test_time;
c = 0;
while(c < iterations) {
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Always OK for 24x7 with TZ=America/New_York, time_t=%lu", test_time);
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(test_time == chosen_valid_time, "get_next_valid_time always returns same time, time_t=%lu", test_time);
test_time += 1800;
c++;
}
/* Tests around clock change going back for TZ=Europe/London. 1256511661 = Sun Oct
25 23:01:01 2009 */
/* A little trip to Paris*/
putenv("TZ=Europe/Paris");
tzset();
/* Timeperiod exclude tests, from Jean Gabes */
temp_timeperiod = find_timeperiod("Test_exclude");
ok(temp_timeperiod != NULL, "ME: Testing Exclude timeperiod");
test_time = 1278939600;
/* printf("Testing at time %s", ctime(&test_time)); */
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "ME: 12 Jul 2010 15:00:00 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
/* printf("JEAN: Got chosent time at %s", ctime(&chosen_valid_time)); */
todo_start("Bug in exclude");
ok(chosen_valid_time == 1288103400, "ME: Next valid time=Tue Oct 26 16:30:00 2010");
todo_end();
temp_timeperiod = find_timeperiod("Test_exclude2");
ok(temp_timeperiod != NULL, "ME: Testing Exclude timeperiod 2");
test_time = 1278939600;
/* printf("Testing at time %s", ctime(&test_time)); */
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "ME: 12 Jul 2010 15:00:00 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
/* printf("JEAN: Got chosent time at %s", ctime(&chosen_valid_time)); */
todo_start("Bug in exclude 2");
ok(chosen_valid_time == 1279058340, "ME: Next valid time=Tue Jul 13 23:59:00 2010");
todo_end();
temp_timeperiod = find_timeperiod("Test_exclude3");
ok(temp_timeperiod != NULL, "ME: Testing Exclude timeperiod 3");
test_time = 1278939600;
/* printf("Testing at time %s", ctime(&test_time)); */
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "ME: 12 Jul 2010 15:00:00 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
/* printf("JEAN: Got chosent time at %s", ctime(&chosen_valid_time)); */
todo_start("Bug in exclude 3");
ok(chosen_valid_time == 1284474600, "ME: Next valid time=Tue Sep 14 16:30:00 2010");
todo_end();
temp_timeperiod = find_timeperiod("Test_exclude4");
ok(temp_timeperiod != NULL, "ME: Testing Exclude timeperiod 4");
test_time = 1278939600;
/* printf("Testing at time %s", ctime(&test_time)); */
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "ME: 12 Jul 2010 15:00:00 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
/* printf("JEAN: Got chosent time at %s", ctime(&chosen_valid_time)); */
todo_start("Bug in exclude 3");
ok(chosen_valid_time == 1283265000, "ME: Next valid time=Tue Aug 31 16:30:00 2010");
todo_end();
/* Back to New york */
putenv("TZ=America/New_York");
tzset();
temp_timeperiod = find_timeperiod("sunday_only");
ok(temp_timeperiod != NULL, "Testing Sunday 00:00-01:15,03:15-22:00");
putenv("TZ=Europe/London");
tzset();
test_time = 1256421000;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "Sat Oct 24 22:50:00 2009 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == 1256425200, "Next valid time=Sun Oct 25 00:00:00 2009");
test_time = 1256421661;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "Sat Oct 24 23:01:01 2009 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == 1256425200, "Next valid time=Sun Oct 25 00:00:00 2009");
test_time = 1256425400;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Sun Oct 25 00:03:20 2009 - true");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == test_time, "Next valid time=Sun Oct 25 00:03:20 2009");
test_time = 1256429700;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Sun Oct 25 01:15:00 2009 - true");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == test_time, "Next valid time=Sun Oct 25 01:15:00 2009");
test_time = 1256430400;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "Sun Oct 25 01:26:40 2009 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
todo_start("Is a bug in get_next_valid_time for a time that falls in the DST change hour period");
ok(chosen_valid_time == 1256440500, "Next valid time=Sun Oct 25 03:15:00 2009") || printf("chosen_valid_time=%lu\n", chosen_valid_time);
todo_end();
test_time = 1256440500;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Sun Oct 25 03:15:00 2009 - true");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == test_time, "Next valid time=Sun Oct 25 03:15:00 2009");
test_time = 1256500000;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Sun Oct 25 19:46:40 2009 - true");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == 1256500000, "Next valid time=Sun Oct 25 19:46:40 2009");
test_time = 1256508000;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == OK, "Sun Oct 25 22:00:00 2009 - true");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == 1256508000, "Next valid time=Sun Oct 25 22:00:00 2009");
test_time = 1256508001;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "Sun Oct 25 22:00:01 2009 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == 1257033600, "Next valid time=Sun Nov 1 00:00:00 2009");
test_time = 1256513000;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "Sun Oct 25 23:23:20 2009 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == 1257033600, "Next valid time=Sun Nov 1 00:00:00 2009");
temp_timeperiod = find_timeperiod("weekly_complex");
ok(temp_timeperiod != NULL, "Testing complex weekly timeperiod definition");
putenv("TZ=America/New_York");
tzset();
test_time = 1268109420;
is_valid_time = check_time_against_period(test_time, temp_timeperiod);
ok(is_valid_time == ERROR, "Mon Mar 8 23:37:00 2010 - false");
_get_next_valid_time(test_time, test_time, &chosen_valid_time, temp_timeperiod);
ok(chosen_valid_time == 1268115300, "Next valid time=Tue Mar 9 01:15:00 2010");
cleanup();
my_free(config_file);
return exit_status();
}
int main (int argc, char **argv) {
server *srv = NULL;
int print_config = 0;
int test_config = 0;
int i_am_root;
int o;
int num_childs = 0;
int pid_fd = -1, fd;
size_t i;
#ifdef HAVE_SIGACTION
struct sigaction act;
#endif
#ifdef HAVE_GETRLIMIT
struct rlimit rlim;
#endif
#ifdef USE_ALARM
struct itimerval interval;
interval.it_interval.tv_sec = 1;
interval.it_interval.tv_usec = 0;
interval.it_value.tv_sec = 1;
interval.it_value.tv_usec = 0;
#endif
/* for nice %b handling in strfime() */
setlocale(LC_TIME, "C");
if (NULL == (srv = server_init())) {
fprintf(stderr, "did this really happen?\n");
return -1;
}
/* init structs done */
srv->srvconf.port = 0;
#ifdef HAVE_GETUID
i_am_root = (getuid() == 0);
#else
i_am_root = 0;
#endif
srv->srvconf.dont_daemonize = 0;
while(-1 != (o = getopt(argc, argv, "f:m:hvVDpt"))) {
switch(o) {
case 'f':
if (srv->config_storage) {
log_error_write(srv, __FILE__, __LINE__, "s",
"Can only read one config file. Use the include command to use multiple config files.");
server_free(srv);
return -1;
}
if (config_read(srv, optarg)) {
server_free(srv);
return -1;
}
break;
case 'm':
buffer_copy_string(srv->srvconf.modules_dir, optarg);
break;
case 'p': print_config = 1; break;
case 't': test_config = 1; break;
case 'D': srv->srvconf.dont_daemonize = 1; break;
case 'v': show_version(); return 0;
case 'V': show_features(); return 0;
case 'h': show_help(); return 0;
default:
show_help();
server_free(srv);
return -1;
}
}
if (!srv->config_storage) {
log_error_write(srv, __FILE__, __LINE__, "s",
"No configuration available. Try using -f option.");
server_free(srv);
return -1;
}
if (print_config) {
data_unset *dc = srv->config_context->data[0];
if (dc) {
dc->print(dc, 0);
fprintf(stdout, "\n");
} else {
/* shouldn't happend */
fprintf(stderr, "global config not found\n");
}
}
if (test_config) {
printf("Syntax OK\n");
}
if (test_config || print_config) {
server_free(srv);
return 0;
}
/* close stdin and stdout, as they are not needed */
openDevNull(STDIN_FILENO);
openDevNull(STDOUT_FILENO);
if (0 != config_set_defaults(srv)) {
log_error_write(srv, __FILE__, __LINE__, "s",
"setting default values failed");
server_free(srv);
return -1;
}
/* UID handling */
#ifdef HAVE_GETUID
if (!i_am_root && issetugid()) {
/* we are setuid-root */
log_error_write(srv, __FILE__, __LINE__, "s",
"Are you nuts ? Don't apply a SUID bit to this binary");
server_free(srv);
return -1;
}
#endif
/* check document-root */
if (srv->config_storage[0]->document_root->used <= 1) {
log_error_write(srv, __FILE__, __LINE__, "s",
"document-root is not set\n");
server_free(srv);
return -1;
}
if (plugins_load(srv)) {
log_error_write(srv, __FILE__, __LINE__, "s",
"loading plugins finally failed");
plugins_free(srv);
server_free(srv);
return -1;
}
/* open pid file BEFORE chroot */
if (srv->srvconf.pid_file->used) {
if (-1 == (pid_fd = open(srv->srvconf.pid_file->ptr, O_WRONLY | O_CREAT | O_EXCL | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
struct stat st;
if (errno != EEXIST) {
log_error_write(srv, __FILE__, __LINE__, "sbs",
"opening pid-file failed:", srv->srvconf.pid_file, strerror(errno));
return -1;
}
if (0 != stat(srv->srvconf.pid_file->ptr, &st)) {
log_error_write(srv, __FILE__, __LINE__, "sbs",
"stating existing pid-file failed:", srv->srvconf.pid_file, strerror(errno));
}
if (!S_ISREG(st.st_mode)) {
log_error_write(srv, __FILE__, __LINE__, "sb",
"pid-file exists and isn't regular file:", srv->srvconf.pid_file);
return -1;
}
if (-1 == (pid_fd = open(srv->srvconf.pid_file->ptr, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
log_error_write(srv, __FILE__, __LINE__, "sbs",
"opening pid-file failed:", srv->srvconf.pid_file, strerror(errno));
return -1;
}
}
}
if (srv->event_handler == FDEVENT_HANDLER_SELECT) {
/* select limits itself
*
* as it is a hard limit and will lead to a segfault we add some safety
* */
srv->max_fds = FD_SETSIZE - 200;
} else {
srv->max_fds = 4096;
}
if (i_am_root) {
struct group *grp = NULL;
struct passwd *pwd = NULL;
int use_rlimit = 1;
#ifdef HAVE_VALGRIND_VALGRIND_H
if (RUNNING_ON_VALGRIND) use_rlimit = 0;
#endif
#ifdef HAVE_GETRLIMIT
if (0 != getrlimit(RLIMIT_NOFILE, &rlim)) {
log_error_write(srv, __FILE__, __LINE__,
"ss", "couldn't get 'max filedescriptors'",
strerror(errno));
return -1;
}
if (use_rlimit && srv->srvconf.max_fds) {
/* set rlimits */
rlim.rlim_cur = srv->srvconf.max_fds;
rlim.rlim_max = srv->srvconf.max_fds;
if (0 != setrlimit(RLIMIT_NOFILE, &rlim)) {
log_error_write(srv, __FILE__, __LINE__,
"ss", "couldn't set 'max filedescriptors'",
strerror(errno));
return -1;
}
}
if (srv->event_handler == FDEVENT_HANDLER_SELECT) {
srv->max_fds = rlim.rlim_cur < ((int)FD_SETSIZE) - 200 ? rlim.rlim_cur : FD_SETSIZE - 200;
} else {
srv->max_fds = rlim.rlim_cur;
}
/* set core file rlimit, if enable_cores is set */
if (use_rlimit && srv->srvconf.enable_cores && getrlimit(RLIMIT_CORE, &rlim) == 0) {
rlim.rlim_cur = rlim.rlim_max;
setrlimit(RLIMIT_CORE, &rlim);
}
#endif
if (srv->event_handler == FDEVENT_HANDLER_SELECT) {
/* don't raise the limit above FD_SET_SIZE */
if (srv->max_fds > ((int)FD_SETSIZE) - 200) {
log_error_write(srv, __FILE__, __LINE__, "sd",
"can't raise max filedescriptors above", FD_SETSIZE - 200,
"if event-handler is 'select'. Use 'poll' or something else or reduce server.max-fds.");
return -1;
}
}
#ifdef HAVE_PWD_H
/* set user and group */
if (srv->srvconf.username->used) {
if (NULL == (pwd = getpwnam(srv->srvconf.username->ptr))) {
log_error_write(srv, __FILE__, __LINE__, "sb",
"can't find username", srv->srvconf.username);
return -1;
}
if (pwd->pw_uid == 0) {
log_error_write(srv, __FILE__, __LINE__, "s",
"I will not set uid to 0\n");
return -1;
}
}
if (srv->srvconf.groupname->used) {
if (NULL == (grp = getgrnam(srv->srvconf.groupname->ptr))) {
log_error_write(srv, __FILE__, __LINE__, "sb",
"can't find groupname", srv->srvconf.groupname);
return -1;
}
if (grp->gr_gid == 0) {
log_error_write(srv, __FILE__, __LINE__, "s",
"I will not set gid to 0\n");
return -1;
}
}
#endif
/* we need root-perms for port < 1024 */
if (0 != network_init(srv)) {
plugins_free(srv);
server_free(srv);
return -1;
}
#ifdef HAVE_PWD_H
/*
* Change group before chroot, when we have access
* to /etc/group
* */
if (NULL != grp) {
setgid(grp->gr_gid);
setgroups(0, NULL);
if (srv->srvconf.username->used) {
initgroups(srv->srvconf.username->ptr, grp->gr_gid);
}
}
#endif
#ifdef HAVE_CHROOT
if (srv->srvconf.changeroot->used) {
tzset();
if (-1 == chroot(srv->srvconf.changeroot->ptr)) {
log_error_write(srv, __FILE__, __LINE__, "ss", "chroot failed: ", strerror(errno));
return -1;
}
if (-1 == chdir("/")) {
log_error_write(srv, __FILE__, __LINE__, "ss", "chdir failed: ", strerror(errno));
return -1;
}
}
#endif
#ifdef HAVE_PWD_H
/* drop root privs */
if (NULL != pwd) {
setuid(pwd->pw_uid);
}
#endif
#if defined(HAVE_SYS_PRCTL_H) && defined(PR_SET_DUMPABLE)
/**
* on IRIX 6.5.30 they have prctl() but no DUMPABLE
*/
if (srv->srvconf.enable_cores) {
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
#endif
} else {
#ifdef HAVE_GETRLIMIT
if (0 != getrlimit(RLIMIT_NOFILE, &rlim)) {
log_error_write(srv, __FILE__, __LINE__,
"ss", "couldn't get 'max filedescriptors'",
strerror(errno));
return -1;
}
/**
* we are not root can can't increase the fd-limit, but we can reduce it
*/
if (srv->srvconf.max_fds && srv->srvconf.max_fds < rlim.rlim_cur) {
/* set rlimits */
rlim.rlim_cur = srv->srvconf.max_fds;
if (0 != setrlimit(RLIMIT_NOFILE, &rlim)) {
log_error_write(srv, __FILE__, __LINE__,
"ss", "couldn't set 'max filedescriptors'",
strerror(errno));
return -1;
}
}
if (srv->event_handler == FDEVENT_HANDLER_SELECT) {
srv->max_fds = rlim.rlim_cur < ((int)FD_SETSIZE) - 200 ? rlim.rlim_cur : FD_SETSIZE - 200;
} else {
srv->max_fds = rlim.rlim_cur;
}
/* set core file rlimit, if enable_cores is set */
if (srv->srvconf.enable_cores && getrlimit(RLIMIT_CORE, &rlim) == 0) {
rlim.rlim_cur = rlim.rlim_max;
setrlimit(RLIMIT_CORE, &rlim);
}
#endif
if (srv->event_handler == FDEVENT_HANDLER_SELECT) {
/* don't raise the limit above FD_SET_SIZE */
if (srv->max_fds > ((int)FD_SETSIZE) - 200) {
log_error_write(srv, __FILE__, __LINE__, "sd",
"can't raise max filedescriptors above", FD_SETSIZE - 200,
"if event-handler is 'select'. Use 'poll' or something else or reduce server.max-fds.");
return -1;
}
}
if (0 != network_init(srv)) {
plugins_free(srv);
server_free(srv);
return -1;
}
}
/* set max-conns */
if (srv->srvconf.max_conns > srv->max_fds/2) {
/* we can't have more connections than max-fds/2 */
log_error_write(srv, __FILE__, __LINE__, "sdd", "can't have more connections than fds/2: ", srv->srvconf.max_conns, srv->max_fds);
srv->max_conns = srv->max_fds/2;
} else if (srv->srvconf.max_conns) {
/* otherwise respect the wishes of the user */
srv->max_conns = srv->srvconf.max_conns;
} else {
/* or use the default: we really don't want to hit max-fds */
srv->max_conns = srv->max_fds/3;
}
if (HANDLER_GO_ON != plugins_call_init(srv)) {
log_error_write(srv, __FILE__, __LINE__, "s", "Initialization of plugins failed. Going down.");
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
#ifdef HAVE_FORK
/* network is up, let's deamonize ourself */
if (srv->srvconf.dont_daemonize == 0) daemonize();
#endif
srv->gid = getgid();
srv->uid = getuid();
/* write pid file */
if (pid_fd != -1) {
buffer_copy_long(srv->tmp_buf, getpid());
buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN("\n"));
write(pid_fd, srv->tmp_buf->ptr, srv->tmp_buf->used - 1);
close(pid_fd);
pid_fd = -1;
}
/* Close stderr ASAP in the child process to make sure that nothing
* is being written to that fd which may not be valid anymore. */
if (-1 == log_error_open(srv)) {
log_error_write(srv, __FILE__, __LINE__, "s", "Opening errorlog failed. Going down.");
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
if (HANDLER_GO_ON != plugins_call_set_defaults(srv)) {
log_error_write(srv, __FILE__, __LINE__, "s", "Configuration of plugins failed. Going down.");
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
/* dump unused config-keys */
for (i = 0; i < srv->config_context->used; i++) {
array *config = ((data_config *)srv->config_context->data[i])->value;
size_t j;
for (j = 0; config && j < config->used; j++) {
data_unset *du = config->data[j];
/* all var.* is known as user defined variable */
if (strncmp(du->key->ptr, "var.", sizeof("var.") - 1) == 0) {
continue;
}
if (NULL == array_get_element(srv->config_touched, du->key->ptr)) {
log_error_write(srv, __FILE__, __LINE__, "sbs",
"WARNING: unknown config-key:",
du->key,
"(ignored)");
}
}
}
if (srv->config_unsupported) {
log_error_write(srv, __FILE__, __LINE__, "s",
"Configuration contains unsupported keys. Going down.");
}
if (srv->config_deprecated) {
log_error_write(srv, __FILE__, __LINE__, "s",
"Configuration contains deprecated keys. Going down.");
}
if (srv->config_unsupported || srv->config_deprecated) {
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
#ifdef HAVE_SIGACTION
memset(&act, 0, sizeof(act));
act.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &act, NULL);
sigaction(SIGUSR1, &act, NULL);
# if defined(SA_SIGINFO)
act.sa_sigaction = sigaction_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
# else
act.sa_handler = signal_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
# endif
sigaction(SIGINT, &act, NULL);
sigaction(SIGTERM, &act, NULL);
sigaction(SIGHUP, &act, NULL);
sigaction(SIGALRM, &act, NULL);
sigaction(SIGCHLD, &act, NULL);
#elif defined(HAVE_SIGNAL)
/* ignore the SIGPIPE from sendfile() */
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGALRM, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGHUP, signal_handler);
signal(SIGCHLD, signal_handler);
signal(SIGINT, signal_handler);
#endif
#ifdef USE_ALARM
signal(SIGALRM, signal_handler);
/* setup periodic timer (1 second) */
if (setitimer(ITIMER_REAL, &interval, NULL)) {
log_error_write(srv, __FILE__, __LINE__, "s", "setting timer failed");
return -1;
}
getitimer(ITIMER_REAL, &interval);
#endif
#ifdef HAVE_FORK
/* start watcher and workers */
num_childs = srv->srvconf.max_worker;
if (num_childs > 0) {
int child = 0;
while (!child && !srv_shutdown && !graceful_shutdown) {
if (num_childs > 0) {
switch (fork()) {
case -1:
return -1;
case 0:
child = 1;
break;
default:
num_childs--;
break;
}
} else {
int status;
if (-1 != wait(&status)) {
/**
* one of our workers went away
*/
num_childs++;
} else {
switch (errno) {
case EINTR:
/**
* if we receive a SIGHUP we have to close our logs ourself as we don't
* have the mainloop who can help us here
*/
if (handle_sig_hup) {
handle_sig_hup = 0;
log_error_cycle(srv);
/**
* forward to all procs in the process-group
*
* we also send it ourself
*/
if (!forwarded_sig_hup) {
forwarded_sig_hup = 1;
kill(0, SIGHUP);
}
}
break;
default:
break;
}
}
}
}
/**
* for the parent this is the exit-point
*/
if (!child) {
/**
* kill all children too
*/
if (graceful_shutdown) {
kill(0, SIGINT);
} else if (srv_shutdown) {
kill(0, SIGTERM);
}
log_error_close(srv);
network_close(srv);
connections_free(srv);
plugins_free(srv);
server_free(srv);
return 0;
}
}
#endif
if (NULL == (srv->ev = fdevent_init(srv, srv->max_fds + 1, srv->event_handler))) {
log_error_write(srv, __FILE__, __LINE__,
"s", "fdevent_init failed");
return -1;
}
/* libev backend overwrites our SIGCHLD handler and calls waitpid on SIGCHLD; we want our own SIGCHLD handling. */
#ifdef HAVE_SIGACTION
sigaction(SIGCHLD, &act, NULL);
#elif defined(HAVE_SIGNAL)
signal(SIGCHLD, signal_handler);
#endif
/*
* kqueue() is called here, select resets its internals,
* all server sockets get their handlers
*
* */
if (0 != network_register_fdevents(srv)) {
plugins_free(srv);
network_close(srv);
server_free(srv);
return -1;
}
/* might fail if user is using fam (not gamin) and famd isn't running */
if (NULL == (srv->stat_cache = stat_cache_init())) {
log_error_write(srv, __FILE__, __LINE__, "s",
"stat-cache could not be setup, dieing.");
return -1;
}
#ifdef HAVE_FAM_H
/* setup FAM */
if (srv->srvconf.stat_cache_engine == STAT_CACHE_ENGINE_FAM) {
if (0 != FAMOpen2(srv->stat_cache->fam, "lighttpd")) {
log_error_write(srv, __FILE__, __LINE__, "s",
"could not open a fam connection, dieing.");
return -1;
}
#ifdef HAVE_FAMNOEXISTS
FAMNoExists(srv->stat_cache->fam);
#endif
srv->stat_cache->fam_fcce_ndx = -1;
fdevent_register(srv->ev, FAMCONNECTION_GETFD(srv->stat_cache->fam), stat_cache_handle_fdevent, NULL);
fdevent_event_set(srv->ev, &(srv->stat_cache->fam_fcce_ndx), FAMCONNECTION_GETFD(srv->stat_cache->fam), FDEVENT_IN);
}
#endif
/* get the current number of FDs */
srv->cur_fds = open("/dev/null", O_RDONLY);
close(srv->cur_fds);
for (i = 0; i < srv->srv_sockets.used; i++) {
server_socket *srv_socket = srv->srv_sockets.ptr[i];
if (-1 == fdevent_fcntl_set(srv->ev, srv_socket->fd)) {
log_error_write(srv, __FILE__, __LINE__, "ss", "fcntl failed:", strerror(errno));
return -1;
}
}
/* main-loop */
while (!srv_shutdown) {
int n;
size_t ndx;
time_t min_ts;
if (handle_sig_hup) {
handler_t r;
/* reset notification */
handle_sig_hup = 0;
/* cycle logfiles */
switch(r = plugins_call_handle_sighup(srv)) {
case HANDLER_GO_ON:
break;
default:
log_error_write(srv, __FILE__, __LINE__, "sd", "sighup-handler return with an error", r);
break;
}
if (-1 == log_error_cycle(srv)) {
log_error_write(srv, __FILE__, __LINE__, "s", "cycling errorlog failed, dying");
return -1;
} else {
#ifdef HAVE_SIGACTION
log_error_write(srv, __FILE__, __LINE__, "sdsd",
"logfiles cycled UID =",
last_sighup_info.si_uid,
"PID =",
last_sighup_info.si_pid);
#else
log_error_write(srv, __FILE__, __LINE__, "s",
"logfiles cycled");
#endif
}
}
if (handle_sig_alarm) {
/* a new second */
#ifdef USE_ALARM
/* reset notification */
handle_sig_alarm = 0;
#endif
/* get current time */
min_ts = time(NULL);
if (min_ts != srv->cur_ts) {
int cs = 0;
connections *conns = srv->conns;
handler_t r;
switch(r = plugins_call_handle_trigger(srv)) {
case HANDLER_GO_ON:
break;
case HANDLER_ERROR:
log_error_write(srv, __FILE__, __LINE__, "s", "one of the triggers failed");
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
/* trigger waitpid */
srv->cur_ts = min_ts;
/* cleanup stat-cache */
stat_cache_trigger_cleanup(srv);
/**
* check all connections for timeouts
*
*/
for (ndx = 0; ndx < conns->used; ndx++) {
int changed = 0;
connection *con;
int t_diff;
con = conns->ptr[ndx];
if (con->state == CON_STATE_READ ||
con->state == CON_STATE_READ_POST) {
if (con->request_count == 1) {
if (srv->cur_ts - con->read_idle_ts > con->conf.max_read_idle) {
/* time - out */
#if 0
log_error_write(srv, __FILE__, __LINE__, "sd",
"connection closed - read-timeout:", con->fd);
#endif
connection_set_state(srv, con, CON_STATE_ERROR);
changed = 1;
}
} else {
if (srv->cur_ts - con->read_idle_ts > con->keep_alive_idle) {
/* time - out */
#if 0
log_error_write(srv, __FILE__, __LINE__, "sd",
"connection closed - read-timeout:", con->fd);
#endif
connection_set_state(srv, con, CON_STATE_ERROR);
changed = 1;
}
}
}
if ((con->state == CON_STATE_WRITE) &&
(con->write_request_ts != 0)) {
#if 0
if (srv->cur_ts - con->write_request_ts > 60) {
log_error_write(srv, __FILE__, __LINE__, "sdd",
"connection closed - pre-write-request-timeout:", con->fd, srv->cur_ts - con->write_request_ts);
}
#endif
if (srv->cur_ts - con->write_request_ts > con->conf.max_write_idle) {
/* time - out */
if (con->conf.log_timeouts) {
log_error_write(srv, __FILE__, __LINE__, "sbsosds",
"NOTE: a request for",
con->request.uri,
"timed out after writing",
con->bytes_written,
"bytes. We waited",
(int)con->conf.max_write_idle,
"seconds. If this a problem increase server.max-write-idle");
}
connection_set_state(srv, con, CON_STATE_ERROR);
changed = 1;
}
}
if (con->state == CON_STATE_CLOSE && (srv->cur_ts - con->close_timeout_ts > HTTP_LINGER_TIMEOUT)) {
changed = 1;
}
/* we don't like div by zero */
if (0 == (t_diff = srv->cur_ts - con->connection_start)) t_diff = 1;
if (con->traffic_limit_reached &&
(con->conf.kbytes_per_second == 0 ||
((con->bytes_written / t_diff) < con->conf.kbytes_per_second * 1024))) {
/* enable connection again */
con->traffic_limit_reached = 0;
changed = 1;
}
if (changed) {
connection_state_machine(srv, con);
}
con->bytes_written_cur_second = 0;
*(con->conf.global_bytes_per_second_cnt_ptr) = 0;
#if 0
if (cs == 0) {
fprintf(stderr, "connection-state: ");
cs = 1;
}
fprintf(stderr, "c[%d,%d]: %s ",
con->fd,
con->fcgi.fd,
connection_get_state(con->state));
#endif
}
if (cs == 1) fprintf(stderr, "\n");
}
}
if (srv->sockets_disabled) {
/* our server sockets are disabled, why ? */
if ((srv->cur_fds + srv->want_fds < srv->max_fds * 8 / 10) && /* we have enough unused fds */
(srv->conns->used <= srv->max_conns * 9 / 10) &&
(0 == graceful_shutdown)) {
for (i = 0; i < srv->srv_sockets.used; i++) {
server_socket *srv_socket = srv->srv_sockets.ptr[i];
fdevent_event_set(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd, FDEVENT_IN);
}
log_error_write(srv, __FILE__, __LINE__, "s", "[note] sockets enabled again");
srv->sockets_disabled = 0;
}
} else {
if ((srv->cur_fds + srv->want_fds > srv->max_fds * 9 / 10) || /* out of fds */
(srv->conns->used >= srv->max_conns) || /* out of connections */
(graceful_shutdown)) { /* graceful_shutdown */
/* disable server-fds */
for (i = 0; i < srv->srv_sockets.used; i++) {
server_socket *srv_socket = srv->srv_sockets.ptr[i];
fdevent_event_del(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd);
if (graceful_shutdown) {
/* we don't want this socket anymore,
*
* closing it right away will make it possible for
* the next lighttpd to take over (graceful restart)
* */
fdevent_unregister(srv->ev, srv_socket->fd);
close(srv_socket->fd);
srv_socket->fd = -1;
/* network_close() will cleanup after us */
if (srv->srvconf.pid_file->used &&
srv->srvconf.changeroot->used == 0) {
if (0 != unlink(srv->srvconf.pid_file->ptr)) {
if (errno != EACCES && errno != EPERM) {
log_error_write(srv, __FILE__, __LINE__, "sbds",
"unlink failed for:",
srv->srvconf.pid_file,
errno,
strerror(errno));
}
}
}
}
}
if (graceful_shutdown) {
log_error_write(srv, __FILE__, __LINE__, "s", "[note] graceful shutdown started");
} else if (srv->conns->used >= srv->max_conns) {
log_error_write(srv, __FILE__, __LINE__, "s", "[note] sockets disabled, connection limit reached");
} else {
log_error_write(srv, __FILE__, __LINE__, "s", "[note] sockets disabled, out-of-fds");
}
srv->sockets_disabled = 1;
}
}
if (graceful_shutdown && srv->conns->used == 0) {
/* we are in graceful shutdown phase and all connections are closed
* we are ready to terminate without harming anyone */
srv_shutdown = 1;
}
/* we still have some fds to share */
if (srv->want_fds) {
/* check the fdwaitqueue for waiting fds */
int free_fds = srv->max_fds - srv->cur_fds - 16;
connection *con;
for (; free_fds > 0 && NULL != (con = fdwaitqueue_unshift(srv, srv->fdwaitqueue)); free_fds--) {
connection_state_machine(srv, con);
srv->want_fds--;
}
}
if ((n = fdevent_poll(srv->ev, 1000)) > 0) {
/* n is the number of events */
int revents;
int fd_ndx;
#if 0
if (n > 0) {
log_error_write(srv, __FILE__, __LINE__, "sd",
"polls:", n);
}
#endif
fd_ndx = -1;
do {
fdevent_handler handler;
void *context;
handler_t r;
fd_ndx = fdevent_event_next_fdndx (srv->ev, fd_ndx);
if (-1 == fd_ndx) break; /* not all fdevent handlers know how many fds got an event */
revents = fdevent_event_get_revent (srv->ev, fd_ndx);
fd = fdevent_event_get_fd (srv->ev, fd_ndx);
handler = fdevent_get_handler(srv->ev, fd);
context = fdevent_get_context(srv->ev, fd);
/* connection_handle_fdevent needs a joblist_append */
#if 0
log_error_write(srv, __FILE__, __LINE__, "sdd",
"event for", fd, revents);
#endif
switch (r = (*handler)(srv, context, revents)) {
case HANDLER_FINISHED:
case HANDLER_GO_ON:
case HANDLER_WAIT_FOR_EVENT:
case HANDLER_WAIT_FOR_FD:
break;
case HANDLER_ERROR:
/* should never happen */
SEGFAULT();
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
} while (--n > 0);
} else if (n < 0 && errno != EINTR) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"fdevent_poll failed:",
strerror(errno));
}
for (ndx = 0; ndx < srv->joblist->used; ndx++) {
connection *con = srv->joblist->ptr[ndx];
handler_t r;
connection_state_machine(srv, con);
switch(r = plugins_call_handle_joblist(srv, con)) {
case HANDLER_FINISHED:
case HANDLER_GO_ON:
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
con->in_joblist = 0;
}
srv->joblist->used = 0;
}
if (srv->srvconf.pid_file->used &&
srv->srvconf.changeroot->used == 0 &&
0 == graceful_shutdown) {
if (0 != unlink(srv->srvconf.pid_file->ptr)) {
if (errno != EACCES && errno != EPERM) {
log_error_write(srv, __FILE__, __LINE__, "sbds",
"unlink failed for:",
srv->srvconf.pid_file,
errno,
strerror(errno));
}
}
}
#ifdef HAVE_SIGACTION
log_error_write(srv, __FILE__, __LINE__, "sdsd",
"server stopped by UID =",
last_sigterm_info.si_uid,
"PID =",
last_sigterm_info.si_pid);
#else
log_error_write(srv, __FILE__, __LINE__, "s",
"server stopped");
#endif
/* clean-up */
log_error_close(srv);
network_close(srv);
connections_free(srv);
plugins_free(srv);
server_free(srv);
return 0;
}
int
main(int argc, char *argv[], char *envp[])
{
#ifdef LISP_FEATURE_WIN32
/* Exception handling support structure. Evil Win32 hack. */
struct lisp_exception_frame exception_frame;
#endif
/* the name of the core file we're to execute. Note that this is
* a malloc'ed string which should be freed eventually. */
char *core = 0;
char **sbcl_argv = 0;
os_vm_offset_t embedded_core_offset = 0;
char *runtime_path = 0;
/* other command line options */
boolean noinform = 0;
boolean end_runtime_options = 0;
boolean disable_lossage_handler_p = 0;
lispobj initial_function;
const char *sbcl_home = getenv("SBCL_HOME");
interrupt_init();
block_blockable_signals(0, 0);
setlocale(LC_ALL, "");
runtime_options = NULL;
/* Check early to see if this executable has an embedded core,
* which also populates runtime_options if the core has runtime
* options */
runtime_path = os_get_runtime_executable_path();
if (runtime_path) {
os_vm_offset_t offset = search_for_embedded_core(runtime_path);
if (offset != -1) {
embedded_core_offset = offset;
core = runtime_path;
} else {
free(runtime_path);
}
}
/* Parse our part of the command line (aka "runtime options"),
* stripping out those options that we handle. */
if (runtime_options != NULL) {
dynamic_space_size = runtime_options->dynamic_space_size;
thread_control_stack_size = runtime_options->thread_control_stack_size;
sbcl_argv = argv;
} else {
int argi = 1;
runtime_options = successful_malloc(sizeof(struct runtime_options));
while (argi < argc) {
char *arg = argv[argi];
if (0 == strcmp(arg, "--script")) {
/* This is both a runtime and a toplevel option. As a
* runtime option, it is equivalent to --noinform.
* This exits, and does not increment argi, so that
* TOPLEVEL-INIT sees the option. */
noinform = 1;
end_runtime_options = 1;
disable_lossage_handler_p = 1;
lose_on_corruption_p = 1;
break;
} else if (0 == strcmp(arg, "--noinform")) {
noinform = 1;
++argi;
} else if (0 == strcmp(arg, "--core")) {
if (core) {
lose("more than one core file specified\n");
} else {
++argi;
if (argi >= argc) {
lose("missing filename for --core argument\n");
}
core = copied_string(argv[argi]);
++argi;
}
} else if (0 == strcmp(arg, "--help")) {
/* I think this is the (or a) usual convention: upon
* seeing "--help" we immediately print our help
* string and exit, ignoring everything else. */
print_help();
exit(0);
} else if (0 == strcmp(arg, "--version")) {
/* As in "--help" case, I think this is expected. */
print_version();
exit(0);
} else if (0 == strcmp(arg, "--dynamic-space-size")) {
++argi;
if (argi >= argc)
lose("missing argument for --dynamic-space-size");
errno = 0;
dynamic_space_size = strtol(argv[argi++], 0, 0) << 20;
if (errno)
lose("argument to --dynamic-space-size is not a number");
# ifdef MAX_DYNAMIC_SPACE_END
if (!((DYNAMIC_SPACE_START <
DYNAMIC_SPACE_START+dynamic_space_size) &&
(DYNAMIC_SPACE_START+dynamic_space_size <=
MAX_DYNAMIC_SPACE_END)))
lose("specified --dynamic-space-size too large");
# endif
} else if (0 == strcmp(arg, "--control-stack-size")) {
++argi;
if (argi >= argc)
lose("missing argument for --control-stack-size");
errno = 0;
thread_control_stack_size = strtol(argv[argi++], 0, 0) << 20;
if (errno)
lose("argument to --control-stack-size is not a number");
} else if (0 == strcmp(arg, "--debug-environment")) {
int n = 0;
printf("; Commandline arguments:\n");
while (n < argc) {
printf("; %2d: \"%s\"\n", n, argv[n]);
++n;
}
n = 0;
printf(";\n; Environment:\n");
while (ENVIRON[n]) {
printf("; %2d: \"%s\"\n", n, ENVIRON[n]);
++n;
}
++argi;
} else if (0 == strcmp(arg, "--disable-ldb")) {
disable_lossage_handler_p = 1;
++argi;
} else if (0 == strcmp(arg, "--lose-on-corruption")) {
lose_on_corruption_p = 1;
++argi;
} else if (0 == strcmp(arg, "--end-runtime-options")) {
end_runtime_options = 1;
++argi;
break;
} else {
/* This option was unrecognized as a runtime option,
* so it must be a toplevel option or a user option,
* so we must be past the end of the runtime option
* section. */
break;
}
}
/* This is where we strip out those options that we handle. We
* also take this opportunity to make sure that we don't find
* an out-of-place "--end-runtime-options" option. */
{
char *argi0 = argv[argi];
int argj = 1;
/* (argc - argi) for the arguments, one for the binary,
and one for the terminating NULL. */
sbcl_argv = successful_malloc((2 + argc - argi) * sizeof(char *));
sbcl_argv[0] = argv[0];
while (argi < argc) {
char *arg = argv[argi++];
/* If we encounter --end-runtime-options for the first
* time after the point where we had to give up on
* runtime options, then the point where we had to
* give up on runtime options must've been a user
* error. */
if (!end_runtime_options &&
0 == strcmp(arg, "--end-runtime-options")) {
lose("bad runtime option \"%s\"\n", argi0);
}
sbcl_argv[argj++] = arg;
}
sbcl_argv[argj] = 0;
}
}
/* Align down to multiple of page_table page size, and to the appropriate
* stack alignment. */
dynamic_space_size &= ~(PAGE_BYTES-1);
thread_control_stack_size &= ~(CONTROL_STACK_ALIGNMENT_BYTES-1);
/* Preserve the runtime options for possible future core saving */
runtime_options->dynamic_space_size = dynamic_space_size;
runtime_options->thread_control_stack_size = thread_control_stack_size;
/* KLUDGE: os_vm_page_size is set by os_init(), and on some
* systems (e.g. Alpha) arch_init() needs need os_vm_page_size, so
* it must follow os_init(). -- WHN 2000-01-26 */
os_init(argv, envp);
arch_init();
gc_init();
validate();
/* If no core file was specified, look for one. */
if (!core) {
core = search_for_core();
}
/* Make sure that SBCL_HOME is set and not the empty string,
unless loading an embedded core. */
if (!(sbcl_home && *sbcl_home) && embedded_core_offset == 0) {
char *envstring, *copied_core, *dir;
char *stem = "SBCL_HOME=";
copied_core = copied_string(core);
dir = dirname(copied_core);
envstring = (char *) calloc(strlen(stem) +
strlen(dir) +
1,
sizeof(char));
sprintf(envstring, "%s%s", stem, dir);
putenv(envstring);
free(copied_core);
}
if (!noinform && embedded_core_offset == 0) {
print_banner();
fflush(stdout);
}
#if defined(SVR4) || defined(__linux__)
tzset();
#endif
define_var("nil", NIL, 1);
define_var("t", T, 1);
if (!disable_lossage_handler_p)
enable_lossage_handler();
globals_init();
initial_function = load_core_file(core, embedded_core_offset);
if (initial_function == NIL) {
lose("couldn't find initial function\n");
}
#ifdef LISP_FEATURE_HPUX
/* -1 = CLOSURE_FUN_OFFSET, 23 = SIMPLE_FUN_CODE_OFFSET, we are
* not in LANGUAGE_ASSEMBLY so we cant reach them. */
return_from_lisp_stub = (void *) ((char *)*((unsigned long *)
((char *)initial_function + -1)) + 23);
#endif
gc_initialize_pointers();
arch_install_interrupt_handlers();
#ifndef LISP_FEATURE_WIN32
os_install_interrupt_handlers();
#else
/* wos_install_interrupt_handlers(handler); */
wos_install_interrupt_handlers(&exception_frame);
#endif
/* Pass core filename and the processed argv into Lisp. They'll
* need to be processed further there, to do locale conversion.
*/
core_string = core;
posix_argv = sbcl_argv;
FSHOW((stderr, "/funcalling initial_function=0x%lx\n",
(unsigned long)initial_function));
#ifdef LISP_FEATURE_WIN32
fprintf(stderr, "\n\
This is experimental prerelease support for the Windows platform: use\n\
at your own risk. \"Your Kitten of Death awaits!\"\n");
fflush(stdout);
fflush(stderr);
#endif
create_initial_thread(initial_function);
lose("CATS. CATS ARE NICE.\n");
return 0;
}
int
main(int argc, char *argv[])
{
/* Scratch variables... */
int c;
pid_t oldpid;
size_t i;
struct sigaction action;
#ifdef HAVE_GETPWNAM
struct passwd *pwd = NULL;
#endif /* HAVE_GETPWNAM */
/* For initialising the address info structures */
/* static so it can get very big without overflowing the stack */
static struct addrinfo hints[MAX_INTERFACES];
static const char *nodes[MAX_INTERFACES];
const char *udp_port = 0;
const char *tcp_port = 0;
const char *configfile = CONFIGFILE;
char* argv0 = (argv0 = strrchr(argv[0], '/')) ? argv0 + 1 : argv[0];
log_init(argv0);
/* Initialize the server handler... */
memset(&nsd, 0, sizeof(struct nsd));
nsd.region = region_create(xalloc, free);
nsd.dbfile = 0;
nsd.pidfile = 0;
nsd.server_kind = NSD_SERVER_MAIN;
for (i = 0; i < MAX_INTERFACES; i++) {
memset(&hints[i], 0, sizeof(hints[i]));
hints[i].ai_family = DEFAULT_AI_FAMILY;
hints[i].ai_flags = AI_PASSIVE;
nodes[i] = NULL;
}
nsd.identity = 0;
nsd.version = VERSION;
nsd.username = 0;
nsd.chrootdir = 0;
nsd.nsid = NULL;
nsd.nsid_len = 0;
nsd.child_count = 0;
nsd.maximum_tcp_count = 0;
nsd.current_tcp_count = 0;
nsd.grab_ip6_optional = 0;
nsd.file_rotation_ok = 0;
/* Set up our default identity to gethostname(2) */
if (gethostname(hostname, MAXHOSTNAMELEN) == 0) {
nsd.identity = hostname;
} else {
log_msg(LOG_ERR,
"failed to get the host name: %s - using default identity",
strerror(errno));
nsd.identity = IDENTITY;
}
/* Parse the command line... */
while ((c = getopt(argc, argv, "46a:c:df:hi:I:l:N:n:P:p:s:u:t:X:V:v"
#ifndef NDEBUG /* <mattthijs> only when configured with --enable-checking */
"F:L:"
#endif /* NDEBUG */
)) != -1) {
switch (c) {
case '4':
for (i = 0; i < MAX_INTERFACES; ++i) {
hints[i].ai_family = AF_INET;
}
break;
case '6':
#ifdef INET6
for (i = 0; i < MAX_INTERFACES; ++i) {
hints[i].ai_family = AF_INET6;
}
#else /* !INET6 */
error("IPv6 support not enabled.");
#endif /* INET6 */
break;
case 'a':
if (nsd.ifs < MAX_INTERFACES) {
nodes[nsd.ifs] = optarg;
++nsd.ifs;
} else {
error("too many interfaces ('-a') specified.");
}
break;
case 'c':
configfile = optarg;
break;
case 'd':
nsd.debug = 1;
break;
case 'f':
nsd.dbfile = optarg;
break;
case 'h':
usage();
exit(0);
case 'i':
nsd.identity = optarg;
break;
case 'I':
if (nsd.nsid_len != 0) {
/* can only be given once */
break;
}
if (strncasecmp(optarg, "ascii_", 6) == 0) {
nsd.nsid = xalloc(strlen(optarg+6));
nsd.nsid_len = strlen(optarg+6);
memmove(nsd.nsid, optarg+6, nsd.nsid_len);
} else {
if (strlen(optarg) % 2 != 0) {
error("the NSID must be a hex string of an even length.");
}
nsd.nsid = xalloc(strlen(optarg) / 2);
nsd.nsid_len = strlen(optarg) / 2;
if (hex_pton(optarg, nsd.nsid, nsd.nsid_len) == -1) {
error("hex string cannot be parsed '%s' in NSID.", optarg);
}
}
break;
case 'l':
nsd.log_filename = optarg;
break;
case 'N':
i = atoi(optarg);
if (i <= 0) {
error("number of child servers must be greater than zero.");
} else {
nsd.child_count = i;
}
break;
case 'n':
i = atoi(optarg);
if (i <= 0) {
error("number of concurrent TCP connections must greater than zero.");
} else {
nsd.maximum_tcp_count = i;
}
break;
case 'P':
nsd.pidfile = optarg;
break;
case 'p':
if (atoi(optarg) == 0) {
error("port argument must be numeric.");
}
tcp_port = optarg;
udp_port = optarg;
break;
case 's':
#ifdef BIND8_STATS
nsd.st.period = atoi(optarg);
#else /* !BIND8_STATS */
error("BIND 8 statistics not enabled.");
#endif /* BIND8_STATS */
break;
case 't':
#ifdef HAVE_CHROOT
nsd.chrootdir = optarg;
#else /* !HAVE_CHROOT */
error("chroot not supported on this platform.");
#endif /* HAVE_CHROOT */
break;
case 'u':
nsd.username = optarg;
break;
case 'V':
verbosity = atoi(optarg);
break;
case 'v':
version();
/* version exits */
#ifndef NDEBUG
case 'F':
sscanf(optarg, "%x", &nsd_debug_facilities);
break;
case 'L':
sscanf(optarg, "%d", &nsd_debug_level);
break;
#endif /* NDEBUG */
case '?':
default:
usage();
exit(1);
}
}
argc -= optind;
argv += optind;
/* Commandline parse error */
if (argc != 0) {
usage();
exit(1);
}
if (strlen(nsd.identity) > UCHAR_MAX) {
error("server identity too long (%u characters)",
(unsigned) strlen(nsd.identity));
}
if(!tsig_init(nsd.region))
error("init tsig failed");
/* Read options */
nsd.options = nsd_options_create(region_create_custom(xalloc, free,
DEFAULT_CHUNK_SIZE, DEFAULT_LARGE_OBJECT_SIZE,
DEFAULT_INITIAL_CLEANUP_SIZE, 1));
if(!parse_options_file(nsd.options, configfile, NULL, NULL)) {
error("could not read config: %s\n", configfile);
}
if(!parse_zone_list_file(nsd.options)) {
error("could not read zonelist file %s\n",
nsd.options->zonelistfile);
}
if(nsd.options->do_ip4 && !nsd.options->do_ip6) {
for (i = 0; i < MAX_INTERFACES; ++i) {
hints[i].ai_family = AF_INET;
}
}
#ifdef INET6
if(nsd.options->do_ip6 && !nsd.options->do_ip4) {
for (i = 0; i < MAX_INTERFACES; ++i) {
hints[i].ai_family = AF_INET6;
}
}
#endif /* INET6 */
if(nsd.options->ip_addresses)
{
ip_address_option_t* ip = nsd.options->ip_addresses;
while(ip) {
if (nsd.ifs < MAX_INTERFACES) {
nodes[nsd.ifs] = ip->address;
++nsd.ifs;
} else {
error("too many interfaces ('-a' + "
"'ip-address:') specified.");
break;
}
ip = ip->next;
}
}
if (verbosity == 0)
verbosity = nsd.options->verbosity;
#ifndef NDEBUG
if (nsd_debug_level > 0 && verbosity == 0)
verbosity = nsd_debug_level;
#endif /* NDEBUG */
if(nsd.options->debug_mode) nsd.debug=1;
if(!nsd.dbfile)
{
if(nsd.options->database)
nsd.dbfile = nsd.options->database;
else
nsd.dbfile = DBFILE;
}
if(!nsd.pidfile)
{
if(nsd.options->pidfile)
nsd.pidfile = nsd.options->pidfile;
else
nsd.pidfile = PIDFILE;
}
if(strcmp(nsd.identity, hostname)==0 || strcmp(nsd.identity,IDENTITY)==0)
{
if(nsd.options->identity)
nsd.identity = nsd.options->identity;
}
if (nsd.options->logfile && !nsd.log_filename) {
nsd.log_filename = nsd.options->logfile;
}
if(nsd.child_count == 0) {
nsd.child_count = nsd.options->server_count;
}
if(nsd.maximum_tcp_count == 0) {
nsd.maximum_tcp_count = nsd.options->tcp_count;
}
nsd.tcp_timeout = nsd.options->tcp_timeout;
nsd.tcp_query_count = nsd.options->tcp_query_count;
nsd.ipv4_edns_size = nsd.options->ipv4_edns_size;
nsd.ipv6_edns_size = nsd.options->ipv6_edns_size;
if(udp_port == 0)
{
if(nsd.options->port != 0) {
udp_port = nsd.options->port;
tcp_port = nsd.options->port;
} else {
udp_port = UDP_PORT;
tcp_port = TCP_PORT;
}
}
#ifdef BIND8_STATS
if(nsd.st.period == 0) {
nsd.st.period = nsd.options->statistics;
}
#endif /* BIND8_STATS */
#ifdef HAVE_CHROOT
if(nsd.chrootdir == 0) nsd.chrootdir = nsd.options->chroot;
#ifdef CHROOTDIR
/* if still no chrootdir, fallback to default */
if(nsd.chrootdir == 0) nsd.chrootdir = CHROOTDIR;
#endif /* CHROOTDIR */
#endif /* HAVE_CHROOT */
if(nsd.username == 0) {
if(nsd.options->username) nsd.username = nsd.options->username;
else nsd.username = USER;
}
if(nsd.options->zonesdir && nsd.options->zonesdir[0]) {
if(chdir(nsd.options->zonesdir)) {
error("cannot chdir to '%s': %s",
nsd.options->zonesdir, strerror(errno));
}
DEBUG(DEBUG_IPC,1, (LOG_INFO, "changed directory to %s",
nsd.options->zonesdir));
}
/* EDNS0 */
edns_init_data(&nsd.edns_ipv4, nsd.options->ipv4_edns_size);
#if defined(INET6)
#if defined(IPV6_USE_MIN_MTU) || defined(IPV6_MTU)
edns_init_data(&nsd.edns_ipv6, nsd.options->ipv6_edns_size);
#else /* no way to set IPV6 MTU, send no bigger than that. */
if (nsd.options->ipv6_edns_size < IPV6_MIN_MTU)
edns_init_data(&nsd.edns_ipv6, nsd.options->ipv6_edns_size);
else
edns_init_data(&nsd.edns_ipv6, IPV6_MIN_MTU);
#endif /* IPV6 MTU) */
#endif /* defined(INET6) */
if (nsd.nsid_len == 0 && nsd.options->nsid) {
if (strlen(nsd.options->nsid) % 2 != 0) {
error("the NSID must be a hex string of an even length.");
}
nsd.nsid = xalloc(strlen(nsd.options->nsid) / 2);
nsd.nsid_len = strlen(nsd.options->nsid) / 2;
if (hex_pton(nsd.options->nsid, nsd.nsid, nsd.nsid_len) == -1) {
error("hex string cannot be parsed '%s' in NSID.", nsd.options->nsid);
}
}
edns_init_nsid(&nsd.edns_ipv4, nsd.nsid_len);
#if defined(INET6)
edns_init_nsid(&nsd.edns_ipv6, nsd.nsid_len);
#endif /* defined(INET6) */
/* Number of child servers to fork. */
nsd.children = (struct nsd_child *) region_alloc_array(
nsd.region, nsd.child_count, sizeof(struct nsd_child));
for (i = 0; i < nsd.child_count; ++i) {
nsd.children[i].kind = NSD_SERVER_BOTH;
nsd.children[i].pid = -1;
nsd.children[i].child_fd = -1;
nsd.children[i].parent_fd = -1;
nsd.children[i].handler = NULL;
nsd.children[i].need_to_send_STATS = 0;
nsd.children[i].need_to_send_QUIT = 0;
nsd.children[i].need_to_exit = 0;
nsd.children[i].has_exited = 0;
}
nsd.this_child = NULL;
/* We need at least one active interface */
if (nsd.ifs == 0) {
nsd.ifs = 1;
/*
* With IPv6 we'd like to open two separate sockets,
* one for IPv4 and one for IPv6, both listening to
* the wildcard address (unless the -4 or -6 flags are
* specified).
*
* However, this is only supported on platforms where
* we can turn the socket option IPV6_V6ONLY _on_.
* Otherwise we just listen to a single IPv6 socket
* and any incoming IPv4 connections will be
* automatically mapped to our IPv6 socket.
*/
#ifdef INET6
if (hints[0].ai_family == AF_UNSPEC) {
#ifdef IPV6_V6ONLY
hints[0].ai_family = AF_INET6;
hints[1].ai_family = AF_INET;
nsd.ifs = 2;
nsd.grab_ip6_optional = 1;
#else /* !IPV6_V6ONLY */
hints[0].ai_family = AF_INET6;
#endif /* IPV6_V6ONLY */
}
#endif /* INET6 */
}
/* Set up the address info structures with real interface/port data */
for (i = 0; i < nsd.ifs; ++i) {
int r;
const char* node = NULL;
const char* service = NULL;
/* We don't perform name-lookups */
if (nodes[i] != NULL)
hints[i].ai_flags |= AI_NUMERICHOST;
get_ip_port_frm_str(nodes[i], &node, &service);
hints[i].ai_socktype = SOCK_DGRAM;
if ((r=getaddrinfo(node, (service?service:udp_port), &hints[i], &nsd.udp[i].addr)) != 0) {
#ifdef INET6
if(nsd.grab_ip6_optional && hints[0].ai_family == AF_INET6) {
log_msg(LOG_WARNING, "No IPv6, fallback to IPv4. getaddrinfo: %s",
r==EAI_SYSTEM?strerror(errno):gai_strerror(r));
continue;
}
#endif
error("cannot parse address '%s': getaddrinfo: %s %s",
nodes[i]?nodes[i]:"(null)",
gai_strerror(r),
r==EAI_SYSTEM?strerror(errno):"");
}
hints[i].ai_socktype = SOCK_STREAM;
if ((r=getaddrinfo(node, (service?service:tcp_port), &hints[i], &nsd.tcp[i].addr)) != 0) {
error("cannot parse address '%s': getaddrinfo: %s %s",
nodes[i]?nodes[i]:"(null)",
gai_strerror(r),
r==EAI_SYSTEM?strerror(errno):"");
}
}
/* Parse the username into uid and gid */
nsd.gid = getgid();
nsd.uid = getuid();
#ifdef HAVE_GETPWNAM
/* Parse the username into uid and gid */
if (*nsd.username) {
if (isdigit((unsigned char)*nsd.username)) {
char *t;
nsd.uid = strtol(nsd.username, &t, 10);
if (*t != 0) {
if (*t != '.' || !isdigit((unsigned char)*++t)) {
error("-u user or -u uid or -u uid.gid");
}
nsd.gid = strtol(t, &t, 10);
} else {
/* Lookup the group id in /etc/passwd */
if ((pwd = getpwuid(nsd.uid)) == NULL) {
error("user id %u does not exist.", (unsigned) nsd.uid);
} else {
nsd.gid = pwd->pw_gid;
}
}
} else {
/* Lookup the user id in /etc/passwd */
if ((pwd = getpwnam(nsd.username)) == NULL) {
error("user '%s' does not exist.", nsd.username);
} else {
nsd.uid = pwd->pw_uid;
nsd.gid = pwd->pw_gid;
}
}
}
/* endpwent(); */
#endif /* HAVE_GETPWNAM */
#if defined(HAVE_SSL)
key_options_tsig_add(nsd.options);
#endif
append_trailing_slash(&nsd.options->xfrdir, nsd.options->region);
/* Check relativity of pathnames to chroot */
if (nsd.chrootdir && nsd.chrootdir[0]) {
/* existing chrootdir: append trailing slash for strncmp checking */
append_trailing_slash(&nsd.chrootdir, nsd.region);
append_trailing_slash(&nsd.options->zonesdir, nsd.options->region);
/* zonesdir must be absolute and within chroot,
* all other pathnames may be relative to zonesdir */
if (strncmp(nsd.options->zonesdir, nsd.chrootdir, strlen(nsd.chrootdir)) != 0) {
error("zonesdir %s has to be an absolute path that starts with the chroot path %s",
nsd.options->zonesdir, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.pidfile, nsd.chrootdir)) {
error("pidfile %s is not relative to %s: chroot not possible",
nsd.pidfile, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.dbfile, nsd.chrootdir)) {
error("database %s is not relative to %s: chroot not possible",
nsd.dbfile, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.options->xfrdfile, nsd.chrootdir)) {
error("xfrdfile %s is not relative to %s: chroot not possible",
nsd.options->xfrdfile, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.options->zonelistfile, nsd.chrootdir)) {
error("zonelistfile %s is not relative to %s: chroot not possible",
nsd.options->zonelistfile, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.options->xfrdir, nsd.chrootdir)) {
error("xfrdir %s is not relative to %s: chroot not possible",
nsd.options->xfrdir, nsd.chrootdir);
}
}
/* Set up the logging */
log_open(LOG_PID, FACILITY, nsd.log_filename);
if (!nsd.log_filename)
log_set_log_function(log_syslog);
else if (nsd.uid && nsd.gid) {
if(chown(nsd.log_filename, nsd.uid, nsd.gid) != 0)
VERBOSITY(2, (LOG_WARNING, "chown %s failed: %s",
nsd.log_filename, strerror(errno)));
}
/* Do we have a running nsd? */
if ((oldpid = readpid(nsd.pidfile)) == -1) {
if (errno != ENOENT) {
log_msg(LOG_ERR, "can't read pidfile %s: %s",
nsd.pidfile, strerror(errno));
}
} else {
if (kill(oldpid, 0) == 0 || errno == EPERM) {
log_msg(LOG_WARNING,
"%s is already running as %u, continuing",
argv0, (unsigned) oldpid);
} else {
log_msg(LOG_ERR,
"...stale pid file from process %u",
(unsigned) oldpid);
}
}
/* Setup the signal handling... */
action.sa_handler = sig_handler;
sigfillset(&action.sa_mask);
action.sa_flags = 0;
sigaction(SIGTERM, &action, NULL);
sigaction(SIGHUP, &action, NULL);
sigaction(SIGINT, &action, NULL);
sigaction(SIGILL, &action, NULL);
sigaction(SIGUSR1, &action, NULL);
sigaction(SIGALRM, &action, NULL);
sigaction(SIGCHLD, &action, NULL);
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
/* Initialize... */
nsd.mode = NSD_RUN;
nsd.signal_hint_child = 0;
nsd.signal_hint_reload = 0;
nsd.signal_hint_reload_hup = 0;
nsd.signal_hint_quit = 0;
nsd.signal_hint_shutdown = 0;
nsd.signal_hint_stats = 0;
nsd.signal_hint_statsusr = 0;
nsd.quit_sync_done = 0;
/* Initialize the server... */
if (server_init(&nsd) != 0) {
error("server initialization failed, %s could "
"not be started", argv0);
}
#if defined(HAVE_SSL)
if(nsd.options->control_enable) {
/* read ssl keys while superuser and outside chroot */
if(!(nsd.rc = daemon_remote_create(nsd.options)))
error("could not perform remote control setup");
}
#endif /* HAVE_SSL */
/* Unless we're debugging, fork... */
if (!nsd.debug) {
int fd;
/* Take off... */
switch ((nsd.pid = fork())) {
case 0:
/* Child */
break;
case -1:
error("fork() failed: %s", strerror(errno));
default:
/* Parent is done */
server_close_all_sockets(nsd.udp, nsd.ifs);
server_close_all_sockets(nsd.tcp, nsd.ifs);
exit(0);
}
/* Detach ourselves... */
if (setsid() == -1) {
error("setsid() failed: %s", strerror(errno));
}
if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
(void)dup2(fd, STDIN_FILENO);
(void)dup2(fd, STDOUT_FILENO);
(void)dup2(fd, STDERR_FILENO);
if (fd > 2)
(void)close(fd);
}
}
/* Get our process id */
nsd.pid = getpid();
/* Set user context */
#ifdef HAVE_GETPWNAM
if (*nsd.username) {
#ifdef HAVE_SETUSERCONTEXT
/* setusercontext does initgroups, setuid, setgid, and
* also resource limits from login config, but we
* still call setresuid, setresgid to be sure to set all uid */
if (setusercontext(NULL, pwd, nsd.uid,
LOGIN_SETALL & ~LOGIN_SETUSER & ~LOGIN_SETGROUP) != 0)
log_msg(LOG_WARNING, "unable to setusercontext %s: %s",
nsd.username, strerror(errno));
#endif /* HAVE_SETUSERCONTEXT */
}
#endif /* HAVE_GETPWNAM */
/* Chroot */
#ifdef HAVE_CHROOT
if (nsd.chrootdir && nsd.chrootdir[0]) {
int l = strlen(nsd.chrootdir)-1; /* ends in trailing slash */
if (file_inside_chroot(nsd.log_filename, nsd.chrootdir))
nsd.file_rotation_ok = 1;
/* strip chroot from pathnames if they're absolute */
nsd.options->zonesdir += l;
if (nsd.log_filename){
if (nsd.log_filename[0] == '/')
nsd.log_filename += l;
}
if (nsd.pidfile[0] == '/')
nsd.pidfile += l;
if (nsd.dbfile[0] == '/')
nsd.dbfile += l;
if (nsd.options->xfrdfile[0] == '/')
nsd.options->xfrdfile += l;
if (nsd.options->zonelistfile[0] == '/')
nsd.options->zonelistfile += l;
if (nsd.options->xfrdir[0] == '/')
nsd.options->xfrdir += l;
/* strip chroot from pathnames of "include:" statements
* on subsequent repattern commands */
cfg_parser->chroot = nsd.chrootdir;
#ifdef HAVE_TZSET
/* set timezone whilst not yet in chroot */
tzset();
#endif
if (chroot(nsd.chrootdir)) {
error("unable to chroot: %s", strerror(errno));
}
if (chdir("/")) {
error("unable to chdir to chroot: %s", strerror(errno));
}
DEBUG(DEBUG_IPC,1, (LOG_INFO, "changed root directory to %s",
nsd.chrootdir));
/* chdir to zonesdir again after chroot */
if(nsd.options->zonesdir && nsd.options->zonesdir[0]) {
if(chdir(nsd.options->zonesdir)) {
error("unable to chdir to '%s': %s",
nsd.options->zonesdir, strerror(errno));
}
DEBUG(DEBUG_IPC,1, (LOG_INFO, "changed directory to %s",
nsd.options->zonesdir));
}
}
else
#endif /* HAVE_CHROOT */
nsd.file_rotation_ok = 1;
DEBUG(DEBUG_IPC,1, (LOG_INFO, "file rotation on %s %sabled",
nsd.log_filename, nsd.file_rotation_ok?"en":"dis"));
/* Write pidfile */
if (writepid(&nsd) == -1) {
log_msg(LOG_ERR, "cannot overwrite the pidfile %s: %s",
nsd.pidfile, strerror(errno));
}
/* Drop the permissions */
#ifdef HAVE_GETPWNAM
if (*nsd.username) {
#ifdef HAVE_INITGROUPS
if(initgroups(nsd.username, nsd.gid) != 0)
log_msg(LOG_WARNING, "unable to initgroups %s: %s",
nsd.username, strerror(errno));
#endif /* HAVE_INITGROUPS */
endpwent();
#ifdef HAVE_SETRESGID
if(setresgid(nsd.gid,nsd.gid,nsd.gid) != 0)
#elif defined(HAVE_SETREGID) && !defined(DARWIN_BROKEN_SETREUID)
if(setregid(nsd.gid,nsd.gid) != 0)
#else /* use setgid */
if(setgid(nsd.gid) != 0)
#endif /* HAVE_SETRESGID */
error("unable to set group id of %s: %s",
nsd.username, strerror(errno));
#ifdef HAVE_SETRESUID
if(setresuid(nsd.uid,nsd.uid,nsd.uid) != 0)
#elif defined(HAVE_SETREUID) && !defined(DARWIN_BROKEN_SETREUID)
if(setreuid(nsd.uid,nsd.uid) != 0)
#else /* use setuid */
if(setuid(nsd.uid) != 0)
#endif /* HAVE_SETRESUID */
error("unable to set user id of %s: %s",
nsd.username, strerror(errno));
DEBUG(DEBUG_IPC,1, (LOG_INFO, "dropped user privileges, run as %s",
nsd.username));
}
#endif /* HAVE_GETPWNAM */
xfrd_make_tempdir(&nsd);
#ifdef USE_ZONE_STATS
options_zonestatnames_create(nsd.options);
server_zonestat_alloc(&nsd);
#endif /* USE_ZONE_STATS */
if(nsd.server_kind == NSD_SERVER_MAIN) {
server_prepare_xfrd(&nsd);
/* xfrd forks this before reading database, so it does not get
* the memory size of the database */
server_start_xfrd(&nsd, 0, 0);
}
if (server_prepare(&nsd) != 0) {
unlinkpid(nsd.pidfile);
error("server preparation failed, %s could "
"not be started", argv0);
}
if(nsd.server_kind == NSD_SERVER_MAIN) {
server_send_soa_xfrd(&nsd, 0);
}
/* Really take off */
log_msg(LOG_NOTICE, "%s started (%s), pid %d",
argv0, PACKAGE_STRING, (int) nsd.pid);
if (nsd.server_kind == NSD_SERVER_MAIN) {
server_main(&nsd);
} else {
server_child(&nsd);
}
/* NOTREACH */
exit(0);
}
/*
* int
* main(int argc, char **argv)
* Start routine of unc_dmctl command.
*/
int
main(int argc, char **argv)
{
pfc_cmdopt_t *parser;
cmdspec_t *spec;
const char *conffile = UNCD_CONF_PATH;
int argidx, ret;
char c;
/* Use C locale. */
(void)setlocale(LC_ALL, "C");
/* Set timezone. */
tzset();
/* Initialize signal. */
signal_init();
/* Create command line option parser. */
parser = pfc_cmdopt_init(PROGNAME, argc, argv, option_spec,
arg_format, 0);
if (PFC_EXPECT_FALSE(parser == NULL)) {
fatal("Failed to create option parser.");
/* NOTREACHED */
}
while ((c = pfc_cmdopt_next(parser)) != PFC_CMDOPT_EOF) {
switch (c) {
case OPTCHAR_CONF:
conffile = pfc_cmdopt_arg_string(parser);
if (PFC_EXPECT_FALSE(*conffile == '\0')) {
fatal("Configuration file path is empty.");
/* NOTREACHED */
}
break;
case OPTCHAR_TIMEOUT:
ipc_timeout = pfc_cmdopt_arg_uint32(parser);
if (PFC_EXPECT_FALSE(ipc_timeout <
IPC_TIMEOUT_MIN)) {
fatal("-%c: Timeout value must be greater than "
"or equal %u.", OPTCHAR_TIMEOUT,
IPC_TIMEOUT_MIN);
/* NOTREACHED */
}
else if (PFC_EXPECT_FALSE(ipc_timeout >
IPC_TIMEOUT_MAX)) {
fatal("-%c: Timeout value must be less than "
"or equal %u.", OPTCHAR_TIMEOUT,
IPC_TIMEOUT_MAX);
/* NOTREACHED */
}
break;
case OPTCHAR_CHANNEL:
ipc_channel = pfc_cmdopt_arg_string(parser);
if (PFC_EXPECT_FALSE(*ipc_channel == '\0')) {
fatal("-%c: IPC channel name must not be "
"empty.", OPTCHAR_CHANNEL);
/* NOTREACHED */
}
break;
case OPTCHAR_DEBUG:
debug_level++;
break;
case OPTCHAR_VERSION:
dump_version();
/* NOTREACHED */
case PFC_CMDOPT_USAGE:
pfc_cmdopt_usage(parser, stdout);
exit(DMCTL_EX_OK);
/* NOTREACHED */
case PFC_CMDOPT_HELP:
pfc_cmdopt_help(parser, stdout, HELP_MESSAGE);
exit(DMCTL_EX_OK);
/* NOTREACHED */
case PFC_CMDOPT_ERROR:
exit(DMCTL_EX_FATAL);
/* NOTREACHED */
default:
fatal("Failed to parse command line options.");
/* NOTREACHED */
}
}
if ((argidx = pfc_cmdopt_validate(parser)) == -1) {
fatal("Invalid command line options.");
/* NOTREACHED */
}
argc -= argidx;
argv += argidx;
if (argc == 0) {
dump_subcommands(parser);
/* NOTREACHED */
}
pfc_cmdopt_destroy(parser);
if (debug_level) {
pfc_log_conf_t cf;
pfc_log_level_t lvl = (debug_level == 1)
? PFC_LOGLVL_DEBUG
: PFC_LOGLVL_VERBOSE;
pfc_logconf_early(&cf, PFC_CFBLK_INVALID, PROGNAME, stderr,
lvl, NULL);
pfc_log_sysinit(&cf);
}
/* Determine subcommand. */
spec = subcmd_find(*argv);
if (PFC_EXPECT_FALSE(spec == NULL)) {
fatal("Unknown subcommand: %s", *argv);
/* NOTREACHED */
}
if (ipc_timeout == 0) {
/* Use default timeout. */
ipc_timeout = spec->cs_timeout;
}
/* Load system configuration file. */
sysconf_init(conffile);
if ((spec->cs_flags & CMDF_NOIPC) == 0) {
int err;
/* Initialize IPC client. */
err = ipc_init();
if (PFC_EXPECT_FALSE(err != 0)) {
return DMCTL_EX_FATAL;
}
}
/* Dispatch subcommand. */
current_cmd = spec;
ret = spec->cs_func(spec, argc, argv);
current_cmd = NULL;
/* Tear down the command. */
if ((spec->cs_flags & CMDF_NOIPC) == 0) {
ipc_fini();
}
dmconf_cleanup();
return ret;
}
/* XML metadata dumping */
static void xml_amf_data_dump(const amf_data * data, int qualified, int indent_level) {
if (data != NULL) {
amf_node * node;
time_t time;
struct tm * t;
char datestr[128];
int markers;
char * ns;
char ns_decl[50];
/* namespace to use whether we're using qualified mode */
ns = (qualified == 1) ? "amf:" : "";
/* if indent_level is zero, that means we're at the root of the xml document
therefore we need to insert the namespace definition */
if (indent_level == 0) {
sprintf(ns_decl, " xmlns%s=\"http://schemas.flvmeta.org/AMF0/1.0/\"", ns);
}
else {
strcpy(ns_decl, "");
}
/* print indentation spaces */
printf("%*s", indent_level * 2, "");
switch (data->type) {
case AMF_TYPE_NUMBER:
printf("<%snumber%s value=\"%.12g\"/>\n", ns, ns_decl, data->number_data);
break;
case AMF_TYPE_BOOLEAN:
printf("<%sboolean%s value=\"%s\"/>\n", ns, ns_decl, (data->boolean_data) ? "true" : "false");
break;
case AMF_TYPE_STRING:
if (amf_string_get_size(data) > 0) {
printf("<%sstring%s>", ns, ns_decl);
/* check whether the string contains xml characters, if so, CDATA it */
markers = has_xml_markers((char*)amf_string_get_bytes(data), amf_string_get_size(data));
if (markers) {
printf("<![CDATA[");
}
/* do not print more than the actual length of string */
printf("%.*s", (int)amf_string_get_size(data), amf_string_get_bytes(data));
if (markers) {
printf("]]>");
}
printf("</%sstring>\n", ns);
}
else {
/* simplify empty xml element into a more compact form */
printf("<%sstring%s/>\n", ns, ns_decl);
}
break;
case AMF_TYPE_OBJECT:
if (amf_object_size(data) > 0) {
printf("<%sobject%s>\n", ns, ns_decl);
node = amf_object_first(data);
while (node != NULL) {
printf("%*s<%sentry name=\"%s\">\n", (indent_level + 1) * 2, "", ns, amf_string_get_bytes(amf_object_get_name(node)));
xml_amf_data_dump(amf_object_get_data(node), qualified, indent_level + 2);
node = amf_object_next(node);
printf("%*s</%sentry>\n", (indent_level + 1) * 2, "", ns);
}
printf("%*s</%sobject>\n", indent_level * 2, "", ns);
}
else {
/* simplify empty xml element into a more compact form */
printf("<%sobject%s/>\n", ns, ns_decl);
}
break;
case AMF_TYPE_NULL:
printf("<%snull%s/>\n", ns, ns_decl);
break;
case AMF_TYPE_UNDEFINED:
printf("<%sundefined%s/>\n", ns, ns_decl);
break;
case AMF_TYPE_ASSOCIATIVE_ARRAY:
if (amf_associative_array_size(data) > 0) {
printf("<%sassociativeArray%s>\n", ns, ns_decl);
node = amf_associative_array_first(data);
while (node != NULL) {
printf("%*s<%sentry name=\"%s\">\n", (indent_level + 1) * 2, "", ns, amf_string_get_bytes(amf_associative_array_get_name(node)));
xml_amf_data_dump(amf_associative_array_get_data(node), qualified, indent_level + 2);
node = amf_associative_array_next(node);
printf("%*s</%sentry>\n", (indent_level + 1) * 2, "", ns);
}
printf("%*s</%sassociativeArray>\n", indent_level * 2, "", ns);
}
else {
/* simplify empty xml element into a more compact form */
printf("<%sassociativeArray%s/>\n", ns, ns_decl);
}
break;
case AMF_TYPE_ARRAY:
if (amf_array_size(data) > 0) {
printf("<%sarray%s>\n", ns, ns_decl);
node = amf_array_first(data);
while (node != NULL) {
xml_amf_data_dump(amf_array_get(node), qualified, indent_level + 1);
node = amf_array_next(node);
}
printf("%*s</%sarray>\n", indent_level * 2, "", ns);
}
else {
/* simplify empty xml element into a more compact form */
printf("<%sarray%s/>\n", ns, ns_decl);
}
break;
case AMF_TYPE_DATE:
time = amf_date_to_time_t(data);
tzset();
t = localtime(&time);
strftime(datestr, sizeof(datestr), "%Y-%m-%dT%H:%M:%S", t);
printf("<%sdate%s value=\"%s\"/>\n", ns, ns_decl, datestr);
break;
case AMF_TYPE_XML: break;
case AMF_TYPE_CLASS: break;
default: break;
}
}
}
time_t
timegm (struct tm *tm)
{
#ifdef HAVE_W32_SYSTEM
/* This one is thread safe. */
SYSTEMTIME st;
FILETIME ft;
unsigned long long cnsecs;
st.wYear = tm->tm_year + 1900;
st.wMonth = tm->tm_mon + 1;
st.wDay = tm->tm_mday;
st.wHour = tm->tm_hour;
st.wMinute = tm->tm_min;
st.wSecond = tm->tm_sec;
st.wMilliseconds = 0; /* Not available. */
st.wDayOfWeek = 0; /* Ignored. */
/* System time is UTC thus the conversion is pretty easy. */
if (!SystemTimeToFileTime (&st, &ft))
{
jnlib_set_errno (EINVAL);
return (time_t)(-1);
}
cnsecs = (((unsigned long long)ft.dwHighDateTime << 32)
| ft.dwLowDateTime);
cnsecs -= 116444736000000000ULL; /* The filetime epoch is 1601-01-01. */
return (time_t)(cnsecs / 10000000ULL);
#else /* (Non thread safe implementation!) */
time_t answer;
char *zone;
zone=getenv("TZ");
putenv("TZ=UTC");
tzset();
answer=mktime(tm);
if(zone)
{
static char *old_zone;
if (!old_zone)
{
old_zone = malloc(3+strlen(zone)+1);
if (old_zone)
{
strcpy(old_zone,"TZ=");
strcat(old_zone,zone);
}
}
if (old_zone)
putenv (old_zone);
}
else
gnupg_unsetenv("TZ");
tzset();
return answer;
#endif
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
char *opt; /* Option character */
int close_all = 1, /* Close all file descriptors? */
disconnect = 1, /* Disconnect from controlling terminal? */
fg = 0, /* Run in foreground? */
run_as_child = 0,
/* Running as child process? */
print_profile = 0;
/* Print the sandbox profile to stdout? */
int fds; /* Number of ready descriptors */
cupsd_client_t *con; /* Current client */
cupsd_job_t *job; /* Current job */
cupsd_listener_t *lis; /* Current listener */
time_t current_time, /* Current time */
activity, /* Client activity timer */
senddoc_time, /* Send-Document time */
expire_time, /* Subscription expire time */
report_time, /* Malloc/client/job report time */
event_time; /* Last event notification time */
long timeout; /* Timeout for cupsdDoSelect() */
struct rlimit limit; /* Runtime limit */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
#ifdef __APPLE__
int use_sysman = 1; /* Use system management functions? */
#else
time_t netif_time = 0; /* Time since last network update */
#endif /* __APPLE__ */
#if defined(HAVE_ONDEMAND)
int service_idle_exit;
/* Idle exit on select timeout? */
#endif /* HAVE_ONDEMAND */
#ifdef HAVE_GETEUID
/*
* Check for setuid invocation, which we do not support!
*/
if (getuid() != geteuid())
{
fputs("cupsd: Cannot run as a setuid program.\n", stderr);
return (1);
}
#endif /* HAVE_GETEUID */
/*
* Check for command-line arguments...
*/
fg = 0;
#ifdef HAVE_LAUNCHD
if (getenv("CUPSD_LAUNCHD"))
{
OnDemand = 1;
fg = 1;
close_all = 0;
disconnect = 0;
}
#endif /* HAVE_LAUNCHD */
for (i = 1; i < argc; i ++)
if (argv[i][0] == '-')
for (opt = argv[i] + 1; *opt != '\0'; opt ++)
switch (*opt)
{
case 'C' : /* Run as child with config file */
run_as_child = 1;
fg = 1;
close_all = 0;
case 'c' : /* Configuration file */
i ++;
if (i >= argc)
{
_cupsLangPuts(stderr, _("cupsd: Expected config filename "
"after \"-c\" option."));
usage(1);
}
if (argv[i][0] == '/')
{
/*
* Absolute directory...
*/
cupsdSetString(&ConfigurationFile, argv[i]);
}
else
{
/*
* Relative directory...
*/
char *current; /* Current directory */
/*
* Allocate a buffer for the current working directory to
* reduce run-time stack usage; this approximates the
* behavior of some implementations of getcwd() when they
* are passed a NULL pointer.
*/
if ((current = malloc(1024)) == NULL)
{
_cupsLangPuts(stderr,
_("cupsd: Unable to get current directory."));
return (1);
}
if (!getcwd(current, 1024))
{
_cupsLangPuts(stderr,
_("cupsd: Unable to get current directory."));
free(current);
return (1);
}
cupsdSetStringf(&ConfigurationFile, "%s/%s", current, argv[i]);
free(current);
}
break;
case 'f' : /* Run in foreground... */
fg = 1;
disconnect = 0;
close_all = 0;
break;
case 'F' : /* Run in foreground, but disconnect from terminal... */
fg = 1;
close_all = 0;
break;
case 'h' : /* Show usage/help */
usage(0);
break;
case 'l' : /* Started by launchd/systemd/upstart... */
#if defined(HAVE_ONDEMAND)
OnDemand = 1;
fg = 1;
close_all = 0;
disconnect = 0;
#else
_cupsLangPuts(stderr, _("cupsd: On-demand support not compiled "
"in, running in normal mode."));
fg = 0;
disconnect = 1;
close_all = 1;
#endif /* HAVE_ONDEMAND */
break;
case 'p' : /* Stop immediately for profiling */
fputs("cupsd: -p (startup profiling) is for internal testing "
"use only!\n", stderr);
stop_scheduler = 1;
fg = 1;
disconnect = 0;
close_all = 0;
break;
case 'P' : /* Disable security profiles */
fputs("cupsd: -P (disable sandboxing) is for internal testing use only.\n", stderr);
UseSandboxing = 0;
break;
case 's' : /* Set cups-files.conf location */
i ++;
if (i >= argc)
{
_cupsLangPuts(stderr, _("cupsd: Expected cups-files.conf "
"filename after \"-s\" option."));
usage(1);
}
if (argv[i][0] != '/')
{
/*
* Relative filename not allowed...
*/
_cupsLangPuts(stderr, _("cupsd: Relative cups-files.conf "
"filename not allowed."));
usage(1);
}
cupsdSetString(&CupsFilesFile, argv[i]);
break;
#ifdef __APPLE__
case 'S' : /* Disable system management functions */
fputs("cupsd: -S (disable system management) for internal "
"testing use only!\n", stderr);
use_sysman = 0;
break;
#endif /* __APPLE__ */
case 't' : /* Test the cupsd.conf file... */
TestConfigFile = 1;
fg = 1;
disconnect = 0;
close_all = 0;
break;
case 'T' : /* Print security profile */
print_profile = 1;
fg = 1;
disconnect = 0;
close_all = 0;
break;
default : /* Unknown option */
_cupsLangPrintf(stderr, _("cupsd: Unknown option \"%c\" - "
"aborting."), *opt);
usage(1);
break;
}
else
{
_cupsLangPrintf(stderr, _("cupsd: Unknown argument \"%s\" - aborting."),
argv[i]);
usage(1);
}
if (!ConfigurationFile)
cupsdSetString(&ConfigurationFile, CUPS_SERVERROOT "/cupsd.conf");
if (!CupsFilesFile)
{
char *filename, /* Copy of cupsd.conf filename */
*slash; /* Final slash in cupsd.conf filename */
size_t len; /* Size of buffer */
len = strlen(ConfigurationFile) + 15;
if ((filename = malloc(len)) == NULL)
{
_cupsLangPrintf(stderr,
_("cupsd: Unable to get path to "
"cups-files.conf file."));
return (1);
}
strlcpy(filename, ConfigurationFile, len);
if ((slash = strrchr(filename, '/')) == NULL)
{
_cupsLangPrintf(stderr,
_("cupsd: Unable to get path to "
"cups-files.conf file."));
return (1);
}
strlcpy(slash, "/cups-files.conf", len - (size_t)(slash - filename));
cupsdSetString(&CupsFilesFile, filename);
free(filename);
}
if (disconnect)
{
/*
* Make sure we aren't tying up any filesystems...
*/
chdir("/");
/*
* Disconnect from the controlling terminal...
*/
setsid();
}
if (close_all)
{
/*
* Close all open files...
*/
getrlimit(RLIMIT_NOFILE, &limit);
for (i = 0; i < (int)limit.rlim_cur && i < 1024; i ++)
close(i);
/*
* Redirect stdin/out/err to /dev/null...
*/
if ((i = open("/dev/null", O_RDONLY)) != 0)
{
dup2(i, 0);
close(i);
}
if ((i = open("/dev/null", O_WRONLY)) != 1)
{
dup2(i, 1);
close(i);
}
if ((i = open("/dev/null", O_WRONLY)) != 2)
{
dup2(i, 2);
close(i);
}
}
else
LogStderr = cupsFileStderr();
/*
* Run in the background as needed...
*/
if (!fg)
{
/*
* Setup signal handlers for the parent...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGUSR1, parent_handler);
sigset(SIGCHLD, parent_handler);
sigset(SIGHUP, SIG_IGN);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGUSR1);
action.sa_handler = parent_handler;
sigaction(SIGUSR1, &action, NULL);
sigaction(SIGCHLD, &action, NULL);
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGHUP, &action, NULL);
#else
signal(SIGUSR1, parent_handler);
signal(SIGCLD, parent_handler);
signal(SIGHUP, SIG_IGN);
#endif /* HAVE_SIGSET */
if (fork() > 0)
{
/*
* OK, wait for the child to startup and send us SIGUSR1 or to crash
* and the OS send us SIGCHLD... We also need to ignore SIGHUP which
* might be sent by the init script to restart the scheduler...
*/
for (; parent_signal == 0;)
sleep(1);
if (parent_signal == SIGUSR1)
return (0);
if (wait(&i) < 0)
{
perror("cupsd");
return (1);
}
else if (WIFEXITED(i))
{
fprintf(stderr, "cupsd: Child exited with status %d\n",
WEXITSTATUS(i));
return (2);
}
else
{
fprintf(stderr, "cupsd: Child exited on signal %d\n", WTERMSIG(i));
return (3);
}
}
#if defined(__OpenBSD__) && OpenBSD < 201211
/*
* Call _thread_sys_closefrom() so the child process doesn't reset the
* parent's file descriptors to be blocking. This is a workaround for a
* limitation of userland libpthread on older versions of OpenBSD.
*/
_thread_sys_closefrom(0);
#endif /* __OpenBSD__ && OpenBSD < 201211 */
/*
* Since many system libraries create fork-unsafe data on execution of a
* program, we need to re-execute the background cupsd with the "-C" and "-s"
* options to avoid problems. Unfortunately, we also have to assume that
* argv[0] contains the name of the cupsd executable - there is no portable
* way to get the real pathname...
*/
execlp(argv[0], argv[0], "-C", ConfigurationFile, "-s", CupsFilesFile, (char *)0);
exit(errno);
}
/*
* Set the timezone info...
*/
tzset();
#ifdef LC_TIME
setlocale(LC_TIME, "");
#endif /* LC_TIME */
#ifdef HAVE_DBUS_THREADS_INIT
/*
* Enable threading support for D-BUS...
*/
dbus_threads_init_default();
#endif /* HAVE_DBUS_THREADS_INIT */
/*
* Set the maximum number of files...
*/
getrlimit(RLIMIT_NOFILE, &limit);
#if !defined(HAVE_POLL) && !defined(HAVE_EPOLL) && !defined(HAVE_KQUEUE)
if (limit.rlim_max > FD_SETSIZE)
MaxFDs = FD_SETSIZE;
else
#endif /* !HAVE_POLL && !HAVE_EPOLL && !HAVE_KQUEUE */
#ifdef RLIM_INFINITY
if (limit.rlim_max == RLIM_INFINITY)
MaxFDs = 16384;
else
#endif /* RLIM_INFINITY */
MaxFDs = limit.rlim_max;
limit.rlim_cur = (rlim_t)MaxFDs;
setrlimit(RLIMIT_NOFILE, &limit);
cupsdStartSelect();
/*
* Read configuration...
*/
if (!cupsdReadConfiguration())
return (1);
else if (TestConfigFile)
{
printf("\"%s\" is OK.\n", CupsFilesFile);
printf("\"%s\" is OK.\n", ConfigurationFile);
return (0);
}
else if (print_profile)
{
cups_file_t *fp; /* File pointer */
const char *profile = cupsdCreateProfile(42, 0);
/* Profile */
char line[1024]; /* Line from file */
if ((fp = cupsFileOpen(profile, "r")) == NULL)
{
printf("Unable to open profile file \"%s\": %s\n", profile ? profile : "(null)", strerror(errno));
return (1);
}
while (cupsFileGets(fp, line, sizeof(line)))
puts(line);
cupsFileClose(fp);
return (0);
}
/*
* Clean out old temp files and printer cache data.
*/
if (!strncmp(TempDir, RequestRoot, strlen(RequestRoot)))
cupsdCleanFiles(TempDir, NULL);
cupsdCleanFiles(CacheDir, "*.ipp");
#if defined(HAVE_ONDEMAND)
if (OnDemand)
{
/*
* If we were started on demand by launchd or systemd get the listen sockets
* file descriptors...
*/
service_checkin();
service_checkout();
}
#endif /* HAVE_ONDEMAND */
/*
* Startup the server...
*/
httpInitialize();
cupsdStartServer();
/*
* Catch hangup and child signals and ignore broken pipes...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGCHLD, sigchld_handler);
sigset(SIGHUP, sighup_handler);
sigset(SIGPIPE, SIG_IGN);
sigset(SIGTERM, sigterm_handler);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGTERM);
sigaddset(&action.sa_mask, SIGCHLD);
action.sa_handler = sigchld_handler;
sigaction(SIGCHLD, &action, NULL);
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGHUP);
action.sa_handler = sighup_handler;
sigaction(SIGHUP, &action, NULL);
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGTERM);
sigaddset(&action.sa_mask, SIGCHLD);
action.sa_handler = sigterm_handler;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGCLD, sigchld_handler); /* No, SIGCLD isn't a typo... */
signal(SIGHUP, sighup_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sigterm_handler);
#endif /* HAVE_SIGSET */
/*
* Initialize authentication certificates...
*/
cupsdInitCerts();
/*
* If we are running in the background, signal the parent process that
* we are up and running...
*/
if (!fg || run_as_child)
{
/*
* Send a signal to the parent process, but only if the parent is
* not PID 1 (init). This avoids accidentally shutting down the
* system on OpenBSD if you CTRL-C the server before it is up...
*/
i = getppid(); /* Save parent PID to avoid race condition */
if (i != 1)
kill(i, SIGUSR1);
}
#ifdef __APPLE__
/*
* Start power management framework...
*/
if (use_sysman)
cupsdStartSystemMonitor();
#endif /* __APPLE__ */
/*
* Send server-started event...
*/
#if defined(HAVE_ONDEMAND)
if (OnDemand)
cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started on demand.");
else
#endif /* HAVE_ONDEMAND */
if (fg)
cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started in foreground.");
else
cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started in background.");
/*
* Start any pending print jobs...
*/
cupsdCheckJobs();
/*
* Loop forever...
*/
current_time = time(NULL);
event_time = current_time;
expire_time = current_time;
fds = 1;
report_time = 0;
senddoc_time = current_time;
while (!stop_scheduler)
{
/*
* Check if there are dead children to handle...
*/
if (dead_children)
process_children();
/*
* Check if we need to load the server configuration file...
*/
if (NeedReload)
{
/*
* Close any idle clients...
*/
if (cupsArrayCount(Clients) > 0)
{
for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
con;
con = (cupsd_client_t *)cupsArrayNext(Clients))
if (httpGetState(con->http) == HTTP_WAITING)
cupsdCloseClient(con);
else
con->http->keep_alive = HTTP_KEEPALIVE_OFF;
cupsdPauseListening();
}
/*
* Restart if all clients are closed and all jobs finished, or
* if the reload timeout has elapsed...
*/
if ((cupsArrayCount(Clients) == 0 &&
(cupsArrayCount(PrintingJobs) == 0 || NeedReload != RELOAD_ALL)) ||
(time(NULL) - ReloadTime) >= ReloadTimeout)
{
/*
* Shutdown the server...
*/
#ifdef HAVE_ONDEMAND
if (OnDemand)
break;
#endif /* HAVE_ONDEMAND */
DoingShutdown = 1;
cupsdStopServer();
/*
* Read configuration...
*/
if (!cupsdReadConfiguration())
{
#ifdef HAVE_SYSTEMD_SD_JOURNAL_H
sd_journal_print(LOG_ERR, "Unable to read configuration file \"%s\" - exiting.", ConfigurationFile);
#else
syslog(LOG_LPR, "Unable to read configuration file \'%s\' - exiting.", ConfigurationFile);
#endif /* HAVE_SYSTEMD_SD_JOURNAL_H */
break;
}
/*
* Startup the server...
*/
DoingShutdown = 0;
cupsdStartServer();
/*
* Send a server-restarted event...
*/
cupsdAddEvent(CUPSD_EVENT_SERVER_RESTARTED, NULL, NULL,
"Scheduler restarted.");
}
}
/*
* Check for available input or ready output. If cupsdDoSelect()
* returns 0 or -1, something bad happened and we should exit
* immediately.
*
* Note that we at least have one listening socket open at all
* times.
*/
if ((timeout = select_timeout(fds)) > 1 && LastEvent)
timeout = 1;
#ifdef HAVE_ONDEMAND
/*
* If no other work is scheduled and we're being controlled by
* launchd then timeout after 'LaunchdTimeout' seconds of
* inactivity...
*/
if (timeout == 86400 && OnDemand && IdleExitTimeout &&
!cupsArrayCount(ActiveJobs) &&
# ifdef HAVE_SYSTEMD
!WebInterface &&
# endif /* HAVE_SYSTEMD */
(!Browsing || !BrowseLocalProtocols || !cupsArrayCount(Printers)))
{
timeout = IdleExitTimeout;
service_idle_exit = 1;
}
else
service_idle_exit = 0;
#endif /* HAVE_ONDEMAND */
if ((fds = cupsdDoSelect(timeout)) < 0)
{
/*
* Got an error from select!
*/
#if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
cupsd_printer_t *p; /* Current printer */
#endif /* HAVE_DNSSD || HAVE_AVAHI */
if (errno == EINTR) /* Just interrupted by a signal */
continue;
/*
* Log all sorts of debug info to help track down the problem.
*/
cupsdLogMessage(CUPSD_LOG_EMERG, "cupsdDoSelect() failed - %s!",
strerror(errno));
for (i = 0, con = (cupsd_client_t *)cupsArrayFirst(Clients);
con;
i ++, con = (cupsd_client_t *)cupsArrayNext(Clients))
cupsdLogMessage(CUPSD_LOG_EMERG,
"Clients[%d] = %d, file = %d, state = %d",
i, con->number, con->file, httpGetState(con->http));
for (i = 0, lis = (cupsd_listener_t *)cupsArrayFirst(Listeners);
lis;
i ++, lis = (cupsd_listener_t *)cupsArrayNext(Listeners))
cupsdLogMessage(CUPSD_LOG_EMERG, "Listeners[%d] = %d", i, lis->fd);
cupsdLogMessage(CUPSD_LOG_EMERG, "CGIPipes[0] = %d", CGIPipes[0]);
#ifdef __APPLE__
cupsdLogMessage(CUPSD_LOG_EMERG, "SysEventPipes[0] = %d",
SysEventPipes[0]);
#endif /* __APPLE__ */
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
job;
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
cupsdLogMessage(CUPSD_LOG_EMERG, "Jobs[%d] = %d < [%d %d] > [%d %d]",
job->id,
job->status_buffer ? job->status_buffer->fd : -1,
job->print_pipes[0], job->print_pipes[1],
job->back_pipes[0], job->back_pipes[1]);
#if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
p;
p = (cupsd_printer_t *)cupsArrayNext(Printers))
cupsdLogMessage(CUPSD_LOG_EMERG, "printer[%s] reg_name=\"%s\"", p->name,
p->reg_name ? p->reg_name : "(null)");
#endif /* HAVE_DNSSD || HAVE_AVAHI */
break;
}
current_time = time(NULL);
/*
* Write dirty config/state files...
*/
if (DirtyCleanTime && current_time >= DirtyCleanTime)
cupsdCleanDirty();
#ifdef __APPLE__
/*
* If we are going to sleep and still have pending jobs, stop them after
* a period of time...
*/
if (SleepJobs > 0 && current_time >= SleepJobs &&
cupsArrayCount(PrintingJobs) > 0)
{
SleepJobs = 0;
cupsdStopAllJobs(CUPSD_JOB_DEFAULT, 5);
}
#endif /* __APPLE__ */
#ifndef __APPLE__
/*
* Update the network interfaces once a minute...
*/
if ((current_time - netif_time) >= 60)
{
netif_time = current_time;
NetIFUpdate = 1;
}
#endif /* !__APPLE__ */
#ifdef HAVE_ONDEMAND
/*
* If no other work was scheduled and we're being controlled by launchd,
* systemd, or upstart then timeout after 'LaunchdTimeout' seconds of
* inactivity...
*/
if (!fds && service_idle_exit)
{
cupsdLogMessage(CUPSD_LOG_INFO,
"Printer sharing is off and there are no jobs pending, "
"will restart on demand.");
stop_scheduler = 1;
break;
}
#endif /* HAVE_ONDEMAND */
/*
* Resume listening for new connections as needed...
*/
if (ListeningPaused && ListeningPaused <= current_time &&
cupsArrayCount(Clients) < MaxClients)
cupsdResumeListening();
/*
* Expire subscriptions and unload completed jobs as needed...
*/
if (current_time > expire_time)
{
if (cupsArrayCount(Subscriptions) > 0)
cupsdExpireSubscriptions(NULL, NULL);
cupsdUnloadCompletedJobs();
expire_time = current_time;
}
#ifndef HAVE_AUTHORIZATION_H
/*
* Update the root certificate once every 5 minutes if we have client
* connections...
*/
if ((current_time - RootCertTime) >= RootCertDuration && RootCertDuration &&
!RunUser && cupsArrayCount(Clients))
{
/*
* Update the root certificate...
*/
cupsdDeleteCert(0);
cupsdAddCert(0, "root", cupsdDefaultAuthType());
}
#endif /* !HAVE_AUTHORIZATION_H */
/*
* Check for new data on the client sockets...
*/
for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
con;
con = (cupsd_client_t *)cupsArrayNext(Clients))
{
/*
* Process pending data in the input buffer...
*/
if (httpGetReady(con->http))
{
cupsdReadClient(con);
continue;
}
/*
* Check the activity and close old clients...
*/
activity = current_time - Timeout;
if (httpGetActivity(con->http) < activity && !con->pipe_pid)
{
cupsdLogMessage(CUPSD_LOG_DEBUG, "Closing client %d after %d seconds of inactivity.", con->number, Timeout);
cupsdCloseClient(con);
continue;
}
}
/*
* Update any pending multi-file documents...
*/
if ((current_time - senddoc_time) >= 10)
{
cupsdCheckJobs();
senddoc_time = current_time;
}
/*
* Clean job history...
*/
if (JobHistoryUpdate && current_time >= JobHistoryUpdate)
cupsdCleanJobs();
/*
* Log statistics at most once a minute when in debug mode...
*/
if ((current_time - report_time) >= 60 && LogLevel >= CUPSD_LOG_DEBUG)
{
size_t string_count, /* String count */
alloc_bytes, /* Allocated string bytes */
total_bytes; /* Total string bytes */
#ifdef HAVE_MALLINFO
struct mallinfo mem; /* Malloc information */
mem = mallinfo();
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-arena=%lu", mem.arena);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-used=%lu",
mem.usmblks + mem.uordblks);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-free=%lu",
mem.fsmblks + mem.fordblks);
#endif /* HAVE_MALLINFO */
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: clients=%d",
cupsArrayCount(Clients));
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: jobs=%d",
cupsArrayCount(Jobs));
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: jobs-active=%d",
cupsArrayCount(ActiveJobs));
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: printers=%d",
cupsArrayCount(Printers));
string_count = _cupsStrStatistics(&alloc_bytes, &total_bytes);
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Report: stringpool-string-count=" CUPS_LLFMT,
CUPS_LLCAST string_count);
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Report: stringpool-alloc-bytes=" CUPS_LLFMT,
CUPS_LLCAST alloc_bytes);
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Report: stringpool-total-bytes=" CUPS_LLFMT,
CUPS_LLCAST total_bytes);
report_time = current_time;
}
/*
* Handle OS-specific event notification for any events that have
* accumulated. Don't send these more than once a second...
*/
if (LastEvent && (current_time - event_time) >= 1)
{
#ifdef HAVE_NOTIFY_POST
if (LastEvent & (CUPSD_EVENT_PRINTER_ADDED |
CUPSD_EVENT_PRINTER_DELETED |
CUPSD_EVENT_PRINTER_MODIFIED))
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"notify_post(\"com.apple.printerListChange\")");
notify_post("com.apple.printerListChange");
}
if (LastEvent & CUPSD_EVENT_PRINTER_STATE_CHANGED)
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"notify_post(\"com.apple.printerHistoryChange\")");
notify_post("com.apple.printerHistoryChange");
}
if (LastEvent & (CUPSD_EVENT_JOB_STATE_CHANGED |
CUPSD_EVENT_JOB_CONFIG_CHANGED |
CUPSD_EVENT_JOB_PROGRESS))
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"notify_post(\"com.apple.jobChange\")");
notify_post("com.apple.jobChange");
}
#endif /* HAVE_NOTIFY_POST */
/*
* Reset the accumulated events...
*/
LastEvent = CUPSD_EVENT_NONE;
event_time = current_time;
}
}
/*
* Log a message based on what happened...
*/
if (stop_scheduler)
{
cupsdLogMessage(CUPSD_LOG_INFO, "Scheduler shutting down normally.");
cupsdAddEvent(CUPSD_EVENT_SERVER_STOPPED, NULL, NULL,
"Scheduler shutting down normally.");
}
else
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Scheduler shutting down due to program error.");
cupsdAddEvent(CUPSD_EVENT_SERVER_STOPPED, NULL, NULL,
"Scheduler shutting down due to program error.");
}
/*
* Close all network clients...
*/
DoingShutdown = 1;
cupsdStopServer();
#ifdef HAVE_ONDEMAND
/*
* Update the keep-alive file as needed...
*/
if (OnDemand)
service_checkout();
#endif /* HAVE_ONDEMAND */
/*
* Stop all jobs...
*/
cupsdFreeAllJobs();
#ifdef __APPLE__
/*
* Stop monitoring system event monitoring...
*/
if (use_sysman)
cupsdStopSystemMonitor();
#endif /* __APPLE__ */
cupsdStopSelect();
return (!stop_scheduler);
}
/* dump AMF data into a stream as text */
void amf0_data_dump(FILE * stream, const amf0_data *data, int indent_level) {
if (data != NULL) {
amf0_node * node;
time_t time;
struct tm * t;
char datestr[128];
switch (data->type) {
case AMF0_TYPE_NUMBER:
fprintf(stream, "%.12g", data->number_data);
break;
case AMF0_TYPE_BOOLEAN:
fprintf(stream, "%s", (data->boolean_data) ? "true" : "false");
break;
case AMF0_TYPE_STRING:
fprintf(stream, "\'%.*s\'", data->string_data.size, data->string_data.mbstr);
break;
case AMF0_TYPE_OBJECT:
node = amf0_object_first(data);
fprintf(stream, "{\n");
while (node != NULL) {
fprintf(stream, "%*s", (indent_level+1)*4, "");
amf0_data_dump(stream, amf0_object_get_name(node), indent_level+1);
fprintf(stream, ": ");
amf0_data_dump(stream, amf0_object_get_data(node), indent_level+1);
node = amf0_object_next(node);
fprintf(stream, "\n");
}
fprintf(stream, "%*s", indent_level*4 + 1, "}");
break;
case AMF0_TYPE_MOVIECLIP:
fprintf(stream, "[movieclip]");
break;
case AMF0_TYPE_NULL:
fprintf(stream, "null");
break;
case AMF0_TYPE_UNDEFINED:
fprintf(stream, "undefined");
break;
case AMF0_TYPE_REFERENCE: /* TODO */
fprintf(stream, "[reference]");
break;
case AMF0_TYPE_ECMA_ARRAY:
node = amf0_associative_array_first(data);
fprintf(stream, "{\n");
while (node != NULL) {
fprintf(stream, "%*s", (indent_level+1)*4, "");
amf0_data_dump(stream, amf0_associative_array_get_name(node), indent_level+1);
fprintf(stream, " => ");
amf0_data_dump(stream, amf0_associative_array_get_data(node), indent_level+1);
node = amf0_associative_array_next(node);
fprintf(stream, "\n");
}
fprintf(stream, "%*s", indent_level*4 + 1, "}");
break;
case AMF0_TYPE_OBJECT_END:
fprintf(stream, "[object end]");
break;
case AMF0_TYPE_STRICT_ARRAY:
node = amf0_array_first(data);
fprintf(stream, "[\n");
while (node != NULL) {
fprintf(stream, "%*s", (indent_level+1)*4, "");
amf0_data_dump(stream, node->data, indent_level+1);
node = amf0_array_next(node);
fprintf(stream, "\n");
}
fprintf(stream, "%*s", indent_level*4 + 1, "]");
break;
case AMF0_TYPE_DATE:
time = amf0_date_to_time_t(data);
tzset();
t = localtime(&time);
strftime(datestr, sizeof(datestr), "%a, %d %b %Y %H:%M:%S %z", t);
fprintf(stream, "%s", datestr);
break;
case AMF0_TYPE_LONG_STRING: /* TODO */
fprintf(stream, "[long string]");
break;
case AMF0_TYPE_UNSUPPORTED:
fprintf(stream, "[unsupported]");
break;
case AMF0_TYPE_RECORDSET:
fprintf(stream, "[recordset]");
break;
case AMF0_TYPE_XML_DOCUMENT: /* TODO */
fprintf(stream, "[xml document]");
break;
case AMF0_TYPE_TYPED_OBJECT: /* TODO */
fprintf(stream, "[typed object]");
break;
default:
fprintf(stream, "[unknown data type 0x%x]", data->type);
break;
}
}
}
time_t date_parse(const char *str)
{
time_t now;
struct tm* now_tmP;
struct tm tm;
const char* cp;
char str_mon[500], str_wday[500], str_gmtoff[500], str_ampm[500];
int tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday, gmtoff, local_gmtoff;
int ampm, got_zone;
time_t t;
if (!str || !*str) return (time_t) 0;
/* Initialize tm with relevant parts of current local time. */
now = time( (time_t*) 0 );
now_tmP = localtime( &now );
bzero( (char*) &tm, sizeof(struct tm) );
tm.tm_sec = now_tmP->tm_sec;
tm.tm_min = now_tmP->tm_min;
tm.tm_hour = now_tmP->tm_hour;
tm.tm_mday = now_tmP->tm_mday;
tm.tm_mon = now_tmP->tm_mon;
tm.tm_year = now_tmP->tm_year;
ampm = AMPM_NONE;
got_zone = 0;
/* Find local zone offset. This is the only real area of
** non-portability, and it's only used for local times that don't
** specify a zone - those don't occur in email and netnews.
*/
#ifdef HAVE_STRUCT_TM_GMTOFF
gmtoff = now_tmP->tm_gmtoff;
#else
tzset();
gmtoff = -timezone;
#endif
local_gmtoff = gmtoff;
/* Skip initial whitespace ourselves - sscanf is clumsy at this. */
for ( cp = str; *cp == ' ' || *cp == '\t'; ++cp )
;
/* And do the sscanfs. WARNING: you can add more formats here,
** but be careful! You can easily screw up the parsing of existing
** formats when you add new ones.
*/
/* N mth YYYY HH:MM:SS ampm zone */
if ( ( ( sscanf( cp, "%d %[a-zA-Z] %d %d:%d:%d %[apmAPM] %[^: ]",
&tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, &tm_sec, str_ampm, str_gmtoff ) == 8 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d %[a-zA-Z] %d %d:%d:%d %[^: ]",
&tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, &tm_sec, str_gmtoff ) == 7 ) &&
scan_mon( str_mon, &tm_mon ) &&
scan_gmtoff( str_gmtoff, &gmtoff ) )
{
DP( "N mth YYYY HH:MM:SS ampm zone" );
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
got_zone = 1;
}
/* N mth YYYY HH:MM ampm zone */
else if ( ( ( sscanf( cp, "%d %[a-zA-Z] %d %d:%d %[apmAPM] %[^: ]",
&tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, str_ampm, str_gmtoff ) == 7 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d %[a-zA-Z] %d %d:%d %[^: ]",
&tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, str_gmtoff ) == 6 ) &&
scan_mon( str_mon, &tm_mon ) &&
scan_gmtoff( str_gmtoff, &gmtoff ) )
{
DP( "N mth YYYY HH:MM ampm zone" );
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
got_zone = 1;
}
/* N mth YYYY HH:MM:SS ampm */
else if ( ( ( sscanf( cp, "%d %[a-zA-Z] %d %d:%d:%d %[apmAPM]",
&tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, &tm_sec, str_ampm ) == 7 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d %[a-zA-Z] %d %d:%d:%d",
&tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, &tm_sec ) == 6 ) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "N mth YYYY HH:MM:SS ampm" );
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
}
/* N mth YYYY HH:MM ampm */
else if ( ( ( sscanf( cp, "%d %[a-zA-Z] %d %d:%d %[apmAPM]",
&tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, str_ampm ) == 6 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d %[a-zA-Z] %d %d:%d",
&tm_mday, str_mon, &tm_year, &tm_hour, &tm_min ) == 5 ) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "N mth YYYY HH:MM ampm" );
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
}
/* mm/dd/yy[yy] HH:MM:SS [ampm] [zone]*/
else if (
( sscanf( cp, "%d/%d/%d %d:%d:%d %[apmAPM] %[^: ]",
&tm_mon, &tm_mday, &tm_year, &tm_hour, &tm_min, &tm_sec, str_ampm, str_gmtoff ) == 8 &&
scan_gmtoff( str_gmtoff, &gmtoff ) && scan_ampm( str_ampm, &m ) && (got_zone = 1))
||
( sscanf( cp, "%d/%d/%d %d:%d:%d %[apmAPM]",
&tm_mon, &tm_mday, &tm_year, &tm_hour, &tm_min, &tm_sec, str_ampm ) == 7 &&
scan_ampm( str_ampm, &m ) )
||
( sscanf( cp, "%d/%d/%d %d:%d:%d",
&tm_mon, &tm_mday, &tm_year, &tm_hour, &tm_min, &tm_sec ) == 6 )
)
{
DP( "mm/dd/yy[yy] HH:MM:SS [ampm] [zone]" );
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
}
/* mm/dd/yy[yy] HH:MM [ampm] [zone]*/
else if (
( sscanf( cp, "%d/%d/%d %d:%d %[apmAPM] %[^: ]",
&tm_mon, &tm_mday, &tm_year, &tm_hour, &tm_min, str_ampm, str_gmtoff ) == 7 &&
scan_gmtoff( str_gmtoff, &gmtoff ) && scan_ampm( str_ampm, &m ) && (got_zone = 1) )
||
( sscanf( cp, "%d/%d/%d %d:%d %[apmAPM]",
&tm_mon, &tm_mday, &tm_year, &tm_hour, &tm_min, str_ampm ) == 6 &&
scan_ampm( str_ampm, &m ) )
||
( sscanf( cp, "%d/%d/%d %d:%d %[^: ]",
&tm_mon, &tm_mday, &tm_year, &tm_hour, &tm_min, str_gmtoff ) == 6 &&
scan_gmtoff( str_gmtoff, &gmtoff ) && (got_zone = 1) )
||
( sscanf( cp, "%d/%d/%d %d:%d",
&tm_mon, &tm_mday, &tm_year, &tm_hour, &tm_min ) == 5 )
)
{
DP( "mm/dd/yy[yy] HH:MM [ampm] [zone]" );
tm.tm_mday = tm_mday;
tm.tm_mon = mm_fix(tm_mon);
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
}
/* yy[yy]-mm-dd hh:nn:ss [ampm] [zone]*/
else if (
( sscanf( cp, "%d-%d-%d %d:%d:%d %[apmAPM] %[^: ]",
&tm_year, &tm_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec, str_ampm, str_gmtoff ) == 8 &&
scan_gmtoff( str_gmtoff, &gmtoff ) && scan_ampm( str_ampm, &m ) && (got_zone = 1) )
||
( sscanf( cp, "%d-%d-%d %d:%d:%d %[apmAPM]",
&tm_year, &tm_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec, str_ampm ) == 7 &&
scan_ampm( str_ampm, &m ) )
||
( sscanf( cp, "%d-%d-%d %d:%d:%d %[^: ]",
&tm_year, &tm_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec, str_gmtoff ) == 7 &&
scan_gmtoff( str_gmtoff, &gmtoff ) && (got_zone = 1) )
||
( sscanf( cp, "%d-%d-%d %d:%d:%d",
&tm_year, &tm_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec ) == 6 )
)
{
DP( "yy[yy]-mm-dd hh:nn:ss [ampm] [zone]" );
tm.tm_mday = tm_mday;
tm.tm_mon = mm_fix(tm_mon);
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
}
/* yy[yy]-mm-dd hh:nn [ampm] [zone]*/
else if (
( sscanf( cp, "%d-%d-%d %d:%d %[apmAPM] %[^: ]",
&tm_year, &tm_mon, &tm_mday, &tm_hour, &tm_min, str_ampm, str_gmtoff ) == 7 &&
scan_gmtoff( str_gmtoff, &gmtoff ) && scan_ampm( str_ampm, &m ) && (got_zone = 1) )
||
( sscanf( cp, "%d-%d-%d %d:%d %[apmAPM]",
&tm_year, &tm_mon, &tm_mday, &tm_hour, &tm_min, str_ampm ) == 6 &&
scan_ampm( str_ampm, &m ) )
||
( sscanf( cp, "%d-%d-%d %d:%d %[^: ]",
&tm_year, &tm_mon, &tm_mday, &tm_hour, &tm_min, str_gmtoff ) == 6 &&
scan_gmtoff( str_gmtoff, &gmtoff ) && (got_zone = 1) )
||
( sscanf( cp, "%d-%d-%d %d:%d",
&tm_year, &tm_mon, &tm_mday, &tm_hour, &tm_min) == 5 )
)
{
DP( "yy[yy]-mm-dd hh:nn:ss [ampm] [zone]" );
tm.tm_mday = tm_mday;
tm.tm_mon = mm_fix(tm_mon);
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
}
/* mm/dd/yy[yy]*/
else if ( sscanf( cp, "%d/%d/%d", &tm_mon, &tm_mday, &tm_year) == 3 ) {
DP( "mm/dd/yy[yy]" );
tm.tm_mday = tm_mday;
tm.tm_mon = mm_fix(tm_mon);
tm.tm_year = tm_year;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
/*yy[yy]-mm-dd*/
else if ( sscanf( cp, "%d-%d-%d", &tm_year, &tm_mon, &tm_mday) == 3 ) {
DP( "yy[yy]-mm-dd" );
tm.tm_mday = tm_mday;
tm.tm_mon = mm_fix(tm_mon);
tm.tm_year = tm_year;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
} /* mm/dd*/
else if ( sscanf( cp, "%d/%d %d:%d %[apmAPM]", &tm_mon, &tm_mday, &tm_hour, &tm_min, str_ampm) == 5 && scan_ampm( str_ampm, &m ) ) {
DP( "mm/dd hh:ss aa" );
tm.tm_mday = tm_mday;
tm.tm_mon = mm_fix(tm_mon);
// tm.tm_year = same as it was;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = 0;
tm.tm_sec = 0;
}
else if ( sscanf( cp, "%d/%d %d:%d", &tm_mon, &tm_mday, &tm_hour, &tm_min) == 4 ) {
DP( "mm/dd hh:ss" );
tm.tm_mday = tm_mday;
tm.tm_mon = mm_fix(tm_mon);
// tm.tm_year = same as it was;
tm.tm_hour = tm_hour;
tm.tm_min = tm_min;
tm.tm_sec = 0;
}
else if ( sscanf( cp, "%d/%d", &tm_mon, &tm_mday) == 2 ) {
DP( "mm/dd" );
tm.tm_mday = tm_mday;
tm.tm_mon = mm_fix(tm_mon);
// tm.tm_year = same as it was;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
/* HH:MM:SS ampm zone N mth YYYY */
else if ( ( ( sscanf( cp, "%d:%d:%d %[apmAPM] %[^: ] %d %[a-zA-Z] %d",
&tm_hour, &tm_min, &tm_sec, str_ampm, str_gmtoff, &tm_mday,
str_mon, &tm_year ) == 8 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d:%d:%d %[^: ] %d %[a-zA-Z] %d",
&tm_hour, &tm_min, &tm_sec, str_gmtoff, &tm_mday, str_mon,
&tm_year ) == 7 ) &&
scan_gmtoff( str_gmtoff, &gmtoff ) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "HH:MM:SS ampm zone N mth YYYY" );
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
}
/* HH:MM ampm zone N mth YYYY */
else if ( ( ( sscanf( cp, "%d:%d %[apmAPM] %[^: ] %d %[a-zA-Z] %d",
&tm_hour, &tm_min, str_ampm, str_gmtoff, &tm_mday, str_mon,
&tm_year ) == 7 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d:%d %[^: ] %d %[a-zA-Z] %d",
&tm_hour, &tm_min, str_gmtoff, &tm_mday, str_mon,
&tm_year ) == 6 ) &&
scan_gmtoff( str_gmtoff, &gmtoff ) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "HH:MM ampm N mth YYYY" );
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
}
/* HH:MM:SS ampm N mth YYYY */
else if ( ( ( sscanf( cp, "%d:%d:%d %[apmAPM] %d %[a-zA-Z] %d",
&tm_hour, &tm_min, &tm_sec, str_ampm, &tm_mday, str_mon,
&tm_year ) == 7 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d:%d:%d %d %[a-zA-Z] %d",
&tm_hour, &tm_min, &tm_sec, &tm_mday, str_mon,
&tm_year ) == 6 ) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "HH:MM:SS ampm N mth YYYY" );
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
}
/* HH:MM ampm N mth YYYY */
else if ( ( ( sscanf( cp, "%d:%d %[apmAPM] %d %[a-zA-Z] %d",
&tm_hour, &tm_min, str_ampm, &tm_mday, str_mon,
&tm_year ) == 6 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d:%d %d %[a-zA-Z] %d",
&tm_hour, &tm_min, &tm_mday, str_mon, &tm_year ) == 5 ) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "HH:MM ampm N mth YYYY" );
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
}
/* wdy, N mth YYYY HH:MM:SS ampm zone */
else if ( ( ( sscanf( cp, "%[a-zA-Z], %d %[a-zA-Z] %d %d:%d:%d %[apmAPM] %[^: ]",
str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
&tm_sec, str_ampm, str_gmtoff ) == 9 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%[a-zA-Z], %d %[a-zA-Z] %d %d:%d:%d %[^: ]",
str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
&tm_sec, str_gmtoff ) == 8 ) &&
scan_wday( str_wday, &tm_wday ) &&
scan_mon( str_mon, &tm_mon ) &&
scan_gmtoff( str_gmtoff, &gmtoff ) )
{
DP( "wdy, N mth YYYY HH:MM:SS ampm zone" );
tm.tm_wday = tm_wday;
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
got_zone = 1;
}
/* wdy, N mth YYYY HH:MM ampm zone */
else if ( ( ( sscanf( cp, "%[a-zA-Z], %d %[a-zA-Z] %d %d:%d %[apmAPM] %[^: ]",
str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
str_ampm, str_gmtoff ) == 8 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%[a-zA-Z], %d %[a-zA-Z] %d %d:%d %[^: ]",
str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
str_gmtoff ) == 7 ) &&
scan_wday( str_wday, &tm_wday ) &&
scan_mon( str_mon, &tm_mon ) &&
scan_gmtoff( str_gmtoff, &gmtoff ) )
{
DP( "wdy, N mth YYYY HH:MM ampm zone" );
tm.tm_wday = tm_wday;
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
got_zone = 1;
}
/* wdy, N mth YYYY HH:MM:SS ampm */
else if ( ( ( sscanf( cp, "%[a-zA-Z], %d %[a-zA-Z] %d %d:%d:%d %[apmAPM]",
str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
&tm_sec, str_ampm ) == 8 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%[a-zA-Z], %d %[a-zA-Z] %d %d:%d:%d",
str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
&tm_sec ) == 7 ) &&
scan_wday( str_wday, &tm_wday ) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "wdy, N mth YYYY HH:MM:SS ampm" );
tm.tm_wday = tm_wday;
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
}
/* wdy, N mth YYYY HH:MM ampm */
else if ( ( ( sscanf( cp, "%[a-zA-Z], %d %[a-zA-Z] %d %d:%d %[apmAPM]",
str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
str_ampm ) == 7 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%[a-zA-Z], %d %[a-zA-Z] %d %d:%d",
str_wday, &tm_mday, str_mon, &tm_year, &tm_hour,
&tm_min ) == 6 ) &&
scan_wday( str_wday, &tm_wday ) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "wdy, N mth YYYY HH:MM ampm" );
tm.tm_wday = tm_wday;
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
}
/* wdy mth N HH:MM:SS ampm zone YYYY */
else if ( ( ( sscanf( cp, "%[a-zA-Z] %[a-zA-Z] %d %d:%d:%d %[apmAPM] %[^: ] %d",
str_wday, str_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec,
str_ampm, str_gmtoff, &tm_year ) == 9 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%[a-zA-Z] %[a-zA-Z] %d %d:%d:%d %[^: ] %d",
str_wday, str_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec,
str_gmtoff, &tm_year ) == 8 ) &&
scan_wday( str_wday, &tm_wday ) &&
scan_mon( str_mon, &tm_mon ) &&
scan_gmtoff( str_gmtoff, &gmtoff ) )
{
DP( "wdy mth N HH:MM:SS ampm zone YYYY" );
tm.tm_wday = tm_wday;
tm.tm_mon = tm_mon;
tm.tm_mday = tm_mday;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
got_zone = 1;
tm.tm_year = tm_year;
}
/* wdy mth N HH:MM ampm zone YYYY */
else if ( ( ( sscanf( cp, "%[a-zA-Z] %[a-zA-Z] %d %d:%d %[apmAPM] %[^: ] %d",
str_wday, str_mon, &tm_mday, &tm_hour, &tm_min,
str_ampm, str_gmtoff, &tm_year ) == 8 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%[a-zA-Z] %[a-zA-Z] %d %d:%d %[^: ] %d",
str_wday, str_mon, &tm_mday, &tm_hour, &tm_min,
str_gmtoff, &tm_year ) == 7 ) &&
scan_wday( str_wday, &tm_wday ) &&
scan_mon( str_mon, &tm_mon ) &&
scan_gmtoff( str_gmtoff, &gmtoff ) )
{
DP( "wdy mth N HH:MM ampm zone YYYY" );
tm.tm_wday = tm_wday;
tm.tm_mon = tm_mon;
tm.tm_mday = tm_mday;
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
got_zone = 1;
tm.tm_year = tm_year;
}
/* N mth YY[YY] */
else if ( sscanf( cp, "%d %[a-zA-Z] %d",
&tm_mday, str_mon, &tm_year ) == 3 &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "N mth YYYY" );
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
/* mth N [,] YY[YY] */
else if ( (sscanf( cp, "%[a-zA-Z] %d %d",
str_mon, &tm_mday, &tm_year ) == 3 ||
sscanf( cp, "%[a-zA-Z] %d , %d",
str_mon, &tm_mday, &tm_year ) == 3)
&&
scan_mon( str_mon, &tm_mon ) )
{
DP( "N mth YYYY" );
tm.tm_mday = tm_mday;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
/* mth [,] YY[YY] */
else if ( (
sscanf( cp, "%[a-zA-Z] %d", str_mon, &tm_year ) == 2
||
sscanf( cp, "%[a-zA-Z] , %d", str_mon, &tm_year ) == 2
) &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "mth [,] YY[YY]" );
tm.tm_mday = 1;
tm.tm_mon = tm_mon;
tm.tm_year = tm_year;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
/* mth*/
else if ( sscanf( cp, "%[a-zA-Z]", str_mon) == 1 &&
scan_mon( str_mon, &tm_mon ) )
{
DP( "mth" );
tm.tm_mday = 1;
tm.tm_mon = tm_mon;
// tm.tm_year = same as it was;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
/* HH:MM:SS ampm */
else if ( ( sscanf( cp, "%d:%d:%d %[apmAPM]",
&tm_hour, &tm_min, &tm_sec, str_ampm ) == 4 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d:%d:%d", &tm_hour, &tm_min, &tm_sec ) == 3 )
{
DP( "HH:MM:SS ampm" );
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = tm_sec;
}
/* HH:MM ampm */
else if ( ( sscanf( cp, "%d:%d %[apmAPM]", &tm_hour, &tm_min,
str_ampm ) == 3 &&
scan_ampm( str_ampm, &m ) ) ||
sscanf( cp, "%d:%d", &tm_hour, &tm_min ) == 2 )
{
DP( "HH:MM" );
tm.tm_hour = ampm_fix( tm_hour, ampm );
tm.tm_min = tm_min;
tm.tm_sec = 0;
}
/* yymmdd */
else if ( (sscanf( cp, "%d", &tm_year) == 1) &&
(tm_year % 100 > 0) &&
(tm_year % 100 <= 31) &&
((tm_year / 100) % 100 > 0) &&
((tm_year / 100) % 100 <= 12) &&
(strlen(cp) == 6) )
{
DP( "yymmdd" );
tm.tm_mday = (int) (tm_mon % 100);
tm.tm_mon = mm_fix((int) (tm_mon / 100) % 100);
tm.tm_year = (int) (tm_year / 10000);
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
else if ( (sscanf( cp, "%d", &tm_year) == 1) &&
(tm_year % 100 > 0) &&
(tm_year % 100 <= 31) &&
((tm_year / 100) % 100 > 0) &&
((tm_year / 100) % 100 <= 12) &&
(strlen(cp) == 8) )
{
DP( "yyyymmdd" );
tm.tm_mday = (int) (tm_mon % 100);
tm.tm_mon = mm_fix((int) (tm_mon / 100) % 100);
tm.tm_year = (int) (tm_year / 10000);
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
else
return (time_t) -1;
// solve yNk bug.... 2 digit year = closest to now
static int yk_low = -1;
static int yk_off = 0;
if (yk_low < 0) {
yk_low = ((now_tmP->tm_year + 50) % 100);
yk_off = 100 * (int) ((now_tmP->tm_year-50) / 100);
}
if ( tm.tm_year > 1900 )
tm.tm_year -= 1900;
else {
if ( tm.tm_year < yk_low )
tm.tm_year += 100;
tm.tm_year += yk_off;
}
tm.tm_isdst = -1;
t = mktime(&tm);
t += (local_gmtoff - gmtoff);
return t;
}
static void print_status_info(const StatusInfo *i) {
const char *old_tz = NULL, *tz;
bool have_time = false;
char a[LINE_MAX];
struct tm tm;
time_t sec;
size_t n;
int r;
assert(i);
/* Save the old $TZ */
tz = getenv("TZ");
if (tz)
old_tz = strdupa(tz);
/* Set the new $TZ */
if (setenv("TZ", isempty(i->timezone) ? "UTC" : i->timezone, true) < 0)
log_warning_errno(errno, "Failed to set TZ environment variable, ignoring: %m");
else
tzset();
if (i->time != 0) {
sec = (time_t) (i->time / USEC_PER_SEC);
have_time = true;
} else if (IN_SET(arg_transport, BUS_TRANSPORT_LOCAL, BUS_TRANSPORT_MACHINE)) {
sec = time(NULL);
have_time = true;
} else
log_warning("Could not get time from timedated and not operating locally, ignoring.");
if (have_time) {
n = strftime(a, sizeof a, "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&sec, &tm));
printf(" Local time: %s\n", n > 0 ? a : "n/a");
n = strftime(a, sizeof a, "%a %Y-%m-%d %H:%M:%S UTC", gmtime_r(&sec, &tm));
printf(" Universal time: %s\n", n > 0 ? a : "n/a");
} else {
printf(" Local time: %s\n", "n/a");
printf(" Universal time: %s\n", "n/a");
}
if (i->rtc_time > 0) {
time_t rtc_sec;
rtc_sec = (time_t) (i->rtc_time / USEC_PER_SEC);
n = strftime(a, sizeof a, "%a %Y-%m-%d %H:%M:%S", gmtime_r(&rtc_sec, &tm));
printf(" RTC time: %s\n", n > 0 ? a : "n/a");
} else
printf(" RTC time: %s\n", "n/a");
if (have_time)
n = strftime(a, sizeof a, "%Z, %z", localtime_r(&sec, &tm));
/* Restore the $TZ */
if (old_tz)
r = setenv("TZ", old_tz, true);
else
r = unsetenv("TZ");
if (r < 0)
log_warning_errno(errno, "Failed to set TZ environment variable, ignoring: %m");
else
tzset();
printf(" Time zone: %s (%s)\n"
"System clock synchronized: %s\n"
" NTP service: %s\n"
" RTC in local TZ: %s\n",
strna(i->timezone), have_time && n > 0 ? a : "n/a",
yes_no(i->ntp_synced),
i->ntp_capable ? (i->ntp_active ? "active" : "inactive") : "n/a",
yes_no(i->rtc_local));
if (i->rtc_local)
printf("\n%s"
"Warning: The system is configured to read the RTC time in the local time zone.\n"
" This mode cannot be fully supported. It will create various problems\n"
" with time zone changes and daylight saving time adjustments. The RTC\n"
" time is never updated, it relies on external facilities to maintain it.\n"
" If at all possible, use RTC in UTC by calling\n"
" 'timedatectl set-local-rtc 0'.%s\n", ansi_highlight(), ansi_normal());
}
int
main(int argc, char **argv)
{
int c;
int forkaway = 0;
FILE *pidfile;
const char *pidpath = "/var/run/tvheadend.pid";
struct group *grp;
struct passwd *pw;
const char *usernam = NULL;
const char *groupnam = NULL;
int logfacility = LOG_DAEMON;
int createdefault = 0;
sigset_t set;
const char *homedir;
const char *rawts_input = NULL;
#if ENABLE_LINUXDVB
const char *dvb_rawts_input = NULL;
#endif
const char *join_transport = NULL;
const char *confpath = NULL;
char *p, *endp;
uint32_t adapter_mask = 0xffffffff;
int crash = 0;
webui_port = 9981;
htsp_port = 9982;
gid_t gid;
uid_t uid;
/* Get current directory */
tvheadend_cwd = dirname(dirname(tvh_strdupa(argv[0])));
/* Set locale */
setlocale(LC_ALL, "");
// make sure the timezone is set
tzset();
while((c = getopt(argc, argv, "Aa:fp:u:g:c:Chdr:j:sw:e:E:R:W:")) != -1) {
switch(c) {
case 'a':
adapter_mask = 0x0;
p = strtok(optarg, ",");
if (p != NULL) {
do {
int adapter = strtol(p, &endp, 10);
if (*endp != 0 || adapter < 0 || adapter > 31) {
fprintf(stderr, "Invalid adapter number '%s'\n", p);
return 1;
}
adapter_mask |= (1 << adapter);
} while ((p = strtok(NULL, ",")) != NULL);
if (adapter_mask == 0x0) {
fprintf(stderr, "No adapters specified!\n");
return 1;
}
} else {
usage(argv[0]);
}
break;
case 'A':
crash = 1;
break;
case 'f':
forkaway = 1;
break;
case 'p':
pidpath = optarg;
break;
case 'w':
webui_port = atoi(optarg);
break;
case 'e':
htsp_port = atoi(optarg);
break;
case 'E':
htsp_port_extra = atoi(optarg);
break;
case 'u':
usernam = optarg;
break;
case 'g':
groupnam = optarg;
break;
case 'c':
confpath = optarg;
break;
case 'd':
log_debug_to_console = 1;
break;
case 's':
log_debug_to_syslog = 1;
break;
case 'C':
createdefault = 1;
break;
case 'r':
rawts_input = optarg;
break;
#if ENABLE_LINUXDVB
case 'R':
dvb_rawts_input = optarg;
break;
#endif
case 'j':
join_transport = optarg;
break;
case 'W':
tvheadend_webroot = optarg;
break;
default:
usage(argv[0]);
}
}
signal(SIGPIPE, handle_sigpipe);
log_stderr = 1;
log_decorate = isatty(2);
if(forkaway) {
grp = getgrnam(groupnam ?: "video");
pw = usernam ? getpwnam(usernam) : NULL;
pidfile = fopen(pidpath, "w+");
if(grp != NULL) {
gid = grp->gr_gid;
} else {
gid = 1;
}
if (pw != NULL) {
if (getuid() != pw->pw_uid) {
gid_t glist[10];
int gnum;
gnum = get_user_groups(pw, glist, 10);
if (setgroups(gnum, glist)) {
tvhlog(LOG_ALERT, "START", "setgroups() failed, do you have permission?");
return 1;
}
}
uid = pw->pw_uid;
homedir = pw->pw_dir;
setenv("HOME", homedir, 1);
} else {
uid = 1;
}
if ((getgid() != gid) && setgid(gid)) {
tvhlog(LOG_ALERT, "START", "setgid() failed, do you have permission?");
return 1;
}
if ((getuid() != uid) && setuid(uid)) {
tvhlog(LOG_ALERT, "START", "setuid() failed, do you have permission?");
return 1;
}
if(daemon(0, 0)) {
exit(2);
}
if(pidfile != NULL) {
fprintf(pidfile, "%d\n", getpid());
fclose(pidfile);
}
umask(0);
}
log_stderr = !forkaway;
log_decorate = isatty(2);
sigfillset(&set);
sigprocmask(SIG_BLOCK, &set, NULL);
openlog("tvheadend", LOG_PID, logfacility);
hts_settings_init(confpath);
pthread_mutex_init(&ffmpeg_lock, NULL);
pthread_mutex_init(&fork_lock, NULL);
pthread_mutex_init(&global_lock, NULL);
pthread_mutex_lock(&global_lock);
time(&dispatch_clock);
trap_init(argv[0]);
/**
* Initialize subsystems
*/
config_init();
service_init();
channels_init();
subscription_init();
access_init(createdefault);
#if ENABLE_LINUXDVB
muxes_init();
dvb_init(adapter_mask, dvb_rawts_input);
#endif
iptv_input_init();
#if ENABLE_V4L
v4l_init();
#endif
#if ENABLE_TRANSCODING
transcoder_init();
#endif
tcp_server_init();
http_server_init();
webui_init();
serviceprobe_init();
#if ENABLE_CWC
cwc_init();
capmt_init();
#if (!ENABLE_DVBCSA)
ffdecsa_init();
#endif
#endif
epggrab_init();
epg_init();
dvr_init();
htsp_init();
if(rawts_input != NULL)
rawts_init(rawts_input);
if(join_transport != NULL)
subscription_dummy_join(join_transport, 1);
#ifdef CONFIG_AVAHI
avahi_init();
#endif
epg_updated(); // cleanup now all prev ref's should have been created
pthread_mutex_unlock(&global_lock);
/**
* Wait for SIGTERM / SIGINT, but only in this thread
*/
running = 1;
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGINT);
signal(SIGTERM, doexit);
signal(SIGINT, doexit);
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
tvhlog(LOG_NOTICE, "START", "HTS Tvheadend version %s started, "
"running as PID:%d UID:%d GID:%d, settings located in '%s'",
tvheadend_version,
getpid(), getuid(), getgid(), hts_settings_get_root());
if(crash)
abort();
mainloop();
epg_save();
tvhlog(LOG_NOTICE, "STOP", "Exiting HTS Tvheadend");
if(forkaway)
unlink("/var/run/tvheadend.pid");
return 0;
}
/*
* OpenSSL provides SSL, TLS and general purpose cryptography. It wraps the
* OpenSSL[http://www.openssl.org/] library.
*
* = Examples
*
* All examples assume you have loaded OpenSSL with:
*
* require 'openssl'
*
* These examples build atop each other. For example the key created in the
* next is used in throughout these examples.
*
* == Keys
*
* === Creating a Key
*
* This example creates a 2048 bit RSA keypair and writes it to the current
* directory.
*
* key = OpenSSL::PKey::RSA.new 2048
*
* open 'private_key.pem', 'w' do |io| io.write key.to_pem end
* open 'public_key.pem', 'w' do |io| io.write key.public_key.to_pem end
*
* === Exporting a Key
*
* Keys saved to disk without encryption are not secure as anyone who gets
* ahold of the key may use it unless it is encrypted. In order to securely
* export a key you may export it with a pass phrase.
*
* cipher = OpenSSL::Cipher.new 'AES-128-CBC'
* pass_phrase = 'my secure pass phrase goes here'
*
* key_secure = key.export cipher, pass_phrase
*
* open 'private.secure.pem', 'w' do |io|
* io.write key_secure
* end
*
* OpenSSL::Cipher.ciphers returns a list of available ciphers.
*
* === Loading a Key
*
* A key can also be loaded from a file.
*
* key2 = OpenSSL::PKey::RSA.new File.read 'private_key.pem'
* key2.public? # => true
*
* or
*
* key3 = OpenSSL::PKey::RSA.new File.read 'public_key.pem'
* key3.private? # => false
*
* === Loading an Encrypted Key
*
* OpenSSL will prompt you for your pass phrase when loading an encrypted key.
* If you will not be able to type in the pass phrase you may provide it when
* loading the key:
*
* key4_pem = File.read 'private.secure.pem'
* key4 = OpenSSL::PKey::RSA.new key4_pem, pass_phrase
*
* == RSA Encryption
*
* RSA provides encryption and decryption using the public and private keys.
* You can use a variety of padding methods depending upon the intended use of
* encrypted data.
*
* === Encryption & Decryption
*
* Asymmetric public/private key encryption is slow and victim to attack in
* cases where it is used without padding or directly to encrypt larger chunks
* of data. Typical use cases for RSA encryption involve "wrapping" a symmetric
* key with the public key of the recipient who would "unwrap" that symmetric
* key again using their private key.
* The following illustrates a simplified example of such a key transport
* scheme. It shouldn't be used in practice, though, standardized protocols
* should always be preferred.
*
* wrapped_key = key.public_encrypt key
*
* A symmetric key encrypted with the public key can only be decrypted with
* the corresponding private key of the recipient.
*
* original_key = key.private_decrypt wrapped_key
*
* By default PKCS#1 padding will be used, but it is also possible to use
* other forms of padding, see PKey::RSA for further details.
*
* === Signatures
*
* Using "private_encrypt" to encrypt some data with the private key is
* equivalent to applying a digital signature to the data. A verifying
* party may validate the signature by comparing the result of decrypting
* the signature with "public_decrypt" to the original data. However,
* OpenSSL::PKey already has methods "sign" and "verify" that handle
* digital signatures in a standardized way - "private_encrypt" and
* "public_decrypt" shouldn't be used in practice.
*
* To sign a document, a cryptographically secure hash of the document is
* computed first, which is then signed using the private key.
*
* digest = OpenSSL::Digest::SHA256.new
* signature = key.sign digest, document
*
* To validate the signature, again a hash of the document is computed and
* the signature is decrypted using the public key. The result is then
* compared to the hash just computed, if they are equal the signature was
* valid.
*
* digest = OpenSSL::Digest::SHA256.new
* if key.verify digest, signature, document
* puts 'Valid'
* else
* puts 'Invalid'
* end
*
* == PBKDF2 Password-based Encryption
*
* If supported by the underlying OpenSSL version used, Password-based
* Encryption should use the features of PKCS5. If not supported or if
* required by legacy applications, the older, less secure methods specified
* in RFC 2898 are also supported (see below).
*
* PKCS5 supports PBKDF2 as it was specified in PKCS#5
* v2.0[http://www.rsa.com/rsalabs/node.asp?id=2127]. It still uses a
* password, a salt, and additionally a number of iterations that will
* slow the key derivation process down. The slower this is, the more work
* it requires being able to brute-force the resulting key.
*
* === Encryption
*
* The strategy is to first instantiate a Cipher for encryption, and
* then to generate a random IV plus a key derived from the password
* using PBKDF2. PKCS #5 v2.0 recommends at least 8 bytes for the salt,
* the number of iterations largely depends on the hardware being used.
*
* cipher = OpenSSL::Cipher.new 'AES-128-CBC'
* cipher.encrypt
* iv = cipher.random_iv
*
* pwd = 'some hopefully not to easily guessable password'
* salt = OpenSSL::Random.random_bytes 16
* iter = 20000
* key_len = cipher.key_len
* digest = OpenSSL::Digest::SHA256.new
*
* key = OpenSSL::PKCS5.pbkdf2_hmac(pwd, salt, iter, key_len, digest)
* cipher.key = key
*
* Now encrypt the data:
*
* encrypted = cipher.update document
* encrypted << cipher.final
*
* === Decryption
*
* Use the same steps as before to derive the symmetric AES key, this time
* setting the Cipher up for decryption.
*
* cipher = OpenSSL::Cipher.new 'AES-128-CBC'
* cipher.decrypt
* cipher.iv = iv # the one generated with #random_iv
*
* pwd = 'some hopefully not to easily guessable password'
* salt = ... # the one generated above
* iter = 20000
* key_len = cipher.key_len
* digest = OpenSSL::Digest::SHA256.new
*
* key = OpenSSL::PKCS5.pbkdf2_hmac(pwd, salt, iter, key_len, digest)
* cipher.key = key
*
* Now decrypt the data:
*
* decrypted = cipher.update encrypted
* decrypted << cipher.final
*
* == PKCS #5 Password-based Encryption
*
* PKCS #5 is a password-based encryption standard documented at
* RFC2898[http://www.ietf.org/rfc/rfc2898.txt]. It allows a short password or
* passphrase to be used to create a secure encryption key. If possible, PBKDF2
* as described above should be used if the circumstances allow it.
*
* PKCS #5 uses a Cipher, a pass phrase and a salt to generate an encryption
* key.
*
* pass_phrase = 'my secure pass phrase goes here'
* salt = '8 octets'
*
* === Encryption
*
* First set up the cipher for encryption
*
* encrypter = OpenSSL::Cipher.new 'AES-128-CBC'
* encrypter.encrypt
* encrypter.pkcs5_keyivgen pass_phrase, salt
*
* Then pass the data you want to encrypt through
*
* encrypted = encrypter.update 'top secret document'
* encrypted << encrypter.final
*
* === Decryption
*
* Use a new Cipher instance set up for decryption
*
* decrypter = OpenSSL::Cipher.new 'AES-128-CBC'
* decrypter.decrypt
* decrypter.pkcs5_keyivgen pass_phrase, salt
*
* Then pass the data you want to decrypt through
*
* plain = decrypter.update encrypted
* plain << decrypter.final
*
* == X509 Certificates
*
* === Creating a Certificate
*
* This example creates a self-signed certificate using an RSA key and a SHA1
* signature.
*
* name = OpenSSL::X509::Name.parse 'CN=nobody/DC=example'
*
* cert = OpenSSL::X509::Certificate.new
* cert.version = 2
* cert.serial = 0
* cert.not_before = Time.now
* cert.not_after = Time.now + 3600
*
* cert.public_key = key.public_key
* cert.subject = name
*
* === Certificate Extensions
*
* You can add extensions to the certificate with
* OpenSSL::SSL::ExtensionFactory to indicate the purpose of the certificate.
*
* extension_factory = OpenSSL::X509::ExtensionFactory.new nil, cert
*
* cert.add_extension \
* extension_factory.create_extension('basicConstraints', 'CA:FALSE', true)
*
* cert.add_extension \
* extension_factory.create_extension(
* 'keyUsage', 'keyEncipherment,dataEncipherment,digitalSignature')
*
* cert.add_extension \
* extension_factory.create_extension('subjectKeyIdentifier', 'hash')
*
* The list of supported extensions (and in some cases their possible values)
* can be derived from the "objects.h" file in the OpenSSL source code.
*
* === Signing a Certificate
*
* To sign a certificate set the issuer and use OpenSSL::X509::Certificate#sign
* with a digest algorithm. This creates a self-signed cert because we're using
* the same name and key to sign the certificate as was used to create the
* certificate.
*
* cert.issuer = name
* cert.sign key, OpenSSL::Digest::SHA1.new
*
* open 'certificate.pem', 'w' do |io| io.write cert.to_pem end
*
* === Loading a Certificate
*
* Like a key, a cert can also be loaded from a file.
*
* cert2 = OpenSSL::X509::Certificate.new File.read 'certificate.pem'
*
* === Verifying a Certificate
*
* Certificate#verify will return true when a certificate was signed with the
* given public key.
*
* raise 'certificate can not be verified' unless cert2.verify key
*
* == Certificate Authority
*
* A certificate authority (CA) is a trusted third party that allows you to
* verify the ownership of unknown certificates. The CA issues key signatures
* that indicate it trusts the user of that key. A user encountering the key
* can verify the signature by using the CA's public key.
*
* === CA Key
*
* CA keys are valuable, so we encrypt and save it to disk and make sure it is
* not readable by other users.
*
* ca_key = OpenSSL::PKey::RSA.new 2048
*
* cipher = OpenSSL::Cipher::Cipher.new 'AES-128-CBC'
*
* open 'ca_key.pem', 'w', 0400 do |io|
* io.write key.export(cipher, pass_phrase)
* end
*
* === CA Certificate
*
* A CA certificate is created the same way we created a certificate above, but
* with different extensions.
*
* ca_name = OpenSSL::X509::Name.parse 'CN=ca/DC=example'
*
* ca_cert = OpenSSL::X509::Certificate.new
* ca_cert.serial = 0
* ca_cert.version = 2
* ca_cert.not_before = Time.now
* ca_cert.not_after = Time.now + 86400
*
* ca_cert.public_key = ca_key.public_key
* ca_cert.subject = ca_name
* ca_cert.issuer = ca_name
*
* extension_factory = OpenSSL::X509::ExtensionFactory.new
* extension_factory.subject_certificate = ca_cert
* extension_factory.issuer_certificate = ca_cert
*
* ca_cert.add_extension \
* extension_factory.create_extension('subjectKeyIdentifier', 'hash')
*
* This extension indicates the CA's key may be used as a CA.
*
* ca_cert.add_extension \
* extension_factory.create_extension('basicConstraints', 'CA:TRUE', true)
*
* This extension indicates the CA's key may be used to verify signatures on
* both certificates and certificate revocations.
*
* ca_cert.add_extension \
* extension_factory.create_extension(
* 'keyUsage', 'cRLSign,keyCertSign', true)
*
* Root CA certificates are self-signed.
*
* ca_cert.sign ca_key, OpenSSL::Digest::SHA1.new
*
* The CA certificate is saved to disk so it may be distributed to all the
* users of the keys this CA will sign.
*
* open 'ca_cert.pem', 'w' do |io|
* io.write ca_cert.to_pem
* end
*
* === Certificate Signing Request
*
* The CA signs keys through a Certificate Signing Request (CSR). The CSR
* contains the information necessary to identify the key.
*
* csr = OpenSSL::X509::Request.new
* csr.version = 0
* csr.subject = name
* csr.public_key = key.public_key
* csr.sign key, OpenSSL::Digest::SHA1.new
*
* A CSR is saved to disk and sent to the CA for signing.
*
* open 'csr.pem', 'w' do |io|
* io.write csr.to_pem
* end
*
* === Creating a Certificate from a CSR
*
* Upon receiving a CSR the CA will verify it before signing it. A minimal
* verification would be to check the CSR's signature.
*
* csr = OpenSSL::X509::Request.new File.read 'csr.pem'
*
* raise 'CSR can not be verified' unless csr.verify csr.public_key
*
* After verification a certificate is created, marked for various usages,
* signed with the CA key and returned to the requester.
*
* csr_cert = OpenSSL::X509::Certificate.new
* csr_cert.serial = 0
* csr_cert.version = 2
* csr_cert.not_before = Time.now
* csr_cert.not_after = Time.now + 600
*
* csr_cert.subject = csr.subject
* csr_cert.public_key = csr.public_key
* csr_cert.issuer = ca_cert.subject
*
* extension_factory = OpenSSL::X509::ExtensionFactory.new
* extension_factory.subject_certificate = csr_cert
* extension_factory.issuer_certificate = ca_cert
*
* csr_cert.add_extension \
* extension_factory.create_extension('basicConstraints', 'CA:FALSE')
*
* csr_cert.add_extension \
* extension_factory.create_extension(
* 'keyUsage', 'keyEncipherment,dataEncipherment,digitalSignature')
*
* csr_cert.add_extension \
* extension_factory.create_extension('subjectKeyIdentifier', 'hash')
*
* csr_cert.sign ca_key, OpenSSL::Digest::SHA1.new
*
* open 'csr_cert.pem', 'w' do |io|
* io.write csr_cert.to_pem
* end
*
* == SSL and TLS Connections
*
* Using our created key and certificate we can create an SSL or TLS connection.
* An SSLContext is used to set up an SSL session.
*
* context = OpenSSL::SSL::SSLContext.new
*
* === SSL Server
*
* An SSL server requires the certificate and private key to communicate
* securely with its clients:
*
* context.cert = cert
* context.key = key
*
* Then create an SSLServer with a TCP server socket and the context. Use the
* SSLServer like an ordinary TCP server.
*
* require 'socket'
*
* tcp_server = TCPServer.new 5000
* ssl_server = OpenSSL::SSL::SSLServer.new tcp_server, context
*
* loop do
* ssl_connection = ssl_server.accept
*
* data = connection.gets
*
* response = "I got #{data.dump}"
* puts response
*
* connection.puts "I got #{data.dump}"
* connection.close
* end
*
* === SSL client
*
* An SSL client is created with a TCP socket and the context.
* SSLSocket#connect must be called to initiate the SSL handshake and start
* encryption. A key and certificate are not required for the client socket.
*
* require 'socket'
*
* tcp_client = TCPSocket.new 'localhost', 5000
* ssl_client = OpenSSL::SSL::SSLSocket.new client_socket, context
* ssl_client.connect
*
* ssl_client.puts "hello server!"
* puts ssl_client.gets
*
* === Peer Verification
*
* An unverified SSL connection does not provide much security. For enhanced
* security the client or server can verify the certificate of its peer.
*
* The client can be modified to verify the server's certificate against the
* certificate authority's certificate:
*
* context.ca_file = 'ca_cert.pem'
* context.verify_mode = OpenSSL::SSL::VERIFY_PEER
*
* require 'socket'
*
* tcp_client = TCPSocket.new 'localhost', 5000
* ssl_client = OpenSSL::SSL::SSLSocket.new client_socket, context
* ssl_client.connect
*
* ssl_client.puts "hello server!"
* puts ssl_client.gets
*
* If the server certificate is invalid or <tt>context.ca_file</tt> is not set
* when verifying peers an OpenSSL::SSL::SSLError will be raised.
*
*/
void
Init_openssl()
{
/*
* Init timezone info
*/
#if 0
tzset();
#endif
/*
* Init all digests, ciphers
*/
/* CRYPTO_malloc_init(); */
/* ENGINE_load_builtin_engines(); */
OpenSSL_add_ssl_algorithms();
OpenSSL_add_all_algorithms();
ERR_load_crypto_strings();
SSL_load_error_strings();
/*
* FIXME:
* On unload do:
*/
#if 0
CONF_modules_unload(1);
destroy_ui_method();
EVP_cleanup();
ENGINE_cleanup();
CRYPTO_cleanup_all_ex_data();
ERR_remove_state(0);
ERR_free_strings();
#endif
/*
* Init main module
*/
mOSSL = rb_define_module("OpenSSL");
/*
* OpenSSL ruby extension version
*/
rb_define_const(mOSSL, "VERSION", rb_str_new2(OSSL_VERSION));
/*
* Version of OpenSSL the ruby OpenSSL extension was built with
*/
rb_define_const(mOSSL, "OPENSSL_VERSION", rb_str_new2(OPENSSL_VERSION_TEXT));
/*
* Version of OpenSSL the ruby OpenSSL extension is running with
*/
rb_define_const(mOSSL, "OPENSSL_LIBRARY_VERSION", rb_str_new2(SSLeay_version(SSLEAY_VERSION)));
/*
* Version number of OpenSSL the ruby OpenSSL extension was built with
* (base 16)
*/
rb_define_const(mOSSL, "OPENSSL_VERSION_NUMBER", INT2NUM(OPENSSL_VERSION_NUMBER));
/*
* Boolean indicating whether OpenSSL is FIPS-enabled or not
*/
#ifdef HAVE_OPENSSL_FIPS
rb_define_const(mOSSL, "OPENSSL_FIPS", Qtrue);
#else
rb_define_const(mOSSL, "OPENSSL_FIPS", Qfalse);
#endif
rb_define_module_function(mOSSL, "fips_mode=", ossl_fips_mode_set, 1);
/*
* Generic error,
* common for all classes under OpenSSL module
*/
eOSSLError = rb_define_class_under(mOSSL,"OpenSSLError",rb_eStandardError);
/*
* Verify callback Proc index for ext-data
*/
if ((ossl_verify_cb_idx = X509_STORE_CTX_get_ex_new_index(0, (void *)"ossl_verify_cb_idx", 0, 0, 0)) < 0)
ossl_raise(eOSSLError, "X509_STORE_CTX_get_ex_new_index");
/*
* Init debug core
*/
dOSSL = Qfalse;
rb_define_module_function(mOSSL, "debug", ossl_debug_get, 0);
rb_define_module_function(mOSSL, "debug=", ossl_debug_set, 1);
rb_define_module_function(mOSSL, "errors", ossl_get_errors, 0);
/*
* Get ID of to_der
*/
ossl_s_to_der = rb_intern("to_der");
/*
* Init components
*/
Init_ossl_bn();
Init_ossl_cipher();
Init_ossl_config();
Init_ossl_digest();
Init_ossl_hmac();
Init_ossl_ns_spki();
Init_ossl_pkcs12();
Init_ossl_pkcs7();
Init_ossl_pkcs5();
Init_ossl_pkey();
Init_ossl_rand();
Init_ossl_ssl();
Init_ossl_x509();
Init_ossl_ocsp();
Init_ossl_engine();
Init_ossl_asn1();
}
int
main(int argc, char **argv)
{
int i;
sigset_t set;
#if ENABLE_MPEGTS
uint32_t adapter_mask = 0;
#endif
int log_level = LOG_INFO;
int log_options = TVHLOG_OPT_MILLIS | TVHLOG_OPT_STDERR | TVHLOG_OPT_SYSLOG;
const char *log_debug = NULL, *log_trace = NULL;
gid_t gid = -1;
uid_t uid = -1;
char buf[512];
FILE *pidfile = NULL;
static struct {
void *thread_id;
struct timeval tv;
uint8_t ru[32];
} randseed;
extern int dvb_bouquets_parse;
main_tid = pthread_self();
/* Setup global mutexes */
pthread_mutex_init(&fork_lock, NULL);
pthread_mutex_init(&global_lock, NULL);
pthread_mutex_init(&tasklet_lock, NULL);
pthread_mutex_init(&atomic_lock, NULL);
pthread_cond_init(>imer_cond, NULL);
pthread_cond_init(&tasklet_cond, NULL);
TAILQ_INIT(&tasklets);
/* Defaults */
tvheadend_webui_port = 9981;
tvheadend_webroot = NULL;
tvheadend_htsp_port = 9982;
tvheadend_htsp_port_extra = 0;
time(&dispatch_clock);
/* Command line options */
int opt_help = 0,
opt_version = 0,
opt_fork = 0,
opt_firstrun = 0,
opt_stderr = 0,
opt_nostderr = 0,
opt_syslog = 0,
opt_nosyslog = 0,
opt_uidebug = 0,
opt_abort = 0,
opt_noacl = 0,
opt_fileline = 0,
opt_threadid = 0,
opt_libav = 0,
opt_ipv6 = 0,
opt_nosatip = 0,
opt_satip_rtsp = 0,
#if ENABLE_TSFILE
opt_tsfile_tuner = 0,
#endif
opt_dump = 0,
opt_xspf = 0,
opt_dbus = 0,
opt_dbus_session = 0,
opt_nobackup = 0,
opt_nobat = 0;
const char *opt_config = NULL,
*opt_user = NULL,
*opt_group = NULL,
*opt_logpath = NULL,
*opt_log_debug = NULL,
*opt_log_trace = NULL,
*opt_pidpath = "/var/run/tvheadend.pid",
#if ENABLE_LINUXDVB
*opt_dvb_adapters = NULL,
#endif
*opt_bindaddr = NULL,
*opt_subscribe = NULL,
*opt_user_agent = NULL;
str_list_t opt_satip_xml = { .max = 10, .num = 0, .str = calloc(10, sizeof(char*)) };
str_list_t opt_tsfile = { .max = 10, .num = 0, .str = calloc(10, sizeof(char*)) };
cmdline_opt_t cmdline_opts[] = {
{ 0, NULL, N_("Generic options"), OPT_BOOL, NULL },
{ 'h', "help", N_("Show this page"), OPT_BOOL, &opt_help },
{ 'v', "version", N_("Show version information"),OPT_BOOL, &opt_version },
{ 0, NULL, N_("Service configuration"), OPT_BOOL, NULL },
{ 'c', "config", N_("Alternate configuration path"), OPT_STR, &opt_config },
{ 'B', "nobackup", N_("Don't backup configuration tree at upgrade"), OPT_BOOL, &opt_nobackup },
{ 'f', "fork", N_("Fork and run as daemon"), OPT_BOOL, &opt_fork },
{ 'u', "user", N_("Run as user"), OPT_STR, &opt_user },
{ 'g', "group", N_("Run as group"), OPT_STR, &opt_group },
{ 'p', "pid", N_("Alternate PID path"), OPT_STR, &opt_pidpath },
{ 'C', "firstrun", N_("If no user account exists then create one with\n"
"no username and no password. Use with care as\n"
"it will allow world-wide administrative access\n"
"to your Tvheadend installation until you create or edit\n"
"the access control from within the Tvheadend web interface."),
OPT_BOOL, &opt_firstrun },
#if ENABLE_DBUS_1
{ 'U', "dbus", N_("Enable DBus"),
OPT_BOOL, &opt_dbus },
{ 'e', "dbus_session", N_("DBus - use the session message bus instead of the system one"),
OPT_BOOL, &opt_dbus_session },
#endif
#if ENABLE_LINUXDVB
{ 'a', "adapters", N_("Only use specified DVB adapters (comma-separated, -1 = none)"),
OPT_STR, &opt_dvb_adapters },
#endif
#if ENABLE_SATIP_SERVER
{ 0, "satip_rtsp", N_("SAT>IP RTSP port number for server\n"
"(default: -1 = disable, 0 = webconfig, standard port is 554)"),
OPT_INT, &opt_satip_rtsp },
#endif
#if ENABLE_SATIP_CLIENT
{ 0, "nosatip", N_("Disable SAT>IP client"),
OPT_BOOL, &opt_nosatip },
{ 0, "satip_xml", N_("URL with the SAT>IP server XML location"),
OPT_STR_LIST, &opt_satip_xml },
#endif
{ 0, NULL, N_("Server connectivity"), OPT_BOOL, NULL },
{ '6', "ipv6", N_("Listen on IPv6"), OPT_BOOL, &opt_ipv6 },
{ 'b', "bindaddr", N_("Specify bind address"), OPT_STR, &opt_bindaddr},
{ 0, "http_port", N_("Specify alternative http port"),
OPT_INT, &tvheadend_webui_port },
{ 0, "http_root", N_("Specify alternative http webroot"),
OPT_STR, &tvheadend_webroot },
{ 0, "htsp_port", N_("Specify alternative htsp port"),
OPT_INT, &tvheadend_htsp_port },
{ 0, "htsp_port2", N_("Specify extra htsp port"),
OPT_INT, &tvheadend_htsp_port_extra },
{ 0, "useragent", N_("Specify User-Agent header for the http client"),
OPT_STR, &opt_user_agent },
{ 0, "xspf", N_("Use XSPF playlist instead of M3U"),
OPT_BOOL, &opt_xspf },
{ 0, NULL, N_("Debug options"), OPT_BOOL, NULL },
{ 'd', "stderr", N_("Enable debug on stderr"), OPT_BOOL, &opt_stderr },
{ 'n', "nostderr", N_("Disable debug on stderr"), OPT_BOOL, &opt_nostderr },
{ 's', "syslog", N_("Enable debug to syslog"), OPT_BOOL, &opt_syslog },
{ 'S', "nosyslog", N_("Disable syslog (all messages)"), OPT_BOOL, &opt_nosyslog },
{ 'l', "logfile", N_("Enable debug to file"), OPT_STR, &opt_logpath },
{ 0, "debug", N_("Enable debug subsystems"), OPT_STR, &opt_log_debug },
#if ENABLE_TRACE
{ 0, "trace", N_("Enable trace subsystems"), OPT_STR, &opt_log_trace },
#endif
{ 0, "fileline", N_("Add file and line numbers to debug"), OPT_BOOL, &opt_fileline },
{ 0, "threadid", N_("Add the thread ID to debug"), OPT_BOOL, &opt_threadid },
#if ENABLE_LIBAV
{ 0, "libav", N_("More verbose libav log"), OPT_BOOL, &opt_libav },
#endif
{ 0, "uidebug", N_("Enable web UI debug (non-minified JS)"), OPT_BOOL, &opt_uidebug },
{ 'A', "abort", N_("Immediately abort"), OPT_BOOL, &opt_abort },
{ 'D', "dump", N_("Enable coredumps for daemon"), OPT_BOOL, &opt_dump },
{ 0, "noacl", N_("Disable all access control checks"),
OPT_BOOL, &opt_noacl },
{ 0, "nobat", N_("Disable DVB bouquets"),
OPT_BOOL, &opt_nobat },
{ 'j', "join", N_("Subscribe to a service permanently"),
OPT_STR, &opt_subscribe },
#if ENABLE_TSFILE || ENABLE_TSDEBUG
{ 0, NULL, N_("Testing options"), OPT_BOOL, NULL },
{ 0, "tsfile_tuners", N_("Number of tsfile tuners"), OPT_INT, &opt_tsfile_tuner },
{ 0, "tsfile", N_("tsfile input (mux file)"), OPT_STR_LIST, &opt_tsfile },
#endif
#if ENABLE_TSDEBUG
{ 0, "tsdebug", N_("Output directory for tsdebug"), OPT_STR, &tvheadend_tsdebug },
#endif
};
/* Get current directory */
tvheadend_cwd0 = dirname(tvh_strdupa(argv[0]));
tvheadend_cwd = dirname(tvh_strdupa(tvheadend_cwd0));
/* Set locale */
setlocale(LC_ALL, "");
setlocale(LC_NUMERIC, "C");
tvh_gettext_init();
/* make sure the timezone is set */
tzset();
/* Process command line */
for (i = 1; i < argc; i++) {
/* Find option */
cmdline_opt_t *opt
= cmdline_opt_find(cmdline_opts, ARRAY_SIZE(cmdline_opts), argv[i]);
if (!opt) {
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts),
_("invalid option specified [%s]"), argv[i]);
continue;
}
/* Process */
if (opt->type == OPT_BOOL)
*((int*)opt->param) = 1;
else if (++i == argc)
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts),
_("option %s requires a value"), opt->lopt);
else if (opt->type == OPT_INT)
*((int*)opt->param) = atoi(argv[i]);
else if (opt->type == OPT_STR_LIST) {
str_list_t *strl = opt->param;
if (strl->num < strl->max)
strl->str[strl->num++] = argv[i];
}
else
*((char**)opt->param) = argv[i];
/* Stop processing */
if (opt_help)
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts), NULL);
if (opt_version)
show_version(argv[0]);
}
/* Additional cmdline processing */
if (opt_nobat)
dvb_bouquets_parse = 0;
#if ENABLE_LINUXDVB
if (!opt_dvb_adapters) {
adapter_mask = ~0;
} else {
char *p, *e;
char *r = NULL;
char *dvb_adapters = strdup(opt_dvb_adapters);
adapter_mask = 0x0;
i = 0;
p = strtok_r(dvb_adapters, ",", &r);
while (p) {
int a = strtol(p, &e, 10);
if (*e != 0 || a > 31) {
fprintf(stderr, _("Invalid adapter number '%s'\n"), p);
free(dvb_adapters);
return 1;
}
i = 1;
if (a < 0)
adapter_mask = 0;
else
adapter_mask |= (1 << a);
p = strtok_r(NULL, ",", &r);
}
free(dvb_adapters);
if (!i) {
fprintf(stderr, "%s", _("No adapters specified!\n"));
return 1;
}
}
#endif
if (tvheadend_webroot) {
char *tmp;
if (*tvheadend_webroot == '/')
tmp = strdup(tvheadend_webroot);
else {
tmp = malloc(strlen(tvheadend_webroot)+2);
*tmp = '/';
strcpy(tmp+1, tvheadend_webroot);
}
if (tmp[strlen(tmp)-1] == '/')
tmp[strlen(tmp)-1] = '\0';
tvheadend_webroot = tmp;
}
tvheadend_webui_debug = opt_uidebug;
/* Setup logging */
if (isatty(2))
log_options |= TVHLOG_OPT_DECORATE;
if (opt_stderr || opt_syslog || opt_logpath) {
if (!opt_log_trace && !opt_log_debug)
log_debug = "all";
log_level = LOG_DEBUG;
if (opt_stderr)
log_options |= TVHLOG_OPT_DBG_STDERR;
if (opt_syslog)
log_options |= TVHLOG_OPT_DBG_SYSLOG;
if (opt_logpath)
log_options |= TVHLOG_OPT_DBG_FILE;
}
if (opt_nostderr)
log_options &= ~(TVHLOG_OPT_DECORATE|TVHLOG_OPT_STDERR|TVHLOG_OPT_DBG_STDERR);
if (opt_nosyslog)
log_options &= ~(TVHLOG_OPT_SYSLOG|TVHLOG_OPT_DBG_SYSLOG);
if (opt_fileline)
log_options |= TVHLOG_OPT_FILELINE;
if (opt_threadid)
log_options |= TVHLOG_OPT_THREAD;
if (opt_libav)
log_options |= TVHLOG_OPT_LIBAV;
if (opt_log_trace) {
log_level = LOG_TRACE;
log_trace = opt_log_trace;
}
if (opt_log_debug)
log_debug = opt_log_debug;
tvhlog_init(log_level, log_options, opt_logpath);
tvhlog_set_debug(log_debug);
tvhlog_set_trace(log_trace);
tvhinfo("main", "Log started");
signal(SIGPIPE, handle_sigpipe); // will be redundant later
signal(SIGILL, handle_sigill); // see handler..
/* Set priviledges */
if(opt_fork || opt_group || opt_user) {
const char *homedir;
struct group *grp = getgrnam(opt_group ?: "video");
struct passwd *pw = opt_user ? getpwnam(opt_user) : NULL;
if(grp != NULL) {
gid = grp->gr_gid;
} else {
gid = 1;
}
if (pw != NULL) {
if (getuid() != pw->pw_uid) {
gid_t glist[16];
int gnum;
gnum = get_user_groups(pw, glist, ARRAY_SIZE(glist));
if (gnum > 0 && setgroups(gnum, glist)) {
char buf[256] = "";
int i;
for (i = 0; i < gnum; i++)
snprintf(buf + strlen(buf), sizeof(buf) - 1 - strlen(buf),
",%d", glist[i]);
tvhlog(LOG_ALERT, "START",
"setgroups(%s) failed, do you have permission?", buf+1);
return 1;
}
}
uid = pw->pw_uid;
homedir = pw->pw_dir;
setenv("HOME", homedir, 1);
} else {
uid = 1;
}
}
uuid_init();
config_boot(opt_config, gid, uid);
tcp_server_preinit(opt_ipv6);
http_server_init(opt_bindaddr); // bind to ports only
htsp_init(opt_bindaddr); // bind to ports only
satip_server_init(opt_satip_rtsp); // bind to ports only
if (opt_fork)
pidfile = tvh_fopen(opt_pidpath, "w+");
if (gid != -1 && (getgid() != gid) && setgid(gid)) {
tvhlog(LOG_ALERT, "START",
"setgid(%d) failed, do you have permission?", gid);
return 1;
}
if (uid != -1 && (getuid() != uid) && setuid(uid)) {
tvhlog(LOG_ALERT, "START",
"setuid(%d) failed, do you have permission?", uid);
return 1;
}
/* Daemonise */
if(opt_fork) {
if(daemon(0, 0)) {
exit(2);
}
if(pidfile != NULL) {
fprintf(pidfile, "%d\n", getpid());
fclose(pidfile);
}
/* Make dumpable */
if (opt_dump) {
#ifdef PLATFORM_LINUX
if (chdir("/tmp"))
tvhwarn("START", "failed to change cwd to /tmp");
prctl(PR_SET_DUMPABLE, 1);
#else
tvhwarn("START", "Coredumps not implemented on your platform");
#endif
}
umask(0);
}
tvheadend_running = 1;
/* Start log thread (must be done post fork) */
tvhlog_start();
/* Alter logging */
if (opt_fork)
tvhlog_options &= ~TVHLOG_OPT_STDERR;
if (!isatty(2))
tvhlog_options &= ~TVHLOG_OPT_DECORATE;
/* Initialise clock */
pthread_mutex_lock(&global_lock);
time(&dispatch_clock);
/* Signal handling */
sigfillset(&set);
sigprocmask(SIG_BLOCK, &set, NULL);
trap_init(argv[0]);
/* SSL library init */
OPENSSL_config(NULL);
SSL_load_error_strings();
SSL_library_init();
/* Rand seed */
randseed.thread_id = (void *)main_tid;
gettimeofday(&randseed.tv, NULL);
uuid_random(randseed.ru, sizeof(randseed.ru));
RAND_seed(&randseed, sizeof(randseed));
/* Initialise configuration */
notify_init();
idnode_init();
spawn_init();
config_init(opt_nobackup == 0);
/**
* Initialize subsystems
*/
epg_in_load = 1;
tvhthread_create(&tasklet_tid, NULL, tasklet_thread, NULL, "tasklet");
dbus_server_init(opt_dbus, opt_dbus_session);
intlconv_init();
api_init();
fsmonitor_init();
libav_init();
tvhtime_init();
profile_init();
imagecache_init();
http_client_init(opt_user_agent);
esfilter_init();
bouquet_init();
service_init();
dvb_init();
#if ENABLE_MPEGTS
mpegts_init(adapter_mask, opt_nosatip, &opt_satip_xml,
&opt_tsfile, opt_tsfile_tuner);
#endif
channel_init();
bouquet_service_resolve();
subscription_init();
dvr_config_init();
access_init(opt_firstrun, opt_noacl);
#if ENABLE_TIMESHIFT
timeshift_init();
#endif
tcp_server_init();
webui_init(opt_xspf);
#if ENABLE_UPNP
upnp_server_init(opt_bindaddr);
#endif
service_mapper_init();
descrambler_init();
epggrab_init();
epg_init();
dvr_init();
dbus_server_start();
http_server_register();
satip_server_register();
htsp_register();
if(opt_subscribe != NULL)
subscription_dummy_join(opt_subscribe, 1);
avahi_init();
bonjour_init();
epg_updated(); // cleanup now all prev ref's should have been created
epg_in_load = 0;
pthread_mutex_unlock(&global_lock);
/**
* Wait for SIGTERM / SIGINT, but only in this thread
*/
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGINT);
signal(SIGTERM, doexit);
signal(SIGINT, doexit);
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
tvhlog(LOG_NOTICE, "START", "HTS Tvheadend version %s started, "
"running as PID:%d UID:%d GID:%d, CWD:%s CNF:%s",
tvheadend_version,
getpid(), getuid(), getgid(), getcwd(buf, sizeof(buf)),
hts_settings_get_root());
if(opt_abort)
abort();
mainloop();
#if ENABLE_DBUS_1
tvhftrace("main", dbus_server_done);
#endif
#if ENABLE_UPNP
tvhftrace("main", upnp_server_done);
#endif
tvhftrace("main", satip_server_done);
tvhftrace("main", htsp_done);
tvhftrace("main", http_server_done);
tvhftrace("main", webui_done);
tvhftrace("main", fsmonitor_done);
tvhftrace("main", http_client_done);
tvhftrace("main", tcp_server_done);
// Note: the locking is obviously a bit redundant, but without
// we need to disable the gtimer_arm call in epg_save()
pthread_mutex_lock(&global_lock);
tvhftrace("main", epg_save);
#if ENABLE_TIMESHIFT
tvhftrace("main", timeshift_term);
#endif
pthread_mutex_unlock(&global_lock);
tvhftrace("main", epggrab_done);
#if ENABLE_MPEGTS
tvhftrace("main", mpegts_done);
#endif
tvhftrace("main", descrambler_done);
tvhftrace("main", service_mapper_done);
tvhftrace("main", service_done);
tvhftrace("main", channel_done);
tvhftrace("main", bouquet_done);
tvhftrace("main", dvr_done);
tvhftrace("main", subscription_done);
tvhftrace("main", access_done);
tvhftrace("main", epg_done);
tvhftrace("main", avahi_done);
tvhftrace("main", bonjour_done);
tvhftrace("main", imagecache_done);
tvhftrace("main", lang_code_done);
tvhftrace("main", api_done);
tvhtrace("main", "tasklet enter");
pthread_cond_signal(&tasklet_cond);
pthread_join(tasklet_tid, NULL);
tvhtrace("main", "tasklet thread end");
tasklet_flush();
tvhtrace("main", "tasklet leave");
tvhftrace("main", dvb_done);
tvhftrace("main", lang_str_done);
tvhftrace("main", esfilter_done);
tvhftrace("main", profile_done);
tvhftrace("main", intlconv_done);
tvhftrace("main", urlparse_done);
tvhftrace("main", idnode_done);
tvhftrace("main", notify_done);
tvhftrace("main", spawn_done);
tvhlog(LOG_NOTICE, "STOP", "Exiting HTS Tvheadend");
tvhlog_end();
tvhftrace("main", config_done);
tvhftrace("main", hts_settings_done);
if(opt_fork)
unlink(opt_pidpath);
#if ENABLE_TSFILE
free(opt_tsfile.str);
#endif
free(opt_satip_xml.str);
/* OpenSSL - welcome to the "cleanup" hell */
ENGINE_cleanup();
RAND_cleanup();
CRYPTO_cleanup_all_ex_data();
EVP_cleanup();
CONF_modules_free();
#ifndef OPENSSL_NO_COMP
COMP_zlib_cleanup();
#endif
ERR_remove_state(0);
ERR_free_strings();
#ifndef OPENSSL_NO_COMP
sk_SSL_COMP_free(SSL_COMP_get_compression_methods());
#endif
/* end of OpenSSL cleanup code */
#if ENABLE_DBUS_1
extern void dbus_shutdown(void);
if (opt_dbus) dbus_shutdown();
#endif
tvh_gettext_done();
return 0;
}
/**
*
*/
void
tvh_str_set(char **strp, const char *src)
{
free(*strp);
*strp = src ? strdup(src) : NULL;
}
/**
*
*/
int
tvh_str_update(char **strp, const char *src)
{
if(src == NULL)
return 0;
free(*strp);
*strp = strdup(src);
return 1;
}
/**
*
*/
void
scopedunlock(pthread_mutex_t **mtxp)
{
pthread_mutex_unlock(*mtxp);
}
NORETURN event_server_main(int argc, char **argv, MULTI_SERVER_FN service,...)
{
const char *myname = "event_server_main";
VSTREAM *stream = 0;
char *root_dir = 0;
char *user_name = 0;
int debug_me = 0;
int daemon_mode = 1;
char *service_name = basename(argv[0]);
int delay;
int c;
int fd;
va_list ap;
MAIL_SERVER_INIT_FN pre_init = 0;
MAIL_SERVER_INIT_FN post_init = 0;
MAIL_SERVER_LOOP_FN loop = 0;
int key;
char *transport = 0;
#if 0
char *lock_path;
VSTRING *why;
#endif
int alone = 0;
int zerolimit = 0;
WATCHDOG *watchdog;
char *oname_val;
char *oname;
char *oval;
const char *err;
char *generation;
int msg_vstream_needed = 0;
int redo_syslog_init = 0;
/*
* Process environment options as early as we can.
*/
if (getenv(CONF_ENV_VERB))
msg_verbose = 1;
if (getenv(CONF_ENV_DEBUG))
debug_me = 1;
/*
* Don't die when a process goes away unexpectedly.
*/
signal(SIGPIPE, SIG_IGN);
/*
* Don't die for frivolous reasons.
*/
#ifdef SIGXFSZ
signal(SIGXFSZ, SIG_IGN);
#endif
/*
* May need this every now and then.
*/
var_procname = mystrdup(basename(argv[0]));
set_mail_conf_str(VAR_PROCNAME, var_procname);
/*
* Initialize logging and exit handler. Do the syslog first, so that its
* initialization completes before we enter the optional chroot jail.
*/
msg_syslog_init(mail_task(var_procname), LOG_PID, LOG_FACILITY);
if (msg_verbose)
msg_info("daemon started");
/*
* Check the Postfix library version as soon as we enable logging.
*/
MAIL_VERSION_CHECK;
/*
* Initialize from the configuration file. Allow command-line options to
* override compiled-in defaults or configured parameter values.
*/
mail_conf_suck();
/*
* Register dictionaries that use higher-level interfaces and protocols.
*/
mail_dict_init();
/*
* After database open error, continue execution with reduced
* functionality.
*/
dict_allow_surrogate = 1;
/*
* Pick up policy settings from master process. Shut up error messages to
* stderr, because no-one is going to see them.
*/
opterr = 0;
while ((c = GETOPT(argc, argv, "cdDi:lm:n:o:s:St:uvVz")) > 0) {
switch (c) {
case 'c':
root_dir = "setme";
break;
case 'd':
daemon_mode = 0;
break;
case 'D':
debug_me = 1;
break;
case 'i':
mail_conf_update(VAR_MAX_IDLE, optarg);
break;
case 'l':
alone = 1;
break;
case 'm':
mail_conf_update(VAR_MAX_USE, optarg);
break;
case 'n':
service_name = optarg;
break;
case 'o':
oname_val = mystrdup(optarg);
if ((err = split_nameval(oname_val, &oname, &oval)) != 0)
msg_fatal("invalid \"-o %s\" option value: %s", optarg, err);
mail_conf_update(oname, oval);
if (strcmp(oname, VAR_SYSLOG_NAME) == 0)
redo_syslog_init = 1;
myfree(oname_val);
break;
case 's':
if ((socket_count = atoi(optarg)) <= 0)
msg_fatal("invalid socket_count: %s", optarg);
break;
case 'S':
stream = VSTREAM_IN;
break;
case 'u':
user_name = "setme";
break;
case 't':
transport = optarg;
break;
case 'v':
msg_verbose++;
break;
case 'V':
if (++msg_vstream_needed == 1)
msg_vstream_init(mail_task(var_procname), VSTREAM_ERR);
break;
case 'z':
zerolimit = 1;
break;
default:
msg_fatal("invalid option: %c", c);
break;
}
}
/*
* Initialize generic parameters.
*/
mail_params_init();
if (redo_syslog_init)
msg_syslog_init(mail_task(var_procname), LOG_PID, LOG_FACILITY);
/*
* If not connected to stdin, stdin must not be a terminal.
*/
if (daemon_mode && stream == 0 && isatty(STDIN_FILENO)) {
msg_vstream_init(var_procname, VSTREAM_ERR);
msg_fatal("do not run this command by hand");
}
/*
* Application-specific initialization.
*/
va_start(ap, service);
while ((key = va_arg(ap, int)) != 0) {
switch (key) {
case MAIL_SERVER_INT_TABLE:
get_mail_conf_int_table(va_arg(ap, CONFIG_INT_TABLE *));
break;
case MAIL_SERVER_LONG_TABLE:
get_mail_conf_long_table(va_arg(ap, CONFIG_LONG_TABLE *));
break;
case MAIL_SERVER_STR_TABLE:
get_mail_conf_str_table(va_arg(ap, CONFIG_STR_TABLE *));
break;
case MAIL_SERVER_BOOL_TABLE:
get_mail_conf_bool_table(va_arg(ap, CONFIG_BOOL_TABLE *));
break;
case MAIL_SERVER_TIME_TABLE:
get_mail_conf_time_table(va_arg(ap, CONFIG_TIME_TABLE *));
break;
case MAIL_SERVER_RAW_TABLE:
get_mail_conf_raw_table(va_arg(ap, CONFIG_RAW_TABLE *));
break;
case MAIL_SERVER_NINT_TABLE:
get_mail_conf_nint_table(va_arg(ap, CONFIG_NINT_TABLE *));
break;
case MAIL_SERVER_NBOOL_TABLE:
get_mail_conf_nbool_table(va_arg(ap, CONFIG_NBOOL_TABLE *));
break;
case MAIL_SERVER_PRE_INIT:
pre_init = va_arg(ap, MAIL_SERVER_INIT_FN);
break;
case MAIL_SERVER_POST_INIT:
post_init = va_arg(ap, MAIL_SERVER_INIT_FN);
break;
case MAIL_SERVER_LOOP:
loop = va_arg(ap, MAIL_SERVER_LOOP_FN);
break;
case MAIL_SERVER_EXIT:
event_server_onexit = va_arg(ap, MAIL_SERVER_EXIT_FN);
break;
case MAIL_SERVER_PRE_ACCEPT:
event_server_pre_accept = va_arg(ap, MAIL_SERVER_ACCEPT_FN);
break;
case MAIL_SERVER_PRE_DISCONN:
event_server_pre_disconn = va_arg(ap, MAIL_SERVER_DISCONN_FN);
break;
case MAIL_SERVER_IN_FLOW_DELAY:
event_server_in_flow_delay = 1;
break;
case MAIL_SERVER_SOLITARY:
if (stream == 0 && !alone)
msg_fatal("service %s requires a process limit of 1",
service_name);
break;
case MAIL_SERVER_UNLIMITED:
if (stream == 0 && !zerolimit)
msg_fatal("service %s requires a process limit of 0",
service_name);
break;
case MAIL_SERVER_PRIVILEGED:
if (user_name)
msg_fatal("service %s requires privileged operation",
service_name);
break;
case MAIL_SERVER_WATCHDOG:
event_server_watchdog = *va_arg(ap, int *);
break;
case MAIL_SERVER_SLOW_EXIT:
event_server_slow_exit = va_arg(ap, MAIL_SERVER_SLOW_EXIT_FN);
break;
default:
msg_panic("%s: unknown argument type: %d", myname, key);
}
}
va_end(ap);
if (root_dir)
root_dir = var_queue_dir;
if (user_name)
user_name = var_mail_owner;
/*
* Can options be required?
*/
if (stream == 0) {
if (transport == 0)
msg_fatal("no transport type specified");
if (strcasecmp(transport, MASTER_XPORT_NAME_INET) == 0)
event_server_accept = event_server_accept_inet;
else if (strcasecmp(transport, MASTER_XPORT_NAME_UNIX) == 0)
event_server_accept = event_server_accept_local;
#ifdef MASTER_XPORT_NAME_PASS
else if (strcasecmp(transport, MASTER_XPORT_NAME_PASS) == 0)
event_server_accept = event_server_accept_pass;
#endif
else
msg_fatal("unsupported transport type: %s", transport);
}
/*
* Retrieve process generation from environment.
*/
if ((generation = getenv(MASTER_GEN_NAME)) != 0) {
if (!alldig(generation))
msg_fatal("bad generation: %s", generation);
OCTAL_TO_UNSIGNED(event_server_generation, generation);
if (msg_verbose)
msg_info("process generation: %s (%o)",
generation, event_server_generation);
}
/*
* Optionally start the debugger on ourself.
*/
if (debug_me)
debug_process();
/*
* Traditionally, BSD select() can't handle multiple processes selecting
* on the same socket, and wakes up every process in select(). See TCP/IP
* Illustrated volume 2 page 532. We avoid select() collisions with an
* external lock file.
*/
/*
* XXX Can't compete for exclusive access to the listen socket because we
* also have to monitor existing client connections for service requests.
*/
#if 0
if (stream == 0 && !alone) {
lock_path = concatenate(DEF_PID_DIR, "/", transport,
".", service_name, (char *) 0);
why = vstring_alloc(1);
if ((event_server_lock = safe_open(lock_path, O_CREAT | O_RDWR, 0600,
(struct stat *) 0, -1, -1, why)) == 0)
msg_fatal("open lock file %s: %s", lock_path, vstring_str(why));
close_on_exec(vstream_fileno(event_server_lock), CLOSE_ON_EXEC);
myfree(lock_path);
vstring_free(why);
}
#endif
/*
* Set up call-back info.
*/
event_server_service = service;
event_server_name = service_name;
event_server_argv = argv + optind;
/*
* Run pre-jail initialization.
*/
if (chdir(var_queue_dir) < 0)
msg_fatal("chdir(\"%s\"): %m", var_queue_dir);
if (pre_init)
pre_init(event_server_name, event_server_argv);
/*
* Optionally, restrict the damage that this process can do.
*/
resolve_local_init();
tzset();
chroot_uid(root_dir, user_name);
/*
* Run post-jail initialization.
*/
if (post_init)
post_init(event_server_name, event_server_argv);
/*
* Are we running as a one-shot server with the client connection on
* standard input? If so, make sure the output is written to stdout so as
* to satisfy common expectation.
*/
if (stream != 0) {
vstream_control(stream,
VSTREAM_CTL_DOUBLE,
VSTREAM_CTL_WRITE_FD, STDOUT_FILENO,
VSTREAM_CTL_END);
service(stream, event_server_name, event_server_argv);
vstream_fflush(stream);
event_server_exit();
}
/*
* Running as a semi-resident server. Service connection requests.
* Terminate when we have serviced a sufficient number of clients, when
* no-one has been talking to us for a configurable amount of time, or
* when the master process terminated abnormally.
*/
if (var_idle_limit > 0)
event_request_timer(event_server_timeout, (char *) 0, var_idle_limit);
for (fd = MASTER_LISTEN_FD; fd < MASTER_LISTEN_FD + socket_count; fd++) {
event_enable_read(fd, event_server_accept, CAST_INT_TO_CHAR_PTR(fd));
close_on_exec(fd, CLOSE_ON_EXEC);
}
event_enable_read(MASTER_STATUS_FD, event_server_abort, (char *) 0);
close_on_exec(MASTER_STATUS_FD, CLOSE_ON_EXEC);
close_on_exec(MASTER_FLOW_READ, CLOSE_ON_EXEC);
close_on_exec(MASTER_FLOW_WRITE, CLOSE_ON_EXEC);
watchdog = watchdog_create(event_server_watchdog,
(WATCHDOG_FN) 0, (char *) 0);
/*
* The event loop, at last.
*/
while (var_use_limit == 0 || use_count < var_use_limit || client_count > 0) {
if (event_server_lock != 0) {
watchdog_stop(watchdog);
if (myflock(vstream_fileno(event_server_lock), INTERNAL_LOCK,
MYFLOCK_OP_EXCLUSIVE) < 0)
msg_fatal("select lock: %m");
}
watchdog_start(watchdog);
delay = loop ? loop(event_server_name, event_server_argv) : -1;
event_loop(delay);
}
event_server_exit();
}
void read_request ( struct process* process )
{
int sock = process->sock, s;
char* buf=process->buf;
char read_complete = 0;
ssize_t count;
while ( 1 )
{
count = read ( sock, buf + process->read_pos, BUF_SIZE - process->read_pos );
if ( count == -1 )
{
if ( errno != EAGAIN )
{
handle_error ( process, "read request" );
return;
}
else
{
//errno == EAGAIN表示读取完毕
break;
}
}
else if ( count == 0 )
{
// 被客户端关闭连接
cleanup ( process );
return;
}
else if ( count > 0 )
{
process->read_pos += count;
}
}
int header_length = process->read_pos;
// determine whether the request is complete
if ( header_length > BUF_SIZE - 1 )
{
process->response_code = 400;
process->status = STATUS_SEND_RESPONSE_HEADER;
strcpy ( process->buf, header_400 );
send_response_header ( process );
handle_error ( processes, "bad request" );
return;
}
buf[header_length]=0;
read_complete = ( strstr ( buf, "\n\n" ) != 0 ) || ( strstr ( buf, "\r\n\r\n" ) != 0 );
int error = 0;
if ( read_complete )
{
//重置读取位置
reset_process ( process );
// get GET info
if ( !strncmp ( buf, "GET", 3 ) == 0 )
{
process->response_code = 400;
process->status = STATUS_SEND_RESPONSE_HEADER;
strcpy ( process->buf, header_400 );
send_response_header ( process );
handle_error ( processes, "bad request" );
return;
}
// get first line
int n_loc = ( int ) strchr ( buf, '\n' );
int space_loc = ( int ) strchr ( buf + 4, ' ' );
if ( n_loc <= space_loc )
{
process->response_code = 400;
process->status = STATUS_SEND_RESPONSE_HEADER;
strcpy ( process->buf, header_400 );
send_response_header ( process );
handle_error ( processes, "bad request" );
return;
}
char path[255];
int len = space_loc - ( int ) buf - 4;
if ( len > MAX_URL_LENGTH )
{
process->response_code = 400;
process->status = STATUS_SEND_RESPONSE_HEADER;
strcpy ( process->buf, header_400 );
send_response_header ( process );
handle_error ( processes, "bad request" );
return;
}
buf[header_length] = 0;
strncpy ( path, buf+4, len );
path[len] = 0;
struct stat filestat;
char fullname[256];
char *prefix = doc_root;
strcpy ( fullname, prefix );
strcpy ( fullname + strlen ( prefix ), path );
s = get_index_file ( fullname, &filestat);
if ( s == -1 )
{
process->response_code = 404;
process->status = STATUS_SEND_RESPONSE_HEADER;
strcpy ( process->buf, header_404 );
send_response_header ( process );
handle_error ( processes, "not found" );
return;
}
int fd = open ( fullname, O_RDONLY );
process->fd = fd;
if ( fd<0 )
{
process->response_code = 404;
process->status = STATUS_SEND_RESPONSE_HEADER;
strcpy ( process->buf, header_404 );
send_response_header ( process );
handle_error ( processes, "not found" );
return;
}
else
{
process->response_code = 200;
}
char tempstring[256];
//检查有无If-Modified-Since，返回304
char* c = strstr ( buf, HEADER_IF_MODIFIED_SINCE );
if(c!=0){
char* rn = strchr(c, '\r');
if(rn==0){
rn = strchr(c, '\n');
if(rn==0){
process->response_code = 400;
process->status = STATUS_SEND_RESPONSE_HEADER;
strcpy ( process->buf, header_400 );
send_response_header ( process );
handle_error ( processes, "bad request" );
return;
}
}
int time_len = rn - c - sizeof(HEADER_IF_MODIFIED_SINCE) + 1;
strncpy(tempstring, c + sizeof(HEADER_IF_MODIFIED_SINCE) - 1,time_len);
tempstring[time_len]=0;
{
struct tm tm;
time_t t;
strptime(tempstring, RFC1123_DATE_FMT, &tm);
tzset();
t=mktime(&tm);
t-=timezone;
gmtime_r(&t, &tm);
if(t >= filestat.st_mtime){
process->response_code = 304;
}
}
}
//开始header
process->buf[0] = 0;
if(process->response_code == 304){
write_to_header ( header_304_start );
} else {
write_to_header ( header_200_start );
}
process->total_length = filestat.st_size;
{
//写入当前时间
struct tm *tm;
time_t tmt;
tmt = time ( NULL );
tm = gmtime ( &tmt );
strftime ( tempstring, sizeof ( tempstring ), RFC1123_DATE_FMT, tm );
write_to_header ( "Date: " );
write_to_header ( tempstring );
write_to_header ( "\r\n" );
//写入文件修改时间
tm = gmtime ( &filestat.st_mtime );
strftime ( tempstring, sizeof ( tempstring ), RFC1123_DATE_FMT, tm );
write_to_header ( "Last-modified: " );
write_to_header ( tempstring );
write_to_header ( "\r\n" );
if(process->response_code == 200){
//写入content长度
sprintf ( tempstring, "Content-Length: %ld\r\n", filestat.st_size );
write_to_header ( tempstring );
}
}
//结束header
write_to_header ( header_end );
process->status = STATUS_SEND_RESPONSE_HEADER;
//修改此sock的监听状态，改为监视写状态
event.data.fd = process->sock;
event.events = EPOLLOUT | EPOLLET;
s = epoll_ctl ( efd, EPOLL_CTL_MOD, process->sock, &event );
if ( s == -1 )
{
perror ( "epoll_ctl" );
abort ();
}
//发送header
send_response_header ( process );
}
}