int main()
{
register_all();
static_assert(std::is_same<Increment::result_type, int>::value, "");
std::cout << "\n";
int result = execute_command<Increment>(1);
int sum = execute_command<Sum>(1, 2);
}
/*! Registers available dpis and stops active non-filter dpis.
* Called when dpid receives
* cmd='register' service='all'
* command
* \Return
* Number of available dpis
*/
int register_all_cmd()
{
stop_active_dpis(dpi_attr_list, numdpis);
free_plugin_list(&dpi_attr_list, numdpis);
free_services_list(services_list);
services_list = NULL;
numdpis = 0;
numsocks = 1; /* the srs socket */
FD_ZERO(&sock_set);
FD_SET(srs_fd, &sock_set);
numdpis = register_all(&dpi_attr_list);
fill_services_list(dpi_attr_list, numdpis, &services_list);
numsocks = init_all_dpi_sockets(dpi_attr_list);
return (numdpis);
}
/*! \todo
* \li Add a dpid_idle_timeout variable to dpidrc
* \bug Infinite loop if plugin crashes before it accepts a connection
*/
int main(void)
{
int i, n = 0, open_max;
int dpid_idle_timeout = 60 * 60; /* default, in seconds */
struct timeval select_timeout;
sigset_t mask_none;
fd_set selected_set;
dpi_attr_list = NULL;
services_list = NULL;
//daemon(0,0); /* Use 0,1 for feedback */
/* TODO: call setsid() ?? */
/* Allow read and write access, but only for the user.
* TODO: can this cause trouble with umount? */
umask(0077);
/* TODO: make dpid work on any directory. */
// chdir("/");
/* close inherited file descriptors */
open_max = get_open_max();
for (i = 3; i < open_max; i++)
dClose(i);
/* this sleep used to unmask a race condition */
// sleep(2);
dpi_errno = no_errors;
/* Get list of available dpis */
numdpis = register_all(&dpi_attr_list);
#if 0
/* Get name of socket directory */
dirname = a_Dpi_sockdir_file();
if ((sockdir = init_sockdir(dirname)) == NULL) {
ERRMSG("main", "init_sockdir", 0);
MSG_ERR("Failed to create socket directory\n");
exit(1);
}
#endif
/* Init and get services list */
fill_services_list(dpi_attr_list, numdpis, &services_list);
/* Remove any sockets that may have been leftover from a crash */
//cleanup();
/* Initialise sockets */
if ((numsocks = init_ids_srs_socket()) == -1) {
switch (dpi_errno) {
case dpid_srs_addrinuse:
MSG_ERR("dpid refuses to start, possibly because:\n");
MSG_ERR("\t1) An instance of dpid is already running.\n");
MSG_ERR("\t2) A previous dpid didn't clean up on exit.\n");
exit(1);
default:
//ERRMSG("main", "init_srs_socket failed", 0);
ERRMSG("main", "init_ids_srs_socket failed", 0);
exit(1);
}
}
numsocks = init_all_dpi_sockets(dpi_attr_list);
est_dpi_terminator();
est_dpi_sigchld();
(void) sigemptyset(&mask_sigchld);
(void) sigaddset(&mask_sigchld, SIGCHLD);
(void) sigemptyset(&mask_none);
(void) sigprocmask(SIG_SETMASK, &mask_none, NULL);
printf("dpid started\n");
/* Start main loop */
while (1) {
do {
(void) sigprocmask(SIG_BLOCK, &mask_sigchld, NULL);
if (caught_sigchld) {
handle_sigchld();
caught_sigchld = 0;
}
(void) sigprocmask(SIG_UNBLOCK, &mask_sigchld, NULL);
select_timeout.tv_sec = dpid_idle_timeout;
select_timeout.tv_usec = 0;
selected_set = sock_set;
n = select(FD_SETSIZE, &selected_set, NULL, NULL, &select_timeout);
if (n == 0) { /* select timed out, try to exit */
/* BUG: This is a workaround for dpid not to exit when the
* downloads server is active. The proper way to handle it is with
* a dpip command that asks the server whether it's busy.
* Note: the cookies server may lose session info too. */
if (server_is_running("downloads"))
continue;
stop_active_dpis(dpi_attr_list, numdpis);
//cleanup();
exit(0);
}
} while (n == -1 && errno == EINTR);
if (n == -1) {
ERRMSG("main", "select", errno);
exit(1);
}
/* If the service req socket is selected then service the req. */
if (FD_ISSET(srs_fd, &selected_set)) {
int sock_fd;
socklen_t sin_sz;
struct sockaddr_in sin;
char *req = NULL;
--n;
assert(n >= 0);
sin_sz = (socklen_t) sizeof(sin);
sock_fd = accept(srs_fd, (struct sockaddr *)&sin, &sin_sz);
if (sock_fd == -1) {
ERRMSG("main", "accept", errno);
MSG_ERR("accept on srs socket failed\n");
MSG_ERR("service pending connections, and continue\n");
} else {
int command;
Dsh *sh;
sh = a_Dpip_dsh_new(sock_fd, sock_fd, 1024);
read_next:
req = get_request(sh);
command = get_command(sh, req);
switch (command) {
case AUTH_CMD:
if (a_Dpip_check_auth(req) != -1) {
dFree(req);
goto read_next;
}
break;
case BYE_CMD:
stop_active_dpis(dpi_attr_list, numdpis);
//cleanup();
exit(0);
break;
case CHECK_SERVER_CMD:
send_sockport(sock_fd, req, dpi_attr_list);
break;
case REGISTER_ALL_CMD:
register_all_cmd();
break;
case UNKNOWN_CMD:
{
char *d_cmd = a_Dpip_build_cmd("cmd=%s msg=%s",
"DpiError", "Unknown command");
(void) CKD_WRITE(sock_fd, d_cmd);
dFree(d_cmd);
ERRMSG("main", "Unknown command", 0);
MSG_ERR(" for request: %s\n", req);
break;
}
case -1:
_ERRMSG("main", "get_command failed", 0);
break;
}
if (req)
free(req);
a_Dpip_dsh_close(sh);
a_Dpip_dsh_free(sh);
}
}
/* While there's a request on one of the plugin sockets
* find the matching plugin and start it. */
for (i = 0; n > 0 && i < numdpis; i++) {
if (FD_ISSET(dpi_attr_list[i].sock_fd, &selected_set)) {
--n;
assert(n >= 0);
if (dpi_attr_list[i].filter) {
/* start a dpi filter plugin and continue watching its socket
* for new connections */
(void) sigprocmask(SIG_SETMASK, &mask_none, NULL);
start_filter_plugin(dpi_attr_list[i]);
} else {
/* start a dpi server plugin but don't wait for new connections
* on its socket */
numsocks--;
assert(numsocks >= 0);
FD_CLR(dpi_attr_list[i].sock_fd, &sock_set);
if ((dpi_attr_list[i].pid = fork()) == -1) {
ERRMSG("main", "fork", errno);
/* exit(1); */
} else if (dpi_attr_list[i].pid == 0) {
/* child */
(void) sigprocmask(SIG_SETMASK, &mask_none, NULL);
start_server_plugin(dpi_attr_list[i]);
}
}
}
}
}
}
int asc_support_main(ATerm *bottomOfStack, int argc, char *argv[], void (*register_all)(), void (*resolve_all)(), void (*init_all)(), unsigned const char* tableBaf, size_t tableSize, ATbool parseInput, ATBhandler handler) {
PT_ParseTree pt = NULL;
PT_Tree asfix;
PT_Tree trm;
PT_ParseTree rpt = NULL;
ATerm reduct;
const char *outputFilename;
int numberOfInputs;
ATinit(argc, argv, bottomOfStack);
initApis();
register_all();
resolve_all();
init_all();
initParsetable(tableBaf, tableSize);
SGLR_initialize();
OPT_initialize();
ASC_initializeDefaultOptions();
/* Check whether we're a ToolBus process */
if (toolbusMode(argc, argv)) {
ATBinit(argc, argv, bottomOfStack);
ATBconnect(NULL, NULL, -1, asf_toolbus_handler);
ATBeventloop();
}
else {
handleOptions(argc, argv, parseInput);
numberOfInputs = ASC_getNumberOfParseTrees();
outputFilename = ASC_getOutputFilename();
if (!streq(ASC_getPrefixFunction(),"")) {
pt = applyFunction((const char*) ASC_getPrefixFunction(),
(const char*) ASC_getResultNonTermName(), numberOfInputs, inputs);
}
else {
if (numberOfInputs == 0) {
pt = parsetreeFromFile("-", parseInput);
}
else if (numberOfInputs == 1) {
pt = inputs[0];
}
else if (numberOfInputs != 1) {
ATerror("Can only process one argument if no -f and -r option "
"are supplied.\n"
"Did a -s argument eat up your -f or -r option?\n");
return 1;
}
}
if (PT_isValidParseTree(pt)) {
trm = PT_getParseTreeTop(pt);
if (ASC_getVerboseFlag()) { ATfprintf(stderr,"Reducing ...\n"); }
reduct = innermost(trm);
if (ASC_getVerboseFlag()) { ATfprintf(stderr,"Reducing finished.\n"); }
if (ASC_getStatsFlag()) { printStats(); }
if (ASC_getOutputFlag()) {
asfix = toasfix(reduct);
rpt = PT_makeParseTreeTop(asfix, 0);
if (parseInput) {
FILE *fp = NULL;
if (!strcmp(outputFilename, "-")) {
fp = stdout;
}
else {
fp = fopen(outputFilename, "wb");
}
if (fp != NULL) {
PT_yieldParseTreeToFile(rpt, fp, ATfalse);
}
else {
ATerror("asc-main: unable to open %s for writing\n", outputFilename);
}
}
else {
if (ASC_getBafmodeFlag()) {
ATwriteToNamedBinaryFile(PT_ParseTreeToTerm(rpt),outputFilename);
}
else {
ATwriteToNamedTextFile(PT_ParseTreeToTerm(rpt),outputFilename);
}
}
}
}
}
return 0;
}
int asc_support_main(ATerm *bottomOfStack, int argc, char *argv[],
void (*register_all)(),
void (*resolve_all)(),
void (*init_all)()
#ifdef TOOLBUS
, ATBhandler handler
#endif
)
{
PT_ParseTree pt;
PT_ParseTree asfix;
PT_Tree trm;
ATerm t;
ATerm reduct;
#ifdef TOOLBUS
ATbool toolbus_mode = ATfalse;
#endif
ATbool produce_output = ATtrue;
ATbool run_verbose = ATfalse;
ATbool printstats = ATfalse;
ATbool bafmode = ATtrue;
char *inputs[MAX_ARGS] = { "-" };
int nInputs = 0;
char *output = "-";
char *function = "";
char *result = "";
int i;
ATinit(argc, argv, bottomOfStack);
PT_initMEPTApi();
ASF_initASFMEApi();
ASC_initRunTime(INITIAL_TABLE_SIZE);
register_all();
resolve_all();
init_all();
#ifdef TOOLBUS
/* Check whether we're a ToolBus process */
for(i=1; !toolbus_mode && i<argc; i++) {
if(!strcmp(argv[i], "-TB_TOOL_NAME")) {
toolbus_mode = ATtrue;
}
}
if (toolbus_mode) {
ATBinit(argc, argv, bottomOfStack);
ATBconnect(NULL, NULL, -1, handler);
ATBeventloop();
}
else {
#endif
for(i=1; i<argc; i++) {
if(streq(argv[i], "-v")) {
run_verbose = ATtrue;
}
else if(streq(argv[i], "-h")) {
usage(argv[0]);
}
else if(streq(argv[i], "-f")) {
function = argv[++i];
}
else if(streq(argv[i], "-i")) {
if (nInputs <= MAX_ARGS) {
inputs[nInputs++] = strdup(argv[++i]);
}
else {
ATerror("%s: Maximum number of %d \'-i\' arguments exceeded.\n",
argv[0], MAX_ARGS);
}
}
else if(streq(argv[i], "-o")) {
output = argv[++i];
}
else if(streq(argv[i], "-r")) {
result = argv[++i];
}
else if(streq(argv[i], "-s")) {
printstats = ATtrue;
}
else if(streq(argv[i], "-t")) {
bafmode = ATfalse;
}
else if(streq(argv[i], "-m")) {
produce_output = ATfalse;
}
}
if (!streq(function,"")) {
PT_Args args = PT_makeArgsEmpty();
if (streq(inputs[0],"-")) {
nInputs++;
}
for (--nInputs; nInputs >= 0; nInputs--) {
PT_ParseTree parseTree = PT_makeParseTreeFromTerm(
ATreadFromNamedFile(inputs[nInputs]));
if (parseTree == NULL) {
ATerror("Unable to read in %s\n", inputs[nInputs]);
exit(1);
}
args = PT_makeArgsList(PT_getParseTreeTree(parseTree), args);
}
pt = PT_applyFunctionToArgsParseTree(function, result, args);
}
else {
if (nInputs != 1 && (!streq(inputs[0], "-"))) {
ATerror("Can only process one argument if no -f and -r option "
"are supplied.\n");
return 1;
}
t = ATreadFromNamedFile(inputs[0]);
pt = PT_makeParseTreeFromTerm(t);
}
if (PT_isValidParseTree(pt)) {
trm = PT_getParseTreeTree(pt);
if(run_verbose) {
ATfprintf(stderr,"Reducing ...\n");
}
reduct = innermost(trm);
if(run_verbose) {
ATfprintf(stderr,"Reducing finished.\n");
}
if (printstats) {
struct rusage usage;
FILE *file;
char buf[BUFSIZ];
int size, resident, shared, trs, lrs, drs, dt;
sprintf(buf, "/proc/%d/statm", getpid());
file = fopen(buf, "r");
if (file) {
fscanf(file, "%d %d %d %d %d %d %d",
&size, &resident, &shared, &trs, &lrs, &drs, &dt);
/*
fprintf(stderr, "size = %d kb\n", size*4);
fprintf(stderr, "resident = %d kb\n", resident*4);
fprintf(stderr, "shared = %d kb\n", shared*4);
fprintf(stderr, "trs = %d kb\n", trs*4);
fprintf(stderr, "lrs = %d kb\n", lrs*4);
*/
fprintf(stderr, "memory used : %d kb\n", drs*4);
/*fprintf(stderr, "dt = %d kb\n", dt*4);*/
} else {
fprintf(stderr, "could not open %s\n", buf);
perror("");
}
if (getrusage(RUSAGE_SELF, &usage) == -1) {
perror("rusage");
} else {
/*fprintf(stderr, "rusage statistics (see 'man getrusage')\n");*/
fprintf(stderr, "utime : %ld.%06d sec.\n",
(long)usage.ru_utime.tv_sec, (int)usage.ru_utime.tv_usec);
fprintf(stderr, "stime : %ld.%06d sec.\n",
(long)usage.ru_stime.tv_sec, (int)usage.ru_stime.tv_usec);
#if 0
/* The following rusage stats do not work yet */
fprintf(stderr, "maxrss : %ld\n", usage.ru_maxrss);
fprintf(stderr, "ixrss : %ld\n", usage.ru_ixrss);
fprintf(stderr, "idrss : %ld\n", usage.ru_idrss);
fprintf(stderr, "isrss : %ld\n", usage.ru_isrss);
fprintf(stderr, "minflt : %ld\n", usage.ru_minflt);
fprintf(stderr, "majflt : %ld\n", usage.ru_majflt);
fprintf(stderr, "nswap : %ld\n", usage.ru_nswap);
fprintf(stderr, "\n");
fprintf(stderr, "inblock : %ld\n", usage.ru_nswap);
fprintf(stderr, "oublock : %ld\n", usage.ru_nswap);
fprintf(stderr, "msgsnd : %ld\n", usage.ru_nswap);
fprintf(stderr, "msgrcv : %ld\n", usage.ru_nswap);
fprintf(stderr, "nsignals : %ld\n", usage.ru_nswap);
fprintf(stderr, "nvcsw : %ld\n", usage.ru_nswap);
fprintf(stderr, "nivcsw : %ld\n", usage.ru_nswap);
#endif
}
}
if (produce_output) {
asfix = toasfix(reduct);
if (bafmode) {
ATwriteToNamedBinaryFile(PT_makeTermFromParseTree(asfix),output);
}
else {
ATwriteToNamedTextFile(PT_makeTermFromParseTree(asfix),output);
}
}
}
#ifdef TOOLBUS
}
#endif
return 0;
}
