struct rld_t *fml_fmi_gen(int n, bseq1_t *seq, int is_mt)
{
mrope_t *mr;
kstring_t str = {0,0,0};
mritr_t itr;
rlditr_t di;
const uint8_t *block;
rld_t *e = 0;
int k;
for (k = 0; k < n; ++k)
if (seq[k].l_seq > 0)
break;
if (k == n) return 0;
mr = mr_init(ROPE_DEF_MAX_NODES, ROPE_DEF_BLOCK_LEN, MR_SO_RCLO);
for (k = 0; k < n; ++k) {
int i;
bseq1_t *s = &seq[k];
if (s->l_seq == 0) continue;
free(s->qual);
for (i = 0; i < s->l_seq; ++i)
s->seq[i] = seq_nt6_table[(int)s->seq[i]];
for (i = 0; i < s->l_seq; ++i)
if (s->seq[i] == 5) break;
if (i < s->l_seq) {
free(s->seq);
continue;
}
if (is_rev_same(s->l_seq, s->seq))
--s->l_seq, s->seq[s->l_seq] = 0;
seq_reverse(s->l_seq, (uint8_t*)s->seq);
kputsn(s->seq, s->l_seq + 1, &str);
seq_revcomp6(s->l_seq, (uint8_t*)s->seq);
kputsn(s->seq, s->l_seq + 1, &str);
free(s->seq);
}
free(seq);
mr_insert_multi(mr, str.l, (uint8_t*)str.s, is_mt);
free(str.s);
e = rld_init(6, 3);
rld_itr_init(e, &di, 0);
mr_itr_first(mr, &itr, 1);
while ((block = mr_itr_next_block(&itr)) != 0) {
const uint8_t *q = block + 2, *end = block + 2 + *rle_nptr(block);
while (q < end) {
int c = 0;
int64_t l;
rle_dec1(q, c, l);
rld_enc(e, &di, l, c);
}
}
rld_enc_finish(e, &di);
mr_destroy(mr);
return e;
}
static struct message_registry *mr_init_via_file(const int8 *file_path)
{
int8 *buffer = NULL;
struct message_registry *mr = NULL;
if (file_path == NULL)
buffer = read_file(MR_JSON_FILE_PATH);
else
buffer = read_file(file_path);
if (buffer == NULL)
return NULL;
mr = mr_init(buffer);
free(buffer);
return mr;
}
int main(int argc , char **argv)
{
#if PRINT_TIME
double start, end;
#endif
extract_arguments(argc, argv);
#if PRINT_TIME
start = time_so_far();
#endif
if(mr_init())
exit(EXIT_FAILURE);
start_threads();
wait_threads();
if(mr_reduce())
exit(EXIT_FAILURE);
#if PRINT_TIME
/* Done here, to avoid counting the printing... */
end = time_so_far();
#endif
if(mr_print())
exit(EXIT_FAILURE);
if(mr_destroy())
exit(EXIT_FAILURE);
#if PRINT_TIME
printf("Done in %g msec\n", end-start);
#endif
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int status, i, listener;
time_t tardy;
char *port, *p;
extern char *database;
struct stat stbuf;
struct utsname uts;
fd_set readfds, writefds, xreadfds, xwritefds;
int nfds, counter = 0;
whoami = argv[0];
/*
* Error handler init.
*/
mr_init();
set_com_err_hook(mr_com_err);
setvbuf(stderr, NULL, _IOLBF, BUFSIZ);
port = strchr(MOIRA_SERVER, ':') + 1;
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-db") && i + 1 < argc)
{
database = argv[i + 1];
i++;
}
else if (!strcmp(argv[i], "-p") && i + 1 < argc)
{
port = argv[i + 1];
i++;
}
else
{
com_err(whoami, 0, "Usage: moirad [-db database][-p port]");
exit(1);
}
}
status = krb5_init_context(&context);
if (status)
{
com_err(whoami, status, "Initializing krb5 context.");
exit(1);
}
status = krb5_get_default_realm(context, &krb_realm);
if (status)
{
com_err(whoami, status, "Getting default Kerberos realm.");
exit(1);
}
/*
* Database initialization. Only init if database should be open.
*/
if (stat(MOIRA_MOTD_FILE, &stbuf) != 0)
{
if ((status = mr_open_database()))
{
com_err(whoami, status, "trying to open database.");
exit(1);
}
sanity_check_database();
}
else
{
dormant = ASLEEP;
com_err(whoami, 0, "sleeping, not opening database");
}
sanity_check_queries();
/*
* Get moira server hostname for authentication
*/
if (uname(&uts) < 0)
{
com_err(whoami, errno, "Unable to get local hostname");
exit(1);
}
host = canonicalize_hostname(xstrdup(uts.nodename));
for (p = host; *p && *p != '.'; p++)
{
if (isupper(*p))
*p = tolower(*p);
}
*p = '\0';
/*
* Set up client array handler.
*/
nclients = 0;
clientssize = 10;
clients = xmalloc(clientssize * sizeof(client *));
mr_setup_signals();
journal = fopen(JOURNAL, "a");
if (!journal)
{
com_err(whoami, errno, "opening journal file");
exit(1);
}
/*
* Establish template connection.
*/
listener = mr_listen(port);
if (listener == -1)
{
com_err(whoami, MR_ABORTED, "trying to create listening connection");
exit(1);
}
FD_ZERO(&xreadfds);
FD_ZERO(&xwritefds);
FD_SET(listener, &xreadfds);
nfds = listener + 1;
com_err(whoami, 0, "started (pid %d)", getpid());
com_err(whoami, 0, rcsid);
if (dormant != ASLEEP)
send_zgram("MOIRA", "server started");
else
send_zgram("MOIRA", "server started, but database closed");
/*
* Run until shut down.
*/
while (!takedown)
{
int i;
struct timeval timeout = {60, 0}; /* 1 minute */
/* If we're supposed to go down and we can, do it */
if (((dormant == AWAKE) && (nclients == 0) &&
(stat(MOIRA_MOTD_FILE, &stbuf) == 0)) ||
(dormant == SLEEPY))
{
mr_close_database();
com_err(whoami, 0, "database closed");
mr_setup_signals();
send_zgram("MOIRA", "database closed");
dormant = ASLEEP;
}
/* Block until something happens. */
memcpy(&readfds, &xreadfds, sizeof(readfds));
memcpy(&writefds, &xwritefds, sizeof(writefds));
if (select(nfds, &readfds, &writefds, NULL, &timeout) == -1)
{
if (errno != EINTR)
com_err(whoami, errno, "in select");
continue;
}
if (takedown)
break;
if (child_exited_abnormally)
{
critical_alert(whoami, "moirad", "%d: child exits with signal %d status %d",
child_pid, child_signal, child_status);
child_exited_abnormally = 0;
}
time(&now);
tardy = now - 30 * 60;
/* If we're asleep and we should wake up, do it */
if ((dormant == ASLEEP) && (stat(MOIRA_MOTD_FILE, &stbuf) == -1) &&
(errno == ENOENT))
{
mr_open_database();
com_err(whoami, 0, "database open");
mr_setup_signals();
send_zgram("MOIRA", "database open again");
dormant = AWAKE;
}
/* Handle any new connections */
if (FD_ISSET(listener, &readfds))
{
int newconn, addrlen = sizeof(struct sockaddr_in);
struct sockaddr_in addr;
client *cp;
newconn = accept(listener, (struct sockaddr *)&addr, &addrlen);
if (newconn == -1)
com_err(whoami, errno, "accepting new connection");
else if (newconn > 0)
{
if (newconn + 1 > nfds)
nfds = newconn + 1;
FD_SET(newconn, &xreadfds);
/* Add a new client to the array */
nclients++;
if (nclients > clientssize)
{
clientssize = 2 * clientssize;
clients = xrealloc(clients, clientssize * sizeof(client *));
}
clients[nclients - 1] = cp = xmalloc(sizeof(client));
memset(cp, 0, sizeof(client));
cp->con = newconn;
cp->id = counter++;
cp->last_time_used = now;
cp->haddr = addr;
cp->tuplessize = 1;
cp->tuples = xmalloc(sizeof(mr_params));
memset(cp->tuples, 0, sizeof(mr_params));
cp->state = CL_ACCEPTING;
cp->version = 2;
cur_client = cp;
com_err(whoami, 0,
"New connection from %s port %d (now %d client%s)",
inet_ntoa(cp->haddr.sin_addr),
(int)ntohs(cp->haddr.sin_port),
nclients, nclients != 1 ? "s" : "");
}
}
/* Handle any existing connections. */
for (i = 0; i < nclients; i++)
{
cur_client = clients[i];
if (FD_ISSET(clients[i]->con, &writefds))
{
client_write(clients[i]);
if (!clients[i]->ntuples)
{
FD_CLR(clients[i]->con, &xwritefds);
FD_SET(clients[i]->con, &xreadfds);
}
clients[i]->last_time_used = now;
}
if (FD_ISSET(clients[i]->con, &readfds))
{
if (clients[i]->state == CL_ACCEPTING)
{
switch(mr_cont_accept(clients[i]->con,
&clients[i]->hsbuf,
&clients[i]->hslen))
{
case -1:
break;
case 0:
clients[i]->state = CL_CLOSING;
break;
default:
clients[i]->state = CL_ACTIVE;
clients[i]->hsbuf = NULL;
break;
}
}
else
{
client_read(clients[i]);
if (clients[i]->ntuples)
{
FD_CLR(clients[i]->con, &xreadfds);
FD_SET(clients[i]->con, &xwritefds);
}
clients[i]->last_time_used = now;
}
}
if (clients[i]->last_time_used < tardy)
{
com_err(whoami, 0, "Shutting down connection due to inactivity");
clients[i]->state = CL_CLOSING;
}
if (clients[i]->state == CL_CLOSING)
{
client *old;
com_err(whoami, 0, "Closed connection (now %d client%s, "
"%d queries)", nclients - 1, nclients != 2 ? "s" : "",
newqueries);
shutdown(clients[i]->con, 2);
close(clients[i]->con);
FD_CLR(clients[i]->con, &xreadfds);
FD_CLR(clients[i]->con, &xwritefds);
free_rtn_tuples(clients[i]);
free(clients[i]->tuples);
if (clients[i]->hsbuf)
free(clients[i]->hsbuf);
old = clients[i];
clients[i] = clients[--nclients];
free(old);
}
cur_client = NULL;
if (takedown)
break;
}
}
com_err(whoami, 0, "%s", takedown);
if (dormant != ASLEEP)
mr_close_database();
send_zgram("MOIRA", takedown);
return 0;
}
int main(int argc, char **argv)
{
char *str, *p;
size_t len;
struct _dt *d;
struct utsname name;
int s, conn;
struct sigaction sa;
FILE *pid_file;
char *pid_path = NULL;
whoami = strrchr(argv[0], '/');
if (whoami)
whoami++;
else
whoami = argv[0];
/* interpret arguments here */
if (argc != 1)
{
fprintf(stderr, "Usage: %s\n", whoami);
exit(1);
}
if (!config_lookup("nofork"))
{
if (fork())
exit(0);
setsid();
}
uname(&name);
hostname = name.nodename;
umask(0022);
mr_init();
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sa.sa_handler = child_handler;
sigaction(SIGCHLD, &sa, NULL);
/* If the config file contains a line "user username", the
* daemon will run with that user's UID.
*/
if ((p = config_lookup("user")))
{
struct passwd *pw;
pw = getpwnam(p);
if (!pw)
{
com_err(whoami, errno, "Unable to find user %s\n", p);
exit(1);
}
uid = pw->pw_uid;
}
/* If the config file contains a line "port portname", the daemon
* will listen on the named port rather than SERVICE_NAME ("moira_update")
*/
if (!(p = config_lookup("port")))
p = SERVICE_NAME;
s = mr_listen(p);
if (s == -1)
{
com_err(whoami, errno, "creating listening socket");
exit(1);
}
set_com_err_hook(syslog_com_err_proc);
openlog(whoami, LOG_PID, LOG_DAEMON);
if ((pid_path = malloc(strlen(PIDFILEPATH) + strlen(whoami) + 6)) != NULL)
{
sprintf(pid_path, "%s/%s.pid", PIDFILEPATH, whoami);
pid_file = fopen(pid_path, "w");
if (pid_file)
{
fprintf(pid_file, "%d\n", getpid ());
fclose(pid_file);
}
else
{
com_err(whoami, errno, "Unable to write PID file %s", pid_path);
exit(1);
}
free(pid_path);
}
else
{
com_err(whoami, errno, "Could not allocate memory for pidfile path");
exit(1);
}
/* now loop waiting for connections */
while (1)
{
struct sockaddr_in client;
long len;
char *buf;
conn = mr_accept(s, &client);
if (conn == -1)
{
com_err(whoami, errno, "accepting on listening socket");
exit(1);
}
else if (conn == 0)
continue;
if (config_lookup("nofork") || (fork() <= 0))
break;
close(conn);
}
/* If the config file contains a line "chroot /dir/name", the
* daemon will run chrooted to that directory.
*/
if ((p = config_lookup("chroot")))
{
if (chroot(p) < 0)
{
com_err(whoami, errno, "unable to chroot to %s", p);
exit(1);
}
}
com_err(whoami, 0, "got connection");
while (1)
{
char *cp, *str;
size_t len;
int code;
code = recv_string(conn, &str, &len);
if (code)
{
com_err(whoami, code, "receiving command");
close(conn);
exit(1);
}
cp = strchr(str, ' ');
if (cp)
*cp = '\0';
for (d = dispatch_table; d->str; d++)
{
if (!strcmp(d->str, str))
{
if (cp)
*cp = ' ';
(d->proc)(conn, str);
goto ok;
}
}
com_err(whoami, 0, "unknown request received: %s", str);
code = send_int(conn, MR_UNKNOWN_PROC);
if (code)
com_err(whoami, code, "sending UNKNOWN_PROC");
ok:
free(str);
}
}
