int main (int argc, char **argv)
{
int i, c;
int pid_flags = 0;
char *local_port = NULL;
char *local_addr = NULL;
char *password = NULL;
char *timeout = NULL;
char *method = NULL;
char *pid_path = NULL;
char *conf_path = NULL;
char *iface = NULL;
int remote_num = 0;
char *remote_host[MAX_REMOTE_NUM];
char *remote_port = NULL;
opterr = 0;
while ((c = getopt (argc, argv, "f:s:p:l:k:t:m:i:c:b:uv")) != -1)
{
switch (c)
{
case 's':
remote_host[remote_num++] = optarg;
break;
case 'p':
remote_port = optarg;
break;
case 'l':
local_port = optarg;
break;
case 'k':
password = optarg;
break;
case 'f':
pid_flags = 1;
pid_path = optarg;
break;
case 't':
timeout = optarg;
break;
case 'm':
method = optarg;
break;
case 'c':
conf_path = optarg;
break;
case 'i':
iface = optarg;
break;
case 'b':
local_addr = optarg;
break;
case 'u':
udprelay = 1;
break;
case 'v':
verbose = 1;
break;
}
}
if (opterr)
{
usage();
exit(EXIT_FAILURE);
}
if (conf_path != NULL)
{
jconf_t *conf = read_jconf(conf_path);
if (remote_num == 0)
{
remote_num = conf->remote_num;
for (i = 0; i < remote_num; i++)
{
remote_host[i] = conf->remote_host[i];
}
}
if (remote_port == NULL) remote_port = conf->remote_port;
if (local_port == NULL) local_port = conf->local_port;
if (password == NULL) password = conf->password;
if (method == NULL) method = conf->method;
if (timeout == NULL) timeout = conf->timeout;
}
if (remote_num == 0 || remote_port == NULL ||
local_port == NULL || password == NULL)
{
usage();
exit(EXIT_FAILURE);
}
if (timeout == NULL) timeout = "10";
if (local_addr == NULL) local_addr = "0.0.0.0";
if (pid_flags)
{
demonize(pid_path);
}
#ifdef __MINGW32__
winsock_init();
#else
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGABRT, SIG_IGN);
#endif
// Setup keys
LOGD("initialize ciphers... %s", method);
int m = enc_init(password, method);
// Setup socket
int listenfd;
listenfd = create_and_bind(local_addr, local_port);
if (listenfd < 0)
{
FATAL("bind() error..");
}
if (listen(listenfd, SOMAXCONN) == -1)
{
FATAL("listen() error.");
}
setnonblocking(listenfd);
LOGD("server listening at port %s.", local_port);
// Setup proxy context
struct listen_ctx listen_ctx;
listen_ctx.remote_num = remote_num;
listen_ctx.remote_host = malloc(sizeof(char *) * remote_num);
while (remote_num > 0)
{
int index = --remote_num;
listen_ctx.remote_host[index] = remote_host[index];
}
listen_ctx.remote_port = remote_port;
listen_ctx.timeout = atoi(timeout);
listen_ctx.fd = listenfd;
listen_ctx.iface = iface;
listen_ctx.method = m;
struct ev_loop *loop = ev_default_loop(0);
if (!loop)
{
FATAL("ev_loop error.");
}
ev_io_init (&listen_ctx.io, accept_cb, listenfd, EV_READ);
ev_io_start (loop, &listen_ctx.io);
// Setup UDP
if (udprelay)
{
LOGD("udprelay enabled.");
udprelay_init(local_addr, local_port, remote_host[0], remote_port, m, iface);
}
ev_run (loop, 0);
#ifdef __MINGW32__
winsock_cleanup();
#endif
return 0;
}
int main(int argc, char **argv) {
int opt;
int option_index = 0;
char *socket_path = getenv("I3SOCK");
char *i3_default_sock_path = "/tmp/i3-ipc.sock";
/* Initialize the standard config to use 0 as default */
memset(&config, '\0', sizeof(config_t));
static struct option long_opt[] = {
{ "socket", required_argument, 0, 's' },
{ "bar_id", required_argument, 0, 'b' },
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'v' },
{ NULL, 0, 0, 0}
};
while ((opt = getopt_long(argc, argv, "b:s:hv", long_opt, &option_index)) != -1) {
switch (opt) {
case 's':
socket_path = expand_path(optarg);
break;
case 'v':
printf("i3bar version " I3_VERSION " © 2010-2014 Axel Wagner and contributors\n");
exit(EXIT_SUCCESS);
break;
case 'b':
config.bar_id = sstrdup(optarg);
break;
default:
print_usage(argv[0]);
exit(EXIT_SUCCESS);
break;
}
}
if (!config.bar_id) {
/* TODO: maybe we want -f which will automatically ask i3 for the first
* configured bar (and error out if there are too many)? */
ELOG("No bar_id passed. Please let i3 start i3bar or specify --bar_id\n");
exit(EXIT_FAILURE);
}
main_loop = ev_default_loop(0);
char *atom_sock_path = init_xcb_early();
if (socket_path == NULL) {
socket_path = atom_sock_path;
}
if (socket_path == NULL) {
ELOG("No Socket Path Specified, default to %s\n", i3_default_sock_path);
socket_path = expand_path(i3_default_sock_path);
}
init_outputs();
if (init_connection(socket_path)) {
/* Request the bar configuration. When it arrives, we fill the config array. */
i3_send_msg(I3_IPC_MESSAGE_TYPE_GET_BAR_CONFIG, config.bar_id);
}
/* We listen to SIGTERM/QUIT/INT and try to exit cleanly, by stopping the main-loop.
* We only need those watchers on the stack, so putting them on the stack saves us
* some calls to free() */
ev_signal *sig_term = smalloc(sizeof(ev_signal));
ev_signal *sig_int = smalloc(sizeof(ev_signal));
ev_signal *sig_hup = smalloc(sizeof(ev_signal));
ev_signal_init(sig_term, &sig_cb, SIGTERM);
ev_signal_init(sig_int, &sig_cb, SIGINT);
ev_signal_init(sig_hup, &sig_cb, SIGHUP);
ev_signal_start(main_loop, sig_term);
ev_signal_start(main_loop, sig_int);
ev_signal_start(main_loop, sig_hup);
/* From here on everything should run smooth for itself, just start listening for
* events. We stop simply stop the event-loop, when we are finished */
ev_loop(main_loop, 0);
kill_child();
FREE(l_statusline_buffer);
FREE(r_statusline_buffer);
clean_xcb();
ev_default_destroy();
free_workspaces();
return 0;
}
int main(int argc, char **argv) {
ws_server_t serv;
ws_quickstart(&serv, "127.0.0.1", 8080, reply);
ev_loop (ev_default_loop(0), 0);
return 0;
}
int main (int argc, char **argv)
{
int i, c;
int pid_flags = 0;
char *user = NULL;
char *local_port = NULL;
char *local_addr = NULL;
char *password = NULL;
char *timeout = NULL;
char *method = NULL;
char *pid_path = NULL;
char *conf_path = NULL;
char *iface = NULL;
int remote_num = 0;
ss_addr_t remote_addr[MAX_REMOTE_NUM];
char *remote_port = NULL;
int option_index = 0;
static struct option long_options[] = {
{"fast-open", no_argument, 0, 0 },
{0, 0, 0, 0 }
};
opterr = 0;
while ((c = getopt_long(argc, argv, "f:s:p:l:k:t:m:i:c:b:a:uv",
long_options, &option_index)) != -1)
{
switch (c)
{
case 0:
if (option_index == 0)
{
#ifdef TCP_FASTOPEN
fast_open = 1;
LOGD("using tcp fast open");
#else
LOGE("tcp fast open is not supported by this environment");
#endif
}
break;
case 's':
remote_addr[remote_num].host = optarg;
remote_addr[remote_num++].port = NULL;
break;
case 'p':
remote_port = optarg;
break;
case 'l':
local_port = optarg;
break;
case 'k':
password = optarg;
break;
case 'f':
pid_flags = 1;
pid_path = optarg;
break;
case 't':
timeout = optarg;
break;
case 'm':
method = optarg;
break;
case 'c':
conf_path = optarg;
break;
case 'i':
iface = optarg;
break;
case 'b':
local_addr = optarg;
break;
case 'a':
user = optarg;
break;
case 'u':
udprelay = 1;
break;
case 'v':
verbose = 1;
break;
}
}
if (opterr)
{
usage();
exit(EXIT_FAILURE);
}
if (conf_path != NULL)
{
jconf_t *conf = read_jconf(conf_path);
if (remote_num == 0)
{
remote_num = conf->remote_num;
for (i = 0; i < remote_num; i++)
{
remote_addr[i] = conf->remote_addr[i];
}
}
if (remote_port == NULL) remote_port = conf->remote_port;
if (local_addr == NULL) local_addr = conf->local_addr;
if (local_port == NULL) local_port = conf->local_port;
if (password == NULL) password = conf->password;
if (method == NULL) method = conf->method;
if (timeout == NULL) timeout = conf->timeout;
if (fast_open == 0) fast_open = conf->fast_open;
}
if (remote_num == 0 || remote_port == NULL ||
local_port == NULL || password == NULL)
{
usage();
exit(EXIT_FAILURE);
}
if (timeout == NULL) timeout = "10";
if (local_addr == NULL) local_addr = "0.0.0.0";
if (pid_flags)
{
USE_SYSLOG(argv[0]);
demonize(pid_path);
}
#ifdef __MINGW32__
winsock_init();
#else
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGABRT, SIG_IGN);
#endif
// Setup keys
LOGD("initialize ciphers... %s", method);
int m = enc_init(password, method);
// Setup socket
int listenfd;
listenfd = create_and_bind(local_addr, local_port);
if (listenfd < 0)
{
FATAL("bind() error..");
}
if (listen(listenfd, SOMAXCONN) == -1)
{
FATAL("listen() error.");
}
setnonblocking(listenfd);
LOGD("server listening at port %s.", local_port);
// Setup proxy context
struct listen_ctx listen_ctx;
listen_ctx.remote_num = remote_num;
listen_ctx.remote_addr = malloc(sizeof(ss_addr_t) * remote_num);
while (remote_num > 0)
{
int index = --remote_num;
if (remote_addr[index].port == NULL) remote_addr[index].port = remote_port;
listen_ctx.remote_addr[index] = remote_addr[index];
}
listen_ctx.timeout = atoi(timeout);
listen_ctx.fd = listenfd;
listen_ctx.iface = iface;
listen_ctx.method = m;
struct ev_loop *loop = ev_default_loop(0);
if (!loop)
{
FATAL("ev_loop error.");
}
ev_io_init (&listen_ctx.io, accept_cb, listenfd, EV_READ);
ev_io_start (loop, &listen_ctx.io);
// Setup UDP
if (udprelay)
{
LOGD("udprelay enabled.");
udprelay_init(local_addr, local_port, remote_addr[0].host, remote_addr[0].port, m, listen_ctx.timeout, iface);
}
// setuid
if (user != NULL)
run_as(user);
ev_run (loop, 0);
#ifdef __MINGW32__
winsock_cleanup();
#endif
return 0;
}
int
main (int argc, char **argv)
{
struct ev_loop *loop;
struct timeval tv[2];
char dirname[10];
char *shmdata;
int rundir, rundirs[NUM_PROCS], sharedir;
int pagesize;
int i, j;
// use the default event loop unless you have special needs
loop = ev_default_loop (EVBACKEND_EPOLL); //EVFLAG_AUTO);
rundir = get_rundir();
pagesize = getpagesize();
// Prepare shared data directory
if ((mkdirat(rundir, SHARE_DIR_NAME, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) != 0) {
fprintf(stderr, "could not make share directory: %s\n", strerror(errno));
return -1;
}
if ((sharedir = openat(rundir, SHARE_DIR_NAME, O_DIRECTORY)) < 0) {
fprintf(stderr, "could not open share directory: %s\n", strerror(errno));
return -1;
}
// Prepare worker rundirs
for (i=0; i<NUM_PROCS; ++i) {
sprintf(dirname, "%d", i);
if ((mkdirat(rundir, dirname, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) != 0) {
fprintf(stderr, "worker %d: could not make runtime directory: %s\n", i, strerror(errno));
return -1;
}
if ((rundirs[i] = openat(rundir, dirname, O_DIRECTORY)) < 0) {
fprintf(stderr, "worker %d: could not open runtime directory: %s\n", i, strerror(errno));
return -1;
}
if ((mkfifoat(rundirs[i], "inputfile", S_IRUSR | S_IWUSR)) != 0) {
fprintf(stderr, "%s: could not create FIFO: %s\n", "inputfile", strerror(errno));
}
}
// Memory map some data;
for (j=0; j<NUM_SHMS; ++j) {
// Maybe just use ids for shared SHM names
shms[j] = openat(sharedir, "dbfile", O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
ftruncate(shms[j], pagesize);
shmdata = mmap((caddr_t)0, pagesize, PROT_WRITE, MAP_SHARED, shms[j], 0);
strcpy(shmdata, "Very important DB data.");
// Now "share" it
for (i=0; i<NUM_PROCS; ++i) {
linkat(sharedir, "dbfile", rundirs[i], "dbfile", 0);
}
}
//ev_set_timeout_collect_interval (loop, 0.0001);
//ev_set_io_collect_interval (loop, 0.0001);
// Start children
for (i=0; i<NUM_PROCS; ++i) {
pid_t pid = fork();
if (pid == 0) {
// Child
fchdir(rundirs[i]);
if (execle(argv[1], gnu_basename(argv[1]), "outputfile", "dbfile", "inputfile", NULL, NULL)) {
fputs("Could not exec: ", stderr);
fputs(strerror(errno), stderr);
fputc('\n', stderr);
exit(EXIT_FAILURE);
}
}
else if (pid > 0) {
// Parent
}
}
// Initialize watchers
for (i=0; i<NUM_PROCS; ++i) {
ev_io *wio = &input_watcher[i];
fifos[i] = openat(rundirs[i], "inputfile", O_WRONLY);
wio->data = (void*)i;
ev_io_init(wio, input_cb, fifos[i], EV_WRITE);
ev_io_start(loop, wio);
}
ev_child *wchld = &child_watcher;
ev_child_init(wchld, child_cb, 0, 1);
ev_child_start(loop, wchld);
// now wait for events to arrive
gettimeofday(tv+0, NULL);
ev_loop (loop, 0);
gettimeofday(tv+1, NULL);
// unloop was called, so exit
long t = (tv[1].tv_sec - tv[0].tv_sec) * 1000000
+ (tv[1].tv_usec - tv[0].tv_usec);
printf("\nTime taken: %lfs (%lfms average)\n\n",
((double)t) / 1000000.0,
((double)t) * NUM_PROCS / NUM_JOBS);
// Hang up
/*
puts("Closing pipes...");
for (i=0; i<NUM_PROCS; ++i) {
close(fifos[i]);
}
*/
puts("Waiting for children processes to terminate...");
pid_t pid;
do {
pid = wait(NULL);
if(pid == -1 && errno != ECHILD) {
perror("Error during wait()");
abort();
}
} while (pid > 0);
// Cleanup shms
puts("Cleaning SHMs...");
for (j=0; j<NUM_SHMS; ++j) {
ftruncate(shms[j], 0);
close(shms[i]);
}
// Finally...
puts("Done.");
return 0;
}
int main(int argc, char **argv)
{
int i, c;
int pid_flags = 0;
char *user = NULL;
char *local_port = NULL;
char *local_addr = NULL;
char *password = NULL;
char *timeout = NULL;
char *method = NULL;
char *pid_path = NULL;
char *conf_path = NULL;
int remote_num = 0;
ss_addr_t remote_addr[MAX_REMOTE_NUM];
char *remote_port = NULL;
opterr = 0;
while ((c = getopt(argc, argv, "f:s:p:l:k:t:m:c:b:a:")) != -1) {
switch (c) {
case 's':
remote_addr[remote_num].host = optarg;
remote_addr[remote_num++].port = NULL;
break;
case 'p':
remote_port = optarg;
break;
case 'l':
local_port = optarg;
break;
case 'k':
password = optarg;
break;
case 'f':
pid_flags = 1;
pid_path = optarg;
break;
case 't':
timeout = optarg;
break;
case 'm':
method = optarg;
break;
case 'c':
conf_path = optarg;
break;
case 'b':
local_addr = optarg;
break;
case 'a':
user = optarg;
break;
}
}
if (opterr) {
usage();
exit(EXIT_FAILURE);
}
if (conf_path != NULL) {
jconf_t *conf = read_jconf(conf_path);
if (remote_num == 0) {
remote_num = conf->remote_num;
for (i = 0; i < remote_num; i++) {
remote_addr[i] = conf->remote_addr[i];
}
}
if (remote_port == NULL) {
remote_port = conf->remote_port;
}
if (local_addr == NULL) {
local_addr = conf->local_addr;
}
if (local_port == NULL) {
local_port = conf->local_port;
}
if (password == NULL) {
password = conf->password;
}
if (method == NULL) {
method = conf->method;
}
if (timeout == NULL) {
timeout = conf->timeout;
}
}
if (remote_num == 0 || remote_port == NULL ||
local_port == NULL || password == NULL) {
usage();
exit(EXIT_FAILURE);
}
if (timeout == NULL) {
timeout = "10";
}
if (local_addr == NULL) {
local_addr = "0.0.0.0";
}
if (pid_flags) {
USE_SYSLOG(argv[0]);
daemonize(pid_path);
}
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGABRT, SIG_IGN);
// Setup keys
LOGD("initialize ciphers... %s", method);
int m = enc_init(password, method);
// Setup socket
int listenfd;
listenfd = create_and_bind(local_addr, local_port);
if (listenfd < 0) {
FATAL("bind() error..");
}
if (listen(listenfd, SOMAXCONN) == -1) {
FATAL("listen() error.");
}
setnonblocking(listenfd);
LOGD("server listening at port %s.", local_port);
// Setup proxy context
struct listen_ctx listen_ctx;
listen_ctx.remote_num = remote_num;
listen_ctx.remote_addr = malloc(sizeof(ss_addr_t) * remote_num);
while (remote_num > 0) {
int index = --remote_num;
if (remote_addr[index].port == NULL) {
remote_addr[index].port = remote_port;
}
listen_ctx.remote_addr[index] = remote_addr[index];
}
listen_ctx.timeout = atoi(timeout);
listen_ctx.fd = listenfd;
listen_ctx.method = m;
struct ev_loop *loop = ev_default_loop(0);
if (!loop) {
FATAL("ev_loop error.");
}
ev_io_init(&listen_ctx.io, accept_cb, listenfd, EV_READ);
ev_io_start(loop, &listen_ctx.io);
// setuid
if (user != NULL) {
run_as(user);
}
ev_run(loop, 0);
return 0;
}
void crawl(arguments *arg) {
// Add Ctrl+c handling
done = 0;
signal(SIGINT, finish);
global_info global;
memset(&global, 0, sizeof(global_info));
char search_name[SEARCH_NAME_LEN];
memset(search_name, '\0', SEARCH_NAME_LEN * sizeof(char));
/* Init before looping starts */
global.out_name = arg->out_file;
if (0 == (global.out = fopen(global.out_name, "w+"))) {
orcerror("%s (%d) %s\n", strerror(errno), errno, global.out_name);
exit(EXIT_FAILURE);
}
global.job_max = arg->max_events;
global.loop = ev_default_loop(0);
global.multi = curl_multi_init();
ev_timer_init(&(global.timer_event), socket_action_timer_cb, 0., 0.);
global.timer_event.data = &global;
curl_multi_setopt(global.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(global.multi, CURLMOPT_TIMERDATA, &global);
curl_multi_setopt(global.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(global.multi, CURLMOPT_SOCKETDATA, &global);
bintree_init(&(global.url_tree), bintree_streq, free_tree);
global.input.search_name = search_name;
global.input.search_name_len = SEARCH_NAME_LEN;
global.input.excludes = arg->excludes;
global.input.excludes_len = arg->excludes_len;
if (!find_search_name(arg->url, search_name , SEARCH_NAME_LEN))
{
orcerror("not a valid domain name or ip in: %s\n", arg->url);
exit(EXIT_FAILURE);
}
orcoutc(orc_reset, orc_blue, "Target %s\n", global.input.search_name);
add_first_call(arg, &global);
struct timeval start;
struct timeval stop;
/* Lets find some urls */
gettimeofday(&start, 0);
ev_loop(global.loop, 0);
gettimeofday(&stop, 0);
print_stats(&global, &start, &stop);
/* Cleanups after looping */
fclose(global.out);
free_array_of_charptr_incl(&(global.input.ret), global.input.ret_len);
bintree_free(&(global.url_tree));
curl_multi_cleanup(global.multi);
char *url_item = 0;
int i = 0;
while (0 != (url_item = url_get(&global))) {
free(url_item);
i++;
}
orcout(orcm_debug, "Freed %d url items.\n", i);
}
int main(int argc, char *argv[])
{
char *ctrlchnlname = NULL;
vnode_client_cmdiotype_t iotype = VCMD_IO_FD;
ev_timer cmdreq;
extern const char *__progname;
#ifdef FORWARD_SIGNALS
int i;
struct sigaction sig_action = {
.sa_handler = sighandler,
};
#endif /* FORWARD_SIGNALS */
char *def_argv[2] = { VCMD_DEFAULT_CMD, 0 };
if (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO) &&
isatty(STDERR_FILENO) && getpgrp() == tcgetpgrp(STDOUT_FILENO))
iotype = VCMD_IO_PTY;
/* Parse command line argument list */
for (;;)
{
int opt;
if ((opt = getopt_long(argc, argv, "c:hiIqvV", longopts, NULL)) == -1)
break;
switch (opt)
{
case 'c':
ctrlchnlname = optarg;
break;
case 'i':
iotype = VCMD_IO_PTY;
break;
case 'I':
iotype = VCMD_IO_FD;
break;
case 'q':
iotype = VCMD_IO_NONE;
break;
case 'v':
verbose++;
break;
case 'V':
printf("%s version %s\n", __progname, CORE_VERSION);
exit(0);
case 'h':
/* pass through */
default:
usage(0, NULL);
}
}
argc -= optind;
argv += optind;
if (ctrlchnlname == NULL)
usage(1, "no control channel name given");
if (!argc)
{
argc = 1;
argv = def_argv;
}
if (argc >= VNODE_ARGMAX)
usage(1, "too many command arguments");
if (atexit(cleanup))
ERR(1, "atexit() failed");
#ifdef FORWARD_SIGNALS
for (i = 1; i < _NSIG; i++)
if (sigaction(i, &sig_action, NULL))
if (verbose && i != SIGKILL && i != SIGSTOP)
WARN("sigaction() failed for %d", i);
#endif /* FORWARD_SIGNALS */
vcmd.cmdio = vnode_open_clientcmdio(iotype);
if (!vcmd.cmdio)
ERR(1, "vnode_open_clientcmdio() failed");
vcmd.argc = argc;
vcmd.argv = argv;
vcmd.cmdstatus = 255;
switch (vcmd.cmdio->iotype)
{
case VCMD_IO_NONE:
break;
case VCMD_IO_FD:
SET_STDIOFD(vcmd.cmdio, STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO);
break;
case VCMD_IO_PTY:
{
struct sigaction sigwinch_action = {
.sa_handler = sigwinch_handler,
};
if (sigaction(SIGWINCH, &sigwinch_action, NULL))
WARN("sigaction() failed for SIGWINCH");
sigwinch_handler(SIGWINCH);
if (termioraw(STDOUT_FILENO, &saveattr))
WARNX("termioraw() failed");
else
saveattr_set = 1;
}
break;
default:
ERR(1, "unsupported i/o type: %u", vcmd.cmdio->iotype);
break;
}
vcmd.client = vnode_client(ev_default_loop(0), ctrlchnlname,
vcmd_ioerrorcb, &vcmd);
if (!vcmd.client)
ERR(1, "vnode_client() failed");
cmdreq.data = &vcmd;
ev_timer_init(&cmdreq, vcmd_cmdreqcb, 0, 0);
ev_timer_start(vcmd.client->loop, &cmdreq);
ev_loop(vcmd.client->loop, 0);
vnode_delclient(vcmd.client);
exit(vcmd.cmdstatus);
}
int main(int argc, char *argv[]) {
static struct option long_options[] = {
{"getmonitors_reply", required_argument, 0, 0},
{0, 0, 0, 0},
};
char *options_string = "";
int opt;
int option_index = 0;
while ((opt = getopt_long(argc, argv, options_string, long_options, &option_index)) != -1) {
switch (opt) {
case 0:
if (strcmp(long_options[option_index].name, "getmonitors_reply") == 0) {
must_read_reply(optarg);
}
break;
default:
exit(EXIT_FAILURE);
}
}
if (optind >= argc) {
errx(EXIT_FAILURE, "syntax: %s [options] <command>\n", argv[0]);
}
int fd = socket(AF_LOCAL, SOCK_STREAM, 0);
if (fd == -1) {
err(EXIT_FAILURE, "socket(AF_UNIX)");
}
if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
warn("Could not set FD_CLOEXEC");
}
struct sockaddr_un addr;
memset(&addr, 0, sizeof(struct sockaddr_un));
addr.sun_family = AF_UNIX;
int i;
bool bound = false;
for (i = 0; i < 100; i++) {
/* XXX: The path to X11 sockets differs on some platforms (e.g. Trusted
* Solaris, HPUX), but since libxcb doesn’t provide a function to
* generate the path, we’ll just have to hard-code it for now. */
snprintf(addr.sun_path, sizeof(addr.sun_path), "/tmp/.X11-unix/X%d", i);
if (bind(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
warn("bind(%s)", addr.sun_path);
} else {
bound = true;
/* Let the user know bind() was successful, so that they know the
* error messages can be disregarded. */
fprintf(stderr, "Successfuly bound to %s\n", addr.sun_path);
sun_path = sstrdup(addr.sun_path);
break;
}
}
if (!bound) {
err(EXIT_FAILURE, "bind()");
}
atexit(cleanup_socket);
/* This program will be started for each testcase which requires it, so we
* expect precisely one connection. */
if (listen(fd, 1) == -1) {
err(EXIT_FAILURE, "listen()");
}
pid_t child = fork();
if (child == -1) {
err(EXIT_FAILURE, "fork()");
}
if (child == 0) {
char *display;
sasprintf(&display, ":%d", i);
setenv("DISPLAY", display, 1);
free(display);
char **child_args = argv + optind;
execvp(child_args[0], child_args);
err(EXIT_FAILURE, "exec()");
}
struct ev_loop *loop = ev_default_loop(0);
ev_child cw;
ev_child_init(&cw, child_cb, child, 0);
ev_child_start(loop, &cw);
ev_io watcher;
ev_io_init(&watcher, uds_connection_cb, fd, EV_READ);
ev_io_start(loop, &watcher);
ev_run(loop, 0);
}
int main() {
#if defined _WIN32
WORD w_version_requested;
WSADATA wsa_data;
int err;
w_version_requested = MAKEWORD(2, 2);
err = WSAStartup(w_version_requested, &wsa_data);
if (err != 0) {
printf("WSAStartup failed with error: %d\n", err);
return 1;
}
#endif
EV_A = ev_default_loop(0);
if (EV_A == NULL) {
printf("ev_default_loop failed!\n");
goto error;
}
struct addrinfo hints;
struct addrinfo *res;
char bol_reuseaddr = 1;
// Get address info
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
int int_status = getaddrinfo(NULL, "8080", &hints, &res);
if (int_status != 0) {
wprintf(L"getaddrinfo failed: %d (%s)\n", int_status, gai_strerror(int_status));
goto error;
}
// Get socket to bind
int_sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (int_sock == INVALID_SOCKET) {
printf("Failed to create socket: %s (%d)\n", strerror(errno), errno);
goto error;
}
if (setsockopt(int_sock, SOL_SOCKET, SO_REUSEADDR, &bol_reuseaddr, sizeof(int)) == -1) {
printf("setsockopt failed: %s (%d)\n", strerror(errno), errno);
goto error;
}
if (bind(int_sock, res->ai_addr, res->ai_addrlen) == -1) {
printf("bind failed: %s (%d)\n", strerror(errno), errno);
goto error;
}
freeaddrinfo(res);
if (listen(int_sock, 10) == -1) {
printf("listen failed: %s (%d)\n", strerror(errno), errno);
goto error;
}
int int_ret;
if ((int_ret = setnonblock(int_sock)) != 0) {
printf("setnonblock failed: %d\n", int_ret);
goto error;
}
#if defined _WIN32
int fd = _open_osfhandle(int_sock, 0);
ev_io_init(&server_io, server_cb, fd, EV_READ);
#else
ev_io_init(&server_io, server_cb, int_sock, EV_READ);
#endif
ev_io_start(EV_A, &server_io);
ev_run(EV_A, 0);
#if defined _WIN32
_close(fd);
#else
close(int_sock);
#endif
#if defined _WIN32
WSACleanup();
#endif
return 0;
error:
#if defined _WIN32
WSACleanup();
#endif
return 1;
}
int main(int argc, char** argv) {
dmn_init_log("gdnsd_extmon_helper", true);
// start up syslog IFF it appears the daemon
// was *not* started via "startfg". Regular
// start/restart would have /dev/null'd the
// standard descriptors before forking us off.
if(!isatty(0))
dmn_start_syslog();
// Bail out early if we don't have the right argument
// count, and try to tell the user not to run us
// if stderr happens to be hooked up to a terminal
if(argc != 5) {
fprintf(stderr, "This binary is not for human execution!\n");
abort();
}
// open stderr logging connection using passed fd
dmn_log_set_alt_stderr(atoi(argv[2]));
// regardless, we seal off stdin now. We don't need it,
// and this way we don't have to deal with it when
// execv()-ing child commands later.
if(!freopen("/dev/null", "r", stdin))
dmn_log_fatal("Cannot open /dev/null: %s", dmn_strerror(errno));
if(!strcmp(argv[1], "Y"))
dmn_set_debug(true);
else if(!strcmp(argv[1], "N"))
dmn_set_debug(false);
else
log_fatal("Invalid debug argument on cmdline: '%s'!", argv[1]);
// these are the main communication pipes to the daemon/plugin
plugin_read_fd = atoi(argv[3]);
plugin_write_fd = atoi(argv[4]);
if(plugin_read_fd < 3 || plugin_read_fd > 1000
|| plugin_write_fd < 3 || plugin_write_fd > 1000)
log_fatal("Invalid pipe descriptors!");
// CLOEXEC the direct lines to the main plugin/daemon,
// so that child scripts can't screw with them.
if(fcntl(plugin_read_fd, F_SETFD, FD_CLOEXEC))
log_fatal("Failed to set FD_CLOEXEC on plugin read fd: %s", dmn_strerror(errno));
if(fcntl(plugin_write_fd, F_SETFD, FD_CLOEXEC))
log_fatal("Failed to set FD_CLOEXEC on plugin write fd: %s", dmn_strerror(errno));
if(emc_read_exact(plugin_read_fd, "HELO"))
log_fatal("Failed to read HELO from plugin");
if(emc_write_string(plugin_write_fd, "HELO_ACK", 8))
log_fatal("Failed to write HELO_ACK to plugin");
uint8_t ccount_buf[7];
if(emc_read_nbytes(plugin_read_fd, 7, ccount_buf)
|| strncmp((char*)ccount_buf, "CMDS:", 5))
log_fatal("Failed to read command count from plugin");
num_mons = ((unsigned)ccount_buf[5] << 8) + ccount_buf[6];
if(!num_mons)
log_fatal("Received command count of zero from plugin");
mons = calloc(num_mons, sizeof(mon_t));
if(emc_write_string(plugin_write_fd, "CMDS_ACK", 8))
log_fatal("Failed to write CMDS_ACK to plugin");
// Note, it's merely a happy coincidence that our mons[]
// indices exactly match cmd->idx numbers. Always use
// the cmd->idx numbers as the official index when talking
// to the main daemon!
for(unsigned i = 0; i < num_mons; i++) {
mons[i].cmd = emc_read_command(plugin_read_fd);
if(!mons[i].cmd)
log_fatal("Failed to read command %u from plugin", i);
if(i != mons[i].cmd->idx)
log_fatal("BUG: plugin index issues, %u vs %u", i, mons[i].cmd->idx);
if(emc_write_string(plugin_write_fd, "CMD_ACK", 7))
log_fatal("Failed to write CMD_ACK for command %u to plugin", i);
}
if(emc_read_exact(plugin_read_fd, "END_CMDS"))
log_fatal("Failed to read END_CMDS from plugin");
if(emc_write_string(plugin_write_fd, "END_CMDS_ACK", 12))
log_fatal("Failed to write END_CMDS_ACK to plugin");
// done with the serial setup, close the readpipe and go nonblocking on write for eventloop...
close(plugin_read_fd);
if(unlikely(fcntl(plugin_write_fd, F_SETFL, (fcntl(plugin_write_fd, F_GETFL, 0)) | O_NONBLOCK) == -1))
log_fatal("Failed to set O_NONBLOCK on pipe: %s", logf_errno());
// init results-sending queue
sendq_init();
// Set up libev error callback
ev_set_syserr_cb(&syserr_for_ev);
// Construct the default loop for the main thread
struct ev_loop* def_loop = ev_default_loop(EVFLAG_AUTO);
if(!def_loop) log_fatal("Could not initialize the default libev loop");
ev_set_timeout_collect_interval(def_loop, 0.1);
ev_set_io_collect_interval(def_loop, 0.01);
// set up primary read/write watchers on the pipe to the daemon's plugin
plugin_read_watcher = malloc(sizeof(ev_io));
plugin_write_watcher = malloc(sizeof(ev_io));
ev_io_init(plugin_write_watcher, plugin_write_cb, plugin_write_fd, EV_WRITE);
ev_set_priority(plugin_write_watcher, 1);
// set up interval watchers for each monitor, initially for immediate firing
// for the daemon's monitoring init cycle, then repeating every interval.
for(unsigned i = 0; i < num_mons; i++) {
mon_t* this_mon = &mons[i];
this_mon->interval_timer = malloc(sizeof(ev_timer));
ev_timer_init(this_mon->interval_timer, mon_interval_cb, 0., this_mon->cmd->interval);
this_mon->interval_timer->data = this_mon;
ev_set_priority(this_mon->interval_timer, 0);
ev_timer_start(def_loop, this_mon->interval_timer);
// initialize the other watchers in the mon_t here as well,
// but do not start them (the interval callback starts them each interval)
this_mon->cmd_timeout = malloc(sizeof(ev_timer));
ev_timer_init(this_mon->cmd_timeout, mon_timeout_cb, 0, 0);
ev_set_priority(this_mon->cmd_timeout, -1);
this_mon->cmd_timeout->data = this_mon;
this_mon->child_watcher = malloc(sizeof(ev_child));
ev_child_init(this_mon->child_watcher, mon_child_cb, 0, 0);
this_mon->child_watcher->data = this_mon;
}
log_info("gdnsd_extmon_helper running");
// shut off stderr output from here out...
dmn_log_close_alt_stderr();
ev_run(def_loop, 0);
log_info("gdnsd_extmon_helper terminating");
// kill -9 on any extant child procs
for(unsigned i = 0; i < num_mons; i++)
if(mons[i].cmd_pid)
kill(mons[i].cmd_pid, SIGKILL);
// Bye!
exit(0);
}
int main(int argc, char **argv) {
GOptionContext *context;
GError *error = NULL;
gint res;
context = g_option_context_new("<application> [app arguments]");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_summary(context, PACKAGE_DESC);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_printerr("Option parsing failed: %s\n", error->message);
return -1;
}
if (opts.show_version) {
g_printerr(PACKAGE_DESC);
g_printerr("\nBuild-Date: " __DATE__ " " __TIME__ "\n");
return 0;
}
if (!opts.app || !opts.app[0]) {
g_printerr("Missing application\n");
return -2;
}
if (opts.forks < 1) {
g_printerr("Invalid forks argument: %i\n", opts.forks);
return -3;
}
if (opts.retry < 1) {
g_printerr("Invalid retry argument: %i\n", opts.retry);
return -4;
}
if (opts.retry_timeout_ms < 0) {
g_printerr("Invalid timeout argument: %i\n", opts.retry_timeout_ms);
return -5;
}
data *d = g_slice_new0(data);
d->children = (child*) g_slice_alloc0(sizeof(child) * opts.forks);
d->running = 0;
d->shutdown = FALSE;
d->return_status = 0;
d->loop = ev_default_loop(0);
#define WATCH_SIG(x) do { ev_signal_init(&d->sig##x, forward_sig_cb, SIG##x); d->sig##x.data = d; ev_signal_start(d->loop, &d->sig##x); ev_unref(d->loop); } while (0)
#define WATCH_TERM_SIG(x) do { ev_signal_init(&d->sig##x, terminate_forward_sig_cb, SIG##x); d->sig##x.data = d; ev_signal_start(d->loop, &d->sig##x); ev_unref(d->loop); } while (0)
#define UNWATCH_SIG(x) do { ev_ref(d->loop); ev_signal_stop(d->loop, &d->sig##x); } while (0)
WATCH_TERM_SIG(HUP);
WATCH_TERM_SIG(INT);
WATCH_TERM_SIG(QUIT);
WATCH_TERM_SIG(TERM);
WATCH_TERM_SIG(USR1);
WATCH_SIG(USR2);
for (gint i = 0; i < opts.forks; i++) {
d->children[i].d = d;
d->children[i].id = i;
d->children[i].pid = -1;
d->children[i].tries = 0;
d->children[i].watcher.data = &d->children[i];
ev_child_init(&d->children[i].watcher, child_died, -1, 0);
spawn(&d->children[i]);
}
ev_loop(d->loop, 0);
res = d->return_status;
g_slice_free1(sizeof(child) * opts.forks, d->children);
g_slice_free(data, d);
UNWATCH_SIG(HUP);
UNWATCH_SIG(INT);
UNWATCH_SIG(QUIT);
UNWATCH_SIG(TERM);
UNWATCH_SIG(USR1);
UNWATCH_SIG(USR2);
return res;
}
verto_ctx *
verto_default_libev(void)
{
return verto_convert_libev(ev_default_loop(EVFLAG_AUTO));
}
int main(int argc, char **argv)
{
ev_stat cfg;
if (argc == 1) {
printf("no cfg\n");
return 0;
}
if (argc == 2) {
daemon(0, 0);
}
cfg_path = strdup(argv[1]);
cfg_init(cfg_path);
ev_stat_init (&cfg, cfg_cb, cfg_path, 2.);
signal(SIGPIPE, SIG_IGN);
struct ev_loop *loop = ev_default_loop (0);
work_loop = ev_loop_new(0);
int listen_fd;
struct sockaddr_in listen_addr;
int reuseaddr_on = 1;
pthread_mutex_init(&lock, NULL);
thread_create(work, NULL);
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0) {
perror("listen failed");
return -1;
}
if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on,
sizeof(reuseaddr_on)) == -1)
{
perror("setsockopt failed");
return -1;
}
memset(&listen_addr, 0, sizeof(listen_addr));
listen_addr.sin_family = AF_INET;
listen_addr.sin_addr.s_addr = INADDR_ANY;
listen_addr.sin_port = htons(SERVER_PORT);
if (bind(listen_fd, (struct sockaddr *)&listen_addr,
sizeof(listen_addr)) < 0)
{
perror("bind failed");
return -1;
}
if (listen(listen_fd, 128) < 0)
{
perror("listen failed");
return -1;
}
if (setnonblock(listen_fd) < 0)
{
perror("failed to set server socket to non-blocking");
return -1;
}
ev_io ev_accept;
ev_io_init(&ev_accept, accept_cb, listen_fd, EV_READ);
ev_io_start(loop, &ev_accept);
if (cfg_path != NULL)
ev_stat_start (loop, &cfg);
ev_loop (loop, 0);
return 0;
}
int main(int argc, char *argv[])
{
int c;
const char *config_file = DEFAULT_CONFIG;
const char *adm_socket = DEFAULT_ADM_SOCKET;
int verbose = 0;
static struct ev_loop *loop;
static struct ev_signal signal_watcher;
pid_t pid;
while ((c = getopt(argc, argv, "a:c:dhp:Vv")) != -1) {
switch (c) {
case 'a':
adm_socket = optarg;
break;
case 'c':
config_file = optarg;
break;
case 'd':
pingu_daemonize++;
break;
case 'h':
return usage(basename(argv[0]));
case 'p':
pid_file = optarg;
break;
case 'V':
print_version(basename(argv[0]));
return 0;
case 'v':
verbose++;
break;
}
}
argc -= optind;
argv += optind;
log_init("pingu", verbose);
pid = get_running_pid();
if (pid)
errx(1, "appears to be running already (pid %i)", pid);
loop = ev_default_loop(0);
if (pingu_conf_parse(config_file) < 0)
return 1;
if (pingu_iface_init(loop) < 0)
return 1;
if (pingu_host_init(loop) < 0)
return 1;
if (pingu_adm_init(loop, adm_socket) < 0)
return 1;
if (pingu_daemonize) {
if (daemonize() == -1)
return 1;
}
kernel_init(loop);
ev_signal_init(&signal_watcher, sigint_cb, SIGINT);
ev_signal_start(loop, &signal_watcher);
ev_run(loop, 0);
log_info("Shutting down");
pingu_iface_cleanup(loop);
pingu_host_cleanup();
kernel_close();
ev_loop_destroy(loop);
return 0;
}
int
main(int argc, char *argv[])
{
#if EV_MULTIPLICITY
lem_loop = ev_default_loop(LEM_LOOPFLAGS);
if (lem_loop == NULL) {
#else
if (!ev_default_loop(LEM_LOOPFLAGS)) {
#endif
lem_log_error("lem: error initializing event loop");
return EXIT_FAILURE;
}
if (setsignal(SIGPIPE, SIG_IGN, 0)
#if !EV_CHILD_ENABLE
|| setsignal(SIGCHLD, SIG_DFL, SA_NOCLDSTOP | SA_NOCLDWAIT)
#endif
)
goto error;
/* create main Lua state */
L = luaL_newstate();
if (L == NULL) {
lem_log_error("lem: error initializing Lua state");
goto error;
}
luaL_openlibs(L);
/* push thread table */
lua_newtable(L);
/* initialize runqueue */
ev_idle_init(&rq.w, runqueue_pop);
ev_idle_start(LEM_ &rq.w);
rq.queue = lem_xmalloc(LEM_INITIAL_QUEUESIZE
* sizeof(struct lem_runqueue_slot));
rq.first = rq.last = 0;
rq.mask = LEM_INITIAL_QUEUESIZE - 1;
/* initialize threadpool */
if (pool_init()) {
lem_log_error("lem: error initializing threadpool");
goto error;
}
/* load file */
if (queue_file(argc, argv, 1))
goto error;
/* start the mainloop */
ev_loop(LEM_ 0);
lem_debug("event loop exited");
/* if there is an error message left on L print it */
if (lua_type(L, -1) == LUA_TSTRING)
lem_log_error("lem: %s", lua_tostring(L, -1));
/* shutdown Lua */
lua_close(L);
/* free runqueue */
free(rq.queue);
/* destroy loop */
#if EV_MULTIPLICITY
ev_loop_destroy(lem_loop);
#else
ev_default_destroy();
#endif
lem_debug("Bye %s", exit_status == EXIT_SUCCESS ? "o/" : ":(");
return exit_status;
error:
if (L)
lua_close(L);
if (rq.queue)
free(rq.queue);
#if EV_MULTIPLICITY
ev_loop_destroy(lem_loop);
#else
ev_default_destroy();
#endif
return EXIT_FAILURE;
}
/**
* Initializes the networking interfaces
* @arg config Takes the statsite_proxy server configuration
* @arg netconf Output. The configuration for the networking stack.
* @arg proxy Pointer to proxy for routing metrics via consistent hashing
*/
int init_networking(statsite_proxy_config *config, statsite_proxy_networking **netconf_out, proxy *proxy) {
// Make the netconf structure
statsite_proxy_networking *netconf = calloc(1, sizeof(struct statsite_proxy_networking));
// Initialize
netconf->events = NULL;
netconf->config = config;
netconf->proxy = proxy;
netconf->should_run = 1;
netconf->thread = NULL;
/**
* Check if we can use kqueue instead of select.
* By default, libev will not use kqueue since it only
* works for sockets, which is all we need.
*/
int ev_mode = EVFLAG_AUTO;
if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE) {
ev_mode = EVBACKEND_KQUEUE;
}
if (!ev_default_loop (ev_mode)) {
syslog(LOG_CRIT, "Failed to initialize libev!");
free(netconf);
return 1;
}
// Setup proxy connections
int proxy_res = setup_proxy_connections(netconf);
if (proxy_res != 0) {
// free proxy connections stuff
free(netconf);
return 1;
}
// Setup the TCP listener
int res = setup_tcp_listener(netconf);
if (res != 0) {
free(netconf);
return 1;
}
// Setup the UDP listener
res = setup_udp_listener(netconf);
if (res != 0) {
ev_io_stop(&netconf->tcp_client);
close(netconf->tcp_client.fd);
free(netconf);
return 1;
}
// Setup the async handler
ev_async_init(&netconf->loop_async, handle_async_event);
ev_async_start(&netconf->loop_async);
// Prepare the conn handlers
init_conn_handler(config);
// Success!
*netconf_out = netconf;
return 0;
}
void poll(CentralIOToDo todo) {
getall(todo);
ev_loop(ev_default_loop(0), EVLOOP_NONBLOCK);
}
int evapi_run_dispatcher(char *laddr, int lport)
{
int evapi_srv_sock;
struct sockaddr_in evapi_srv_addr;
struct ev_loop *loop;
struct hostent *h = NULL;
struct ev_io io_server;
struct ev_io io_notify;
LM_DBG("starting dispatcher processing\n");
memset(_evapi_clients, 0, sizeof(evapi_client_t) * EVAPI_MAX_CLIENTS);
loop = ev_default_loop(0);
if(loop==NULL) {
LM_ERR("cannot get libev loop\n");
return -1;
}
h = gethostbyname(laddr);
if (h == NULL || (h->h_addrtype != AF_INET && h->h_addrtype != AF_INET6)) {
LM_ERR("cannot resolve local server address [%s]\n", laddr);
return -1;
}
if(h->h_addrtype == AF_INET) {
evapi_srv_sock = socket(PF_INET, SOCK_STREAM, 0);
} else {
evapi_srv_sock = socket(PF_INET6, SOCK_STREAM, 0);
}
if( evapi_srv_sock < 0 )
{
LM_ERR("cannot create server socket (family %d)\n", h->h_addrtype);
return -1;
}
/* set non-blocking flag */
fcntl(evapi_srv_sock, F_SETFL, fcntl(evapi_srv_sock, F_GETFL) | O_NONBLOCK);
bzero(&evapi_srv_addr, sizeof(evapi_srv_addr));
evapi_srv_addr.sin_family = h->h_addrtype;
evapi_srv_addr.sin_port = htons((short)lport);
evapi_srv_addr.sin_addr = *(struct in_addr*)h->h_addr;
if (bind(evapi_srv_sock, (struct sockaddr*)&evapi_srv_addr,
sizeof(evapi_srv_addr)) < 0) {
LM_ERR("cannot bind to local address and port [%s:%d]\n", laddr, lport);
close(evapi_srv_sock);
return -1;
}
if (listen(evapi_srv_sock, 4) < 0) {
LM_ERR("listen error\n");
close(evapi_srv_sock);
return -1;
}
ev_io_init(&io_server, evapi_accept_client, evapi_srv_sock, EV_READ);
ev_io_start(loop, &io_server);
ev_io_init(&io_notify, evapi_recv_notify, _evapi_notify_sockets[0], EV_READ);
ev_io_start(loop, &io_notify);
while(1) {
ev_loop (loop, 0);
}
return 0;
}
void wait(CentralIOToDo todo) {
getall(todo);
ev_loop(ev_default_loop(0), EVLOOP_ONESHOT);
}
int main(int argc, char *argv[])
{
// read options
char *dir = NULL;
short badarg = 0;
int opt; while ((opt = getopt(argc, argv, "d:")) != -1)
{
if (opt == 'd') dir = optarg;
else badarg = 1;
}
if (badarg) { print_usage(); return 1; }
// change dir
dir = flon_path(argv[0], dir);
if (chdir(dir) != 0)
{
fgaj_r("couldn't chdir to %s", dir);
return 1;
}
fgaj_i("-d %s", dir);
// load configuration
if (flon_configure(".") != 0)
{
fgaj_r("couldn't read %s/etc/flon.json, cannot start", dir);
return 1;
}
free(dir);
// set up logging
flon_setup_logging("dispatcher");
// scan once
scan_dir();
// load timers
flon_load_timers();
// then, ev...
struct ev_loop *l = ev_default_loop(0);
// watch var/spool/dis/
ev_stat est;
ev_stat_init(&est, spool_cb, "var/spool/dis/", 0.);
ev_stat_start(l, &est);
// check from time to time too
ev_periodic epe;
ev_periodic_init(&epe, trigger_cb, 0., .35, trigger_reschedule_cb);
ev_periodic_start(l, &epe);
//ev_timer eti;
//ev_timer_init(&eti, do_something_when_loop_ready_cb, 0., 0.);
//ev_timer_start(l, &eti);
ev_signal esi;
ev_signal_init(&esi, sighup_cb, SIGHUP);
ev_signal_start(l, &esi);
// loop
//fgaj_i("about to ev_loop...");
ev_loop(l, 0);
fgaj_r("something went wrong");
}
Loop::Loop(int opts) : event_ids(0), options_(opts), owner(false) {
base = ev_default_loop(options_);
/* @todo Should fail here if default returns NULL */
}
int main(int argc, char * const argv[]) {
int result,i,r;
int opt_index;
int opt_rate = -1;
int opt_channels = -1;
int opt_period = 0;
int opt_duration = 0;
int opt_assert = 0;
int opt_invalid_log_size = 0;
const char *opt_device = NULL;
const char *opt_config = NULL;
const char *opt_priority = NULL;
struct alsa_config config;
struct ev_io stdin_watcher;
struct ev_timer duration_timer;
loop = ev_default_loop(0);
while (1) {
if ((result = getopt_long( argc, argv, "+r:c:p:D:C:P:d:aI:", options, &opt_index )) == EOF) break;
switch (result) {
case '?':
usage();
break;
case 'r':
opt_rate = atoi(optarg);
break;
case 'c':
opt_channels = atoi(optarg);
break;
case 'p':
opt_period = atoi(optarg);
break;
case 'd':
opt_duration = atoi(optarg);
break;
case 'D':
opt_device = optarg;
break;
case 'C':
opt_config = optarg;
break;
case 'P':
opt_priority = optarg;
break;
case 'a':
opt_assert = 1;
break;
case 'I':
opt_invalid_log_size = atoi(optarg);
break;
}
}
/* generate the config */
alsa_config_init( &config, opt_config );
if (opt_rate > 0) config.rate = opt_rate;
if (opt_channels > 0) config.channels = opt_channels;
if (opt_period > 0) config.period = opt_period;
if (opt_device) { strncpy( config.device, opt_device, sizeof(config.device)-1 ); config.device[ sizeof(config.device)-1 ] = '\0'; }
if (opt_priority) { strncpy( config.priority, opt_priority, sizeof(config.priority)-1 ); config.priority[ sizeof(config.priority)-1 ] = '\0'; }
/* check if the config is valid */
if (config.device[0] == '\0') {
printf("Undefined device.\n");
exit(1);
}
dbg("dev: '%s'", config.device);
#define MAX_TESTS 2
struct test *tests[MAX_TESTS];
int tests_count = 0;
/* build the tests objects */
argc -= optind;
argv += optind;
while (argc) {
struct test *t = NULL;
if (!strcmp( argv[0], "play" )) {
struct playback_create_opts opts = {0};
optind = 1;
while (1) {
if ((result = getopt( argc, argv, "+x:r:" )) == EOF) break;
switch (result) {
case '?':
printf("invalid option '%s' for test 'play'\n", optarg);
usage();
break;
case 'x':
opts.xrun = atoi(optarg);
break;
case 'r':
if (sscanf(optarg, "%d,%d", &opts.restart_play_time, &opts.restart_pause_time) != 2) {
printf("invalid value '%s' for test 'play' option '-r'\n", optarg);
usage();
}
dbg("%d,%d", opts.restart_play_time, opts.restart_pause_time);
break;
}
}
argc -= optind-1;
argv += optind-1;
t = playback_create( &config, &opts );
if (!t) {
err("failed to create a playback test");
exit(1);
}
} else if (!strcmp( argv[0], "capture" )) {
struct capture_create_opts opts = {0};
optind = 1;
while (1) {
if ((result = getopt( argc, argv, "+x:r:" )) == EOF) break;
switch (result) {
case '?':
printf("invalid option '%s' for test 'capture'\n", optarg);
usage();
break;
case 'x':
opts.xrun = atoi(optarg);
break;
case 'r':
if (sscanf(optarg, "%d,%d", &opts.restart_play_time, &opts.restart_pause_time) != 2) {
printf("invalid value '%s' for test 'capture' option '-r'\n", optarg);
usage();
}
dbg("%d,%d", opts.restart_play_time, opts.restart_pause_time);
break;
}
}
argc -= optind-1;
argv += optind-1;
t = capture_create( &config, &opts );
if (!t) {
err("failed to create a capture test");
exit(1);
}
} else if (!strcmp( argv[0], "loopback_delay" )) {
struct loopback_delay_create_opts opts = {0};
optind = 1;
while (1) {
if ((result = getopt( argc, argv, "+a:s:x:" )) == EOF) break;
switch (result) {
case '?':
printf("invalid option '%s' for test 'loopback_delay'\n", optarg);
usage();
break;
case 'a':
opts.assert_delay = 1;
opts.expected_delay = atoi(optarg);
break;
case 's':
if (!strcmp(optarg, "capture"))
opts.start_sync_mode = LSM_PREPARE_CAPTURE_PLAYBACK;
else if (!strcmp(optarg, "play"))
opts.start_sync_mode = LSM_PREPARE_PLAYBACK_CAPTURE;
else if (!strcmp(optarg, "link"))
opts.start_sync_mode = LSM_LINK;
else {
printf("invalid value '%s' for test 'loopback_delay' option '-s'\n", optarg);
usage();
}
break;
}
}
argc -= optind-1;
argv += optind-1;
t = loopback_delay_create( &config, &opts );
if (!t) {
err("failed to create a capture test");
exit(1);
}
}
if (t) {
if (tests_count >= MAX_TESTS) {
err("too many tests defined.");
exit(1);
}
tests[tests_count++] = t;
} else {
printf("undefined test '%s'.\n", argv[0]);
usage();
}
argc--;
argv++;
}
if (tests_count == 0) {
printf("no tests specified.\n");
exit(1);
}
/* change the scheduling priority is required */
if (config.priority[0]) {
int p;
if (sscanf(config.priority, "fifo,%d", &p )==1) {
struct sched_param param;
param.sched_priority = p;
dbg("priority: fifo,%d", p);
if (sched_setscheduler(0, SCHED_FIFO, ¶m))
err("sched_setscheduler");
} else if (sscanf(config.priority, "rr,%d", &p )==1) {
struct sched_param param;
param.sched_priority = p;
dbg("priority: rr,%d", p);
if (sched_setscheduler(0, SCHED_RR, ¶m))
err("sched_setscheduler");
} else if (sscanf(config.priority, "other,%d", &p )==1) {
struct sched_param param;
param.sched_priority = p;
dbg("priority: other,%d", p);
if (sched_setscheduler(0, SCHED_OTHER, ¶m))
err("sched_setscheduler");
} else {
printf("Invalid priority '%s'\n", config.priority);
}
}
/* start the various tests */
for (i=0; i < tests_count; i++) {
struct test *t = tests[i];
r = t->ops->start( t );
if (r < 0) {
err("starting test %s failed", t->name );
exit(1);
}
}
/* setup signal handlers to exist cleanly */
ev_signal_init(&evw_intsig, on_exit_signal, SIGINT);
ev_signal_start(loop, &evw_intsig);
ev_signal_init(&evw_termsig, on_exit_signal, SIGTERM);
ev_signal_start(loop, &evw_termsig);
ev_io_init(&stdin_watcher, on_stdin, 0, EV_READ);
ev_io_start( loop, &stdin_watcher );
if (opt_assert) {
seq_error_notify = &seq_error_assert;
}
if (opt_invalid_log_size > 0) {
seq_consecutive_invalid_frames_log = opt_invalid_log_size;
}
if (opt_duration > 0) {
dbg("start a %d seconds duration timer", opt_duration);
ev_timer_init( &duration_timer, on_duration_timer, opt_duration, 0 );
ev_timer_start( loop, &duration_timer );
}
ev_run( loop, 0 );
int test_exit_status = 0;
for (i=0; i < tests_count; i++) {
struct test *t = tests[i];
if (t->ops->close( t )) {
err("%s exit status: failed", t->name);
test_exit_status = 1;
}
}
printf("total number of sequence errors: %u\n", seq_errors_total);
printf("global tests exit status: %s\n", test_exit_status ? "FAILED" : "OK");
/* exit with a good status only if no error was detected */
return (seq_errors_total || test_exit_status) ? 2 : 0;
}
int main(int argc, char **argv) {
int opt;
int option_index = 0;
char *socket_path = getenv("I3SOCK");
char *command = NULL;
char *fontname = NULL;
char *i3_default_sock_path = "/tmp/i3-ipc.sock";
struct xcb_color_strings_t colors = { NULL, };
/* Definition of the standard-config */
config.hide_on_modifier = 0;
config.dockpos = DOCKPOS_NONE;
config.disable_ws = 0;
static struct option long_opt[] = {
{ "socket", required_argument, 0, 's' },
{ "command", required_argument, 0, 'c' },
{ "hide", no_argument, 0, 'm' },
{ "dock", optional_argument, 0, 'd' },
{ "font", required_argument, 0, 'f' },
{ "nows", no_argument, 0, 'w' },
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'v' },
{ "verbose", no_argument, 0, 'V' },
{ "color-bar-fg", required_argument, 0, 'A' },
{ "color-bar-bg", required_argument, 0, 'B' },
{ "color-active-ws-fg", required_argument, 0, 'C' },
{ "color-active-ws-bg", required_argument, 0, 'D' },
{ "color-inactive-ws-fg", required_argument, 0, 'E' },
{ "color-inactive-ws-bg", required_argument, 0, 'F' },
{ "color-urgent-ws-bg", required_argument, 0, 'G' },
{ "color-urgent-ws-fg", required_argument, 0, 'H' },
{ "color-focus-ws-bg", required_argument, 0, 'I' },
{ "color-focus-ws-fg", required_argument, 0, 'J' },
{ NULL, 0, 0, 0}
};
while ((opt = getopt_long(argc, argv, "s:c:d::mf:whvVA:B:C:D:E:F:G:H:I:J:", long_opt, &option_index)) != -1) {
switch (opt) {
case 's':
socket_path = expand_path(optarg);
break;
case 'c':
command = strdup(optarg);
break;
case 'm':
config.hide_on_modifier = 1;
break;
case 'd':
config.hide_on_modifier = 0;
if (optarg == NULL) {
config.dockpos = DOCKPOS_BOT;
break;
}
if (!strcmp(optarg, "top")) {
config.dockpos = DOCKPOS_TOP;
} else if (!strcmp(optarg, "bottom")) {
config.dockpos = DOCKPOS_BOT;
} else {
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
break;
case 'f':
fontname = strdup(optarg);
break;
case 'w':
config.disable_ws = 1;
break;
case 'v':
printf("i3bar version " I3_VERSION " © 2010-2011 Axel Wagner and contributors\n");
exit(EXIT_SUCCESS);
break;
case 'V':
config.verbose = 1;
break;
case 'A':
read_color(&colors.bar_fg);
break;
case 'B':
read_color(&colors.bar_bg);
break;
case 'C':
read_color(&colors.active_ws_fg);
break;
case 'D':
read_color(&colors.active_ws_bg);
break;
case 'E':
read_color(&colors.inactive_ws_fg);
break;
case 'F':
read_color(&colors.inactive_ws_bg);
break;
case 'G':
read_color(&colors.urgent_ws_bg);
break;
case 'H':
read_color(&colors.urgent_ws_fg);
break;
case 'I':
read_color(&colors.focus_ws_bg);
break;
case 'J':
read_color(&colors.focus_ws_fg);
break;
default:
print_usage(argv[0]);
exit(EXIT_SUCCESS);
break;
}
}
if (fontname == NULL) {
/* This is a very restrictive default. More sensefull would be something like
* "-misc-*-*-*-*--*-*-*-*-*-*-*-*". But since that produces very ugly results
* on my machine, let's stick with this until we have a configfile */
fontname = "-misc-fixed-medium-r-semicondensed--12-110-75-75-c-60-iso10646-1";
}
if (config.dockpos != DOCKPOS_NONE) {
if (config.hide_on_modifier) {
ELOG("--dock and --hide are mutually exclusive!\n");
exit(EXIT_FAILURE);
}
} else {
config.hide_on_modifier = 1;
}
main_loop = ev_default_loop(0);
init_colors(&colors);
char *atom_sock_path = init_xcb(fontname);
if (socket_path == NULL) {
socket_path = atom_sock_path;
}
if (socket_path == NULL) {
ELOG("No Socket Path Specified, default to %s\n", i3_default_sock_path);
socket_path = expand_path(i3_default_sock_path);
}
free_colors(&colors);
init_outputs();
if (init_connection(socket_path)) {
/* We subscribe to the i3-events we need */
subscribe_events();
/* We initiate the main-function by requesting infos about the outputs and
* workspaces. Everything else (creating the bars, showing the right workspace-
* buttons and more) is taken care of by the event-driveniness of the code */
i3_send_msg(I3_IPC_MESSAGE_TYPE_GET_OUTPUTS, NULL);
if (!config.disable_ws) {
i3_send_msg(I3_IPC_MESSAGE_TYPE_GET_WORKSPACES, NULL);
}
}
/* The name of this function is actually misleading. Even if no -c is specified,
* this function initiates the watchers to listen on stdin and react accordingly */
start_child(command);
FREE(command);
/* We listen to SIGTERM/QUIT/INT and try to exit cleanly, by stopping the main-loop.
* We only need those watchers on the stack, so putting them on the stack saves us
* some calls to free() */
ev_signal *sig_term = malloc(sizeof(ev_signal));
ev_signal *sig_int = malloc(sizeof(ev_signal));
ev_signal *sig_hup = malloc(sizeof(ev_signal));
if (sig_term == NULL || sig_int == NULL || sig_hup == NULL) {
ELOG("malloc() failed: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
ev_signal_init(sig_term, &sig_cb, SIGTERM);
ev_signal_init(sig_int, &sig_cb, SIGINT);
ev_signal_init(sig_hup, &sig_cb, SIGHUP);
ev_signal_start(main_loop, sig_term);
ev_signal_start(main_loop, sig_int);
ev_signal_start(main_loop, sig_hup);
/* From here on everything should run smooth for itself, just start listening for
* events. We stop simply stop the event-loop, when we are finished */
ev_loop(main_loop, 0);
kill_child();
FREE(statusline_buffer);
clean_xcb();
ev_default_destroy();
free_workspaces();
return 0;
}
/*
* loop function
*/
static int default_loop(lua_State *L) {
unsigned int flags = (unsigned int)luaL_optinteger(L, 1, EVFLAG_AUTO);
struct ev_loop *loop = ev_default_loop(flags);
setloop(L, loop);
return 1;
}
int main(int argc, char **argv)
{
int sigs[] = { SIGINT, SIGKILL, SIGTERM, SIGSEGV, SIGFPE };
struct ev_signal signals[ARRAY_SIZE(sigs)];
struct ev_loop *loop = ev_default_loop(0);
struct lws_context_creation_info info;
char interface_name[128] = "";
const char *iface = NULL;
ev_timer timeout_watcher;
char cert_path[1024];
char key_path[1024];
int debug_level = 7;
int use_ssl = 0;
int opts = 0;
int n = 0;
#ifndef _WIN32
int syslog_options = LOG_PID | LOG_PERROR;
#endif
#ifndef LWS_NO_DAEMONIZE
int daemonize = 0;
#endif
/*
* take care to zero down the info struct, he contains random garbaage
* from the stack otherwise
*/
memset(&info, 0, sizeof info);
info.port = 7681;
while (n >= 0) {
n = getopt_long(argc, argv, "eci:hsap:d:Dr:", options, NULL);
if (n < 0)
continue;
switch (n) {
case 'e':
opts |= LWS_SERVER_OPTION_LIBEV;
break;
#ifndef LWS_NO_DAEMONIZE
case 'D':
daemonize = 1;
#ifndef _WIN32
syslog_options &= ~LOG_PERROR;
#endif
break;
#endif
case 'd':
debug_level = atoi(optarg);
break;
case 's':
use_ssl = 1;
break;
case 'a':
opts |= LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT;
break;
case 'p':
info.port = atoi(optarg);
break;
case 'i':
strncpy(interface_name, optarg, sizeof interface_name);
interface_name[(sizeof interface_name) - 1] = '\0';
iface = interface_name;
break;
case 'c':
close_testing = 1;
fprintf(stderr, " Close testing mode -- closes on "
"client after 50 dumb increments"
"and suppresses lws_mirror spam\n");
break;
case 'r':
resource_path = optarg;
printf("Setting resource path to \"%s\"\n", resource_path);
break;
case 'h':
fprintf(stderr, "Usage: test-server "
"[--port=<p>] [--ssl] "
"[-d <log bitfield>] "
"[--resource_path <path>]\n");
exit(1);
}
}
#if !defined(LWS_NO_DAEMONIZE) && !defined(WIN32)
/*
* normally lock path would be /var/lock/lwsts or similar, to
* simplify getting started without having to take care about
* permissions or running as root, set to /tmp/.lwsts-lock
*/
if (daemonize && lws_daemonize("/tmp/.lwsts-lock")) {
fprintf(stderr, "Failed to daemonize\n");
return 1;
}
#endif
for (n = 0; n < ARRAY_SIZE(sigs); n++) {
_ev_init(&signals[n], signal_cb);
ev_signal_set(&signals[n], sigs[n]);
ev_signal_start(loop, &signals[n]);
}
#ifndef _WIN32
/* we will only try to log things according to our debug_level */
setlogmask(LOG_UPTO (LOG_DEBUG));
openlog("lwsts", syslog_options, LOG_DAEMON);
#endif
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
lwsl_notice("libwebsockets test server - "
"(C) Copyright 2010-2015 Andy Green <*****@*****.**> - "
"licensed under LGPL2.1\n");
printf("Using resource path \"%s\"\n", resource_path);
info.iface = iface;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = lws_get_internal_extensions();
#endif
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
if (use_ssl) {
if (strlen(resource_path) > sizeof(cert_path) - 32) {
lwsl_err("resource path too long\n");
return -1;
}
sprintf(cert_path, "%s/libwebsockets-test-server.pem",
resource_path);
if (strlen(resource_path) > sizeof(key_path) - 32) {
lwsl_err("resource path too long\n");
return -1;
}
sprintf(key_path, "%s/libwebsockets-test-server.key.pem",
resource_path);
info.ssl_cert_filepath = cert_path;
info.ssl_private_key_filepath = key_path;
}
info.gid = -1;
info.uid = -1;
info.max_http_header_pool = 1;
info.options = opts | LWS_SERVER_OPTION_LIBEV;
context = lws_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
}
/*
* this shows how to override the lws file operations. You don't need
* to do any of this unless you have a reason (eg, want to serve
* compressed files without decompressing the whole archive)
*/
/* stash original platform fops */
fops_plat = *(lws_get_fops(context));
/* override the active fops */
lws_get_fops(context)->open = test_server_fops_open;
lws_initloop(context, loop);
_ev_timer_init(&timeout_watcher, ev_timeout_cb, 0.05, 0.05);
ev_timer_start(loop, &timeout_watcher);
while (!force_exit)
ev_run(loop, 0);
lws_context_destroy(context);
ev_loop_destroy(loop);
lwsl_notice("libwebsockets-test-server exited cleanly\n");
#ifndef _WIN32
closelog();
#endif
return 0;
}
static void _child_ev_cb(EV_P_ struct ev_signal *w, int revents) {
environment e = (environment)w->data;
// call for all VMs/states
ht_vconfig_each(e->machines, _find_child_waiters);
}
environment environment_new() {
environment e = ALLOC_N(struct rubinius_environment, 1);
e->machines = ht_vconfig_create(11);
e->machine_id = 1;
e->messages = ht_vconfig_create(11);
e->sig_event_base = ev_default_loop(EVFLAG_FORKCHECK);
return e;
}
static void _fork_event_loops(int key, void *mach) {
machine m = mach;
ev_loop_fork(m->s->event_base);
ev_loop(m->s->event_base, EVLOOP_NONBLOCK);
}
void environment_fork() {
environment e = environment_current();
ev_default_fork();
ev_loop(e->sig_event_base, EVLOOP_NONBLOCK);
ht_vconfig_each(e->machines, _fork_event_loops);
int ugh_daemon_exec(const char *cfg_filename, unsigned daemon)
{
int rc;
ugh_daemon_t d;
aux_clrptr(&d);
loop = ev_default_loop(0);
/* TODO make it possible to set default values for each module config and
* global config via ugh_make_command macro (by setting all this at
* module_handle_add stage)
*/
rc = ugh_config_init(&d.cfg);
if (0 > rc) return -1;
rc = ugh_config_load(&d.cfg, cfg_filename);
if (0 > rc) return -1;
if (daemon)
{
rc = log_create(d.cfg.log_error, log_levels(d.cfg.log_level));
if (0 > rc) return -1;
}
else
{
log_level = log_levels(d.cfg.log_level);
}
rc = ugh_resolver_init(&d.resolver, &d.cfg);
if (0 > rc) return -1;
size_t i;
for (i = 0; i < ugh_module_handles_size; ++i)
{
if (ugh_module_handles[i].module->init)
{
rc = ugh_module_handles[i].module->init(&d.cfg, ugh_module_handles[i].config);
if (0 > rc) return -1;
}
}
rc = ugh_server_listen(&d.srv, &d.cfg, &d.resolver);
if (0 > rc) return -1;
ev_timer_init(&d.wev_silent, ugh_wcb_silent, 0, UGH_CONFIG_SILENT_TIMEOUT);
ev_timer_again(loop, &d.wev_silent);
ev_run(loop, 0);
ugh_server_enough(&d.srv);
for (i = 0; i < ugh_module_handles_size; ++i)
{
if (ugh_module_handles[i].module->free)
{
rc = ugh_module_handles[i].module->free(&d.cfg, ugh_module_handles[i].config);
if (0 > rc) return -1;
}
}
ugh_resolver_free(&d.resolver);
ugh_config_free(&d.cfg);
return 0;
}
/** Hello, this is main.
* \param argc Who knows.
* \param argv Who knows.
* \return EXIT_SUCCESS I hope.
*/
int
main(int argc, char **argv)
{
char *confpath = NULL;
int xfd, i, screen_nbr, opt, colors_nbr;
xcolor_init_request_t colors_reqs[2];
ssize_t cmdlen = 1;
xdgHandle xdg;
xcb_generic_event_t *event;
static struct option long_options[] =
{
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'v' },
{ "config", 1, NULL, 'c' },
{ "check", 0, NULL, 'k' },
{ NULL, 0, NULL, 0 }
};
/* event loop watchers */
ev_io xio = { .fd = -1 };
ev_check xcheck;
ev_prepare a_refresh;
ev_signal sigint;
ev_signal sigterm;
ev_signal sighup;
/* clear the globalconf structure */
p_clear(&globalconf, 1);
globalconf.keygrabber = LUA_REFNIL;
globalconf.mousegrabber = LUA_REFNIL;
buffer_init(&globalconf.startup_errors);
/* save argv */
for(i = 0; i < argc; i++)
cmdlen += a_strlen(argv[i]) + 1;
globalconf.argv = p_new(char, cmdlen);
a_strcpy(globalconf.argv, cmdlen, argv[0]);
for(i = 1; i < argc; i++)
{
a_strcat(globalconf.argv, cmdlen, " ");
a_strcat(globalconf.argv, cmdlen, argv[i]);
}
/* Text won't be printed correctly otherwise */
setlocale(LC_CTYPE, "");
/* Get XDG basedir data */
xdgInitHandle(&xdg);
/* init lua */
luaA_init(&xdg);
/* check args */
while((opt = getopt_long(argc, argv, "vhkc:",
long_options, NULL)) != -1)
switch(opt)
{
case 'v':
eprint_version();
break;
case 'h':
exit_help(EXIT_SUCCESS);
break;
case 'k':
if(!luaA_parserc(&xdg, confpath, false))
{
fprintf(stderr, "✘ Configuration file syntax error.\n");
return EXIT_FAILURE;
}
else
{
fprintf(stderr, "✔ Configuration file syntax OK.\n");
return EXIT_SUCCESS;
}
case 'c':
if(a_strlen(optarg))
confpath = a_strdup(optarg);
else
fatal("-c option requires a file name");
break;
}
globalconf.loop = ev_default_loop(0);
ev_timer_init(&globalconf.timer, &luaA_on_timer, 0., 0.);
/* register function for signals */
ev_signal_init(&sigint, exit_on_signal, SIGINT);
ev_signal_init(&sigterm, exit_on_signal, SIGTERM);
ev_signal_init(&sighup, restart_on_signal, SIGHUP);
ev_signal_start(globalconf.loop, &sigint);
ev_signal_start(globalconf.loop, &sigterm);
ev_signal_start(globalconf.loop, &sighup);
ev_unref(globalconf.loop);
ev_unref(globalconf.loop);
ev_unref(globalconf.loop);
struct sigaction sa = { .sa_handler = signal_fatal, .sa_flags = 0 };
sigemptyset(&sa.sa_mask);
sigaction(SIGSEGV, &sa, 0);
/* XLib sucks */
XkbIgnoreExtension(True);
/* X stuff */
globalconf.display = XOpenDisplay(NULL);
if (globalconf.display == NULL)
fatal("cannot open display");
globalconf.default_screen = XDefaultScreen(globalconf.display);
globalconf.connection = XGetXCBConnection(globalconf.display);
/* Double checking then everything is OK. */
if(xcb_connection_has_error(globalconf.connection))
fatal("cannot open display");
/* Prefetch all the extensions we might need */
xcb_prefetch_extension_data(globalconf.connection, &xcb_big_requests_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_test_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_randr_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_shape_id);
/* initialize dbus */
a_dbus_init();
/* Get the file descriptor corresponding to the X connection */
xfd = xcb_get_file_descriptor(globalconf.connection);
ev_io_init(&xio, &a_xcb_io_cb, xfd, EV_READ);
ev_io_start(globalconf.loop, &xio);
ev_check_init(&xcheck, &a_xcb_check_cb);
ev_check_start(globalconf.loop, &xcheck);
ev_unref(globalconf.loop);
ev_prepare_init(&a_refresh, &a_refresh_cb);
ev_prepare_start(globalconf.loop, &a_refresh);
ev_unref(globalconf.loop);
/* Grab server */
xcb_grab_server(globalconf.connection);
/* Make sure there are no pending events. Since we didn't really do anything
* at all yet, we will just discard all events which we received so far.
* The above GrabServer should make sure no new events are generated. */
xcb_aux_sync(globalconf.connection);
while ((event = xcb_poll_for_event(globalconf.connection)) != NULL)
{
/* Make sure errors are printed */
uint8_t response_type = XCB_EVENT_RESPONSE_TYPE(event);
if(response_type == 0)
event_handle(event);
p_delete(&event);
}
for(screen_nbr = 0;
screen_nbr < xcb_setup_roots_length(xcb_get_setup(globalconf.connection));
screen_nbr++)
{
const uint32_t select_input_val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
/* This causes an error if some other window manager is running */
xcb_change_window_attributes(globalconf.connection,
xutil_screen_get(globalconf.connection, screen_nbr)->root,
XCB_CW_EVENT_MASK, &select_input_val);
}
/* Need to xcb_flush to validate error handler */
xcb_aux_sync(globalconf.connection);
/* Process all errors in the queue if any. There can be no events yet, so if
* this function returns something, it must be an error. */
if (xcb_poll_for_event(globalconf.connection) != NULL)
fatal("another window manager is already running");
/* Prefetch the maximum request length */
xcb_prefetch_maximum_request_length(globalconf.connection);
/* check for xtest extension */
const xcb_query_extension_reply_t *xtest_query;
xtest_query = xcb_get_extension_data(globalconf.connection, &xcb_test_id);
globalconf.have_xtest = xtest_query->present;
/* Allocate the key symbols */
globalconf.keysyms = xcb_key_symbols_alloc(globalconf.connection);
xcb_get_modifier_mapping_cookie_t xmapping_cookie =
xcb_get_modifier_mapping_unchecked(globalconf.connection);
/* init atom cache */
atoms_init(globalconf.connection);
/* init screens information */
screen_scan();
/* init default font and colors */
colors_reqs[0] = xcolor_init_unchecked(&globalconf.colors.fg,
"black", sizeof("black") - 1);
colors_reqs[1] = xcolor_init_unchecked(&globalconf.colors.bg,
"white", sizeof("white") - 1);
globalconf.font = draw_font_new("sans 8");
for(colors_nbr = 0; colors_nbr < 2; colors_nbr++)
xcolor_init_reply(colors_reqs[colors_nbr]);
xutil_lock_mask_get(globalconf.connection, xmapping_cookie,
globalconf.keysyms, &globalconf.numlockmask,
&globalconf.shiftlockmask, &globalconf.capslockmask,
&globalconf.modeswitchmask);
/* Get the window tree associated to this screen */
const int screen_max = xcb_setup_roots_length(xcb_get_setup(globalconf.connection));
xcb_query_tree_cookie_t tree_c[screen_max];
/* do this only for real screen */
for(screen_nbr = 0; screen_nbr < screen_max; screen_nbr++)
{
/* select for events */
const uint32_t change_win_vals[] =
{
XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY
| XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW
| XCB_EVENT_MASK_STRUCTURE_NOTIFY
| XCB_EVENT_MASK_PROPERTY_CHANGE
| XCB_EVENT_MASK_BUTTON_PRESS
| XCB_EVENT_MASK_BUTTON_RELEASE
| XCB_EVENT_MASK_FOCUS_CHANGE
};
tree_c[screen_nbr] = xcb_query_tree_unchecked(globalconf.connection,
xutil_screen_get(globalconf.connection, screen_nbr)->root);
xcb_change_window_attributes(globalconf.connection,
xutil_screen_get(globalconf.connection, screen_nbr)->root,
XCB_CW_EVENT_MASK,
change_win_vals);
ewmh_init(screen_nbr);
systray_init(screen_nbr);
}
/* init spawn (sn) */
spawn_init();
/* we will receive events, stop grabbing server */
xcb_ungrab_server(globalconf.connection);
/* Parse and run configuration file */
if (!luaA_parserc(&xdg, confpath, true))
fatal("couldn't find any rc file");
scan(tree_c);
xcb_flush(globalconf.connection);
/* main event loop */
ev_loop(globalconf.loop, 0);
/* cleanup event loop */
ev_ref(globalconf.loop);
ev_check_stop(globalconf.loop, &xcheck);
ev_ref(globalconf.loop);
ev_prepare_stop(globalconf.loop, &a_refresh);
ev_ref(globalconf.loop);
ev_io_stop(globalconf.loop, &xio);
awesome_atexit(false);
return EXIT_SUCCESS;
}
MyServer() :
loop_(ev_default_loop()),
sigterm_(loop_),
http_()
{
}
