int main(int argc, char **argv)
{
char *s;
#if 0 /* Shouldn't need this.. */
signal(SIGHUP, SIG_IGN);
#endif
/* initialize locale support */
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
init_env();
do_args(argc, argv);
memset(inbuf, 0, sizeof(inbuf));
if (argc > 2) {
strncpy(logfname, argv[2], sizeof(logfname));
if (argc > 3)
strncpy(homedir, argv[3], sizeof(homedir));
else if ((s = getenv("HOME")) != NULL)
strncpy(homedir, s, sizeof(homedir));
else
homedir[0] = 0;
}
else
logfname[0] = 0;
return execscript(argv[1]) != OK;
}
void native_startup(int argc, char **argv) {
#if USE_RT_MON
{
/* create a 2d histogram for dope repaint actions */
double l[2] = {0, 0}; /* start at <0, 0> ... */
double h[2] = {400, 400}; /* ... up to <400, 400> */
int b[2] = {200, 200}; /* 200 bins for each dim */
/*
* Create histogram with 2 layers and use TSC times.
* layer 1 are accumulated times
* layer 2 counts time number of events added together in layer 1
* -> (layer 1 / layer 2) == average time
*
* Units: x- and y-axis are in pixel, z-axis is time in µsecs
*/
hist2dxy = rt_mon_hist2d_create(l, h, b, 2,
"dope/rel_xy_2d",
"w [px]", "h [px]", "t/px [ns/px]",
RT_MON_TSC_TIME);
}
#endif
/*
* Just avoid to start DOpE if another instance is already
* present.
*/
do_args(argc, argv);
}
/**
* ipsec pool --batch - read commands from a file
*/
static void batch(char *argv0, char *name)
{
char command[512];
FILE *file = strncmp(name, "-", 1) == 0 ? stdin : fopen(name, "r");
if (file == NULL)
{
fprintf(stderr, "opening '%s' failed: %s\n", name, strerror(errno));
exit(EXIT_FAILURE);
}
db->transaction(db, FALSE);
while (fgets(command, sizeof(command), file))
{
char *argv[ARGV_SIZE], *start;
int i, argc = 0;
size_t cmd_len = strlen(command);
/* ignore empty lines */
if (cmd_len == 1 && *(command + cmd_len - 1) == '\n')
{
continue;
}
/* parse command into argv */
start = command;
argv_add(argv, argc++, argv0);
for (i = 0; i < cmd_len; ++i)
{
if (command[i] == ' ' || command[i] == '\n')
{
if (command + i == start)
{
/* ignore leading whitespace */
++start;
continue;
}
command[i] = '\0';
argv_add(argv, argc++, start);
start = command + i + 1;
}
}
if (strlen(start) > 0)
{
argv_add(argv, argc++, start);
}
argv_add(argv, argc, NULL);
do_args(argc, argv);
}
db->commit(db);
if (file != stdin)
{
fclose(file);
}
}
int
main(int argc, char * const *argv)
{
const char *T_arg = NULL;
const char *S_arg = NULL;
const char *n_arg = NULL;
int opt, sock;
while ((opt = getopt(argc, argv, "n:S:T:t:")) != -1) {
switch (opt) {
case 'n':
n_arg = optarg;
break;
case 'S':
S_arg = optarg;
break;
case 'T':
T_arg = optarg;
break;
case 't':
timeout = strtod(optarg, NULL);
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (n_arg != NULL) {
if (T_arg != NULL || S_arg != NULL) {
usage();
}
sock = n_arg_sock(n_arg);
} else if (T_arg == NULL) {
sock = n_arg_sock("");
} else {
assert(T_arg != NULL);
sock = cli_sock(T_arg, S_arg);
}
if (sock < 0)
exit(2);
if (argc > 0)
do_args(sock, argc, argv);
else {
if (isatty(0)) {
interactive(sock);
} else {
pass(sock);
}
}
exit(0);
}
int main(int argc, char *argv[])
{
char *uri;
atexit(library_deinit);
/* initialize library */
if (!library_init(NULL, "pool"))
{
exit(SS_RC_LIBSTRONGSWAN_INTEGRITY);
}
if (lib->integrity &&
!lib->integrity->check_file(lib->integrity, "pool", argv[0]))
{
fprintf(stderr, "integrity check of pool failed\n");
exit(SS_RC_DAEMON_INTEGRITY);
}
if (!lib->plugins->load(lib->plugins,
lib->settings->get_str(lib->settings, "pool.load", PLUGINS)))
{
exit(SS_RC_INITIALIZATION_FAILED);
}
/* TODO: make database URI or setting key configurable via command line */
uri = lib->settings->get_str(lib->settings,
"pool.database",
lib->settings->get_str(lib->settings,
"charon.plugins.attr-sql.database",
lib->settings->get_str(lib->settings,
"libhydra.plugins.attr-sql.database", NULL)));
if (!uri)
{
fprintf(stderr, "database URI pool.database not set.\n");
exit(SS_RC_INITIALIZATION_FAILED);
}
db = lib->db->create(lib->db, uri);
if (!db)
{
fprintf(stderr, "opening database failed.\n");
exit(SS_RC_INITIALIZATION_FAILED);
}
atexit(cleanup);
do_args(argc, argv);
exit(EXIT_SUCCESS);
}
QoreValue QoreValueList::maxValue(const ResolvedCallReferenceNode* fr, ExceptionSink* xsink) const {
if (!priv->length)
return QoreValue();
QoreValue rv = priv->entry[0];
for (size_t i = 1; i < priv->length; ++i) {
QoreValue v = priv->entry[i];
safe_qorelist_t args(do_args(v, rv), xsink);
ValueHolder result(fr->execValue(*args, xsink), xsink);
if (*xsink)
return QoreValue();
if (result->getAsBigInt() > 0)
rv = v;
}
return rv.refSelf();
}
int main(int argc, char* argv[]){
char** ap;
initialize_syntax();
ap = argv+1;
stdout_stream = make_file_output_stream(stdout,"");
stdin_stream = make_file_input_stream(stdin,NULL);
output_stream = stdout_stream;
if ( argc >= 3 && stricmp(*ap,"-prim") == 0 ) {
CIStream ps;
ap++;
ps = open_input_file( *ap, FALSE );
if ( ps != NULL ) {
read_patterns(ps, "", FALSE);
cis_close(ps);
}
ap++;
}
else initialize_argv_domain();
do_args(ap);
return (int)exit_status;
}
int main( int argc, char **argv )
{
PALETTE pal;
int i;
/* init allegro and init palette */
install_allegro(SYSTEM_NONE, &errno, atexit);
set_color_depth(8);
set_color_conversion(COLORCONV_REDUCE_TO_256);
for( i = 0; i < 256; i++ )
{
/* divided by 4 because the colour value ranges from 0-63 */
pal[i].r = pal[i].g = pal[i].b = i/4;
}
srand(time(NULL));
do_args(argc, argv);
if( filename == NULL )
{
/* +1 for '\0' char */
filename = malloc(strlen(DEFT_FILENAME)+1);
if( filename == NULL )
{
fprintf(stderr, "error: can't malloc space for map name.\n");
exit(EXIT_FAILURE);
}
strcpy(filename, DEFT_FILENAME);
}
lwmapgen(size, grid_size, func_id);
save_bitmap(filename, map.map, pal);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
/* enable attest debugging hook */
dbg = pacman_dbg;
openlog("pacman", 0, LOG_DEBUG);
atexit(cleanup);
/* initialize library */
if (!library_init(NULL, "pacman"))
{
exit(SS_RC_LIBSTRONGSWAN_INTEGRITY);
}
if (!lib->plugins->load(lib->plugins,
lib->settings->get_str(lib->settings, "pacman.load", "sqlite")))
{
exit(SS_RC_INITIALIZATION_FAILED);
}
do_args(argc, argv);
exit(EXIT_SUCCESS);
}
/******************************************************************************
* main *
* *
* Main function *
******************************************************************************/
int main(int argc, char *argv[])
{
int error = 0, i=1;
l4_threadid_t dummy_l4id = L4_NIL_ID, loader_id;
// l4events_event_t event;
// l4events_nr_t eventnr;
CORBA_Environment _env = dice_default_environment;
/* init */
do_args(argc, argv);
my_l4id = l4thread_l4_id( l4thread_myself() );
LOG("Hello, I'm running as "l4util_idfmt, l4util_idstr(my_l4id));
/* ask for 'con' (timeout = 5000 ms) */
if (names_waitfor_name(CON_NAMES_STR, &con_l4id, 50000) == 0)
{
LOG("PANIC: %s not registered at names", CON_NAMES_STR);
enter_kdebug("panic");
}
if (names_waitfor_name("LOADER", &loader_id, 50000) == 0)
{
LOG("PANIC: LOADER not registered at names");
enter_kdebug("panic");
}
if (con_if_openqry_call(&con_l4id, MY_SBUF_SIZE, 0, 0,
L4THREAD_DEFAULT_PRIO,
&vc_l4id,
CON_VFB, &_env))
enter_kdebug("Ouch, open vc failed");
if (con_vc_smode_call(&vc_l4id, CON_OUT, &dummy_l4id, &_env))
enter_kdebug("Ouch, setup vc failed");
if (con_vc_graph_gmode_call(&vc_l4id, &gmode, &xres, &yres,
&bits_per_pixel, &bytes_per_pixel,
&bytes_per_line, &accel_flags,
&fn_x, &fn_y, &_env))
enter_kdebug("Ouch, graph_gmode failed");
if (bytes_per_pixel != 2)
{
printf("Graphics mode not 2 bytes/pixel, exiting\n");
con_vc_close_call(&vc_l4id, &_env);
exit(0);
}
if (create_logo())
enter_kdebug("Ouch, logo creation failed");
while (!error && (i>0))
{
if ((error = clear_screen()))
enter_kdebug("Ouch, clear_screen failed");
if ((error = logo()))
enter_kdebug("Ouch, logo failed");
l4_sleep(500);
i--;
}
if (con_vc_close_call(&vc_l4id, &_env))
enter_kdebug("Ouch, close vc failed?!");
LOG("Finally closed vc");
LOG("Going to bed ...");
names_register("CON_DEMO1");
/*
my_id = l4_myself();
event.len=sizeof(l4_umword_t);
*(l4_umword_t*)event.str=my_id.id.task;
l4events_send(1, &event, &eventnr, L4EVENTS_SEND_ACK);
l4events_get_ack(eventnr, L4_IPC_NEVER);
*/
return 0;
}
void
procstat_env(struct procstat *procstat, struct kinfo_proc *kipp)
{
do_args(procstat, kipp, 1);
}
int
main(int argc, char * const *argv)
{
const char *T_arg = NULL;
const char *S_arg = NULL;
const char *n_arg = NULL;
int opt, sock;
/*
* By default linux::getopt(3) mangles the argv order, such that
* varnishadm -n bla param.set foo -bar
* gets interpreted as
* varnishadm -n bla -bar param.set foo
* The '+' stops that from happening
* See #1496
*/
while ((opt = getopt(argc, argv, "+n:S:T:t:")) != -1) {
switch (opt) {
case 'n':
n_arg = optarg;
break;
case 'S':
S_arg = optarg;
break;
case 'T':
T_arg = optarg;
break;
case 't':
timeout = VNUM(optarg);
if (isnan(timeout))
usage();
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (n_arg != NULL) {
if (T_arg != NULL || S_arg != NULL) {
usage();
}
sock = n_arg_sock(n_arg);
} else if (T_arg == NULL) {
sock = n_arg_sock("");
} else {
assert(T_arg != NULL);
sock = cli_sock(T_arg, S_arg);
}
if (sock < 0)
exit(2);
if (argc > 0)
do_args(sock, argc, argv);
else {
if (isatty(0)) {
interactive(sock);
} else {
pass(sock);
}
}
exit(0);
}
int qore_value_list_private::mergesort(const ResolvedCallReferenceNode* fr, bool ascending, ExceptionSink* xsink) {
//printd(5, "List::mergesort() ENTER this: %p, pgm: %p, f: %p length: %d\n", this, pgm, f, length);
if (length <= 1)
return 0;
// separate list into two equal-sized lists
ReferenceHolder<QoreValueList> left(new QoreValueList, xsink);
ReferenceHolder<QoreValueList> right(new QoreValueList, xsink);
qore_value_list_private* l = left->priv;
qore_value_list_private* r = right->priv;
size_t mid = length / 2;
{
size_t i = 0;
for (; i < mid; i++)
l->push(entry[i]);
for (; i < length; i++)
r->push(entry[i]);
}
// set length to 0 - the temporary lists own the entry references now
length = 0;
// mergesort the two lists
if (l->mergesort(fr, ascending, xsink) || r->mergesort(fr, ascending, xsink))
return -1;
// merge the resulting lists
// use offsets and StackList::getAndClear() to avoid moving a lot of memory around
size_t li = 0, ri = 0;
while ((li < l->length) && (ri < r->length)) {
QoreValue& lv = l->entry[li];
QoreValue& rv = r->entry[ri];
int rc;
if (fr) {
safe_qorelist_t args(do_args(lv, rv), xsink);
ValueHolder result(fr->execValue(*args, xsink), xsink);
if (*xsink)
return -1;
rc = (int)result->getAsBigInt();
}
else {
ValueHolder result(OP_LOG_CMP->eval(lv, rv, true, 2, xsink), xsink);
if (*xsink)
return -1;
rc = (int)result->getAsBigInt();
}
if ((ascending && rc <= 0)
|| (!ascending && rc > 0))
push(l->getAndClear(li++));
else
push(r->getAndClear(ri++));
}
// only one list will have entries left...
while (li < l->length)
push(l->getAndClear(li++));
while (ri < r->length)
push(r->getAndClear(ri++));
//printd(5, "List::mergesort() EXIT this: %p, length: %d\n", this, length);
return 0;
}
int qore_value_list_private::qsort(const ResolvedCallReferenceNode* fr, size_t left, size_t right, bool ascending, ExceptionSink* xsink) {
size_t l_hold = left;
size_t r_hold = right;
QoreValue pivot = entry[left];
while (left < right) {
while (true) {
int rc;
if (fr) {
safe_qorelist_t args(do_args(entry[right], pivot), xsink);
ValueHolder rv(fr->execValue(*args, xsink), xsink);
if (*xsink)
return -1;
rc = (int)rv->getAsBigInt();
}
else {
ValueHolder rv(OP_LOG_CMP->eval(entry[right], pivot, true, 2, xsink), xsink);
if (*xsink)
return -1;
rc = (int)rv->getAsBigInt();
}
if ((left < right)
&& ((rc >= 0 && ascending)
|| (rc < 0 && !ascending)))
--right;
else
break;
}
if (left != right) {
entry[left] = entry[right];
++left;
}
while (true) {
int rc;
if (fr) {
safe_qorelist_t args(do_args(entry[left], pivot), xsink);
ValueHolder rv(fr->execValue(*args, xsink), xsink);
if (*xsink)
return -1;
rc = (int)rv->getAsBigInt();
}
else {
ValueHolder rv(OP_LOG_CMP->eval(entry[left], pivot, true, 2, xsink), xsink);
if (*xsink)
return -1;
rc = (int)rv->getAsBigInt();
}
if ((left < right)
&& ((rc <= 0 && ascending)
|| (rc > 0 && !ascending)))
++left;
else
break;
}
if (left != right) {
entry[right] = entry[left];
--right;
}
}
entry[left] = pivot;
size_t t_left = left;
left = l_hold;
right = r_hold;
int rc = 0;
if (left < t_left)
rc = qsort(fr, left, t_left - 1, ascending, xsink);
if (!rc && right > t_left)
rc = qsort(fr, t_left + 1, right, ascending, xsink);
return rc;
}
int main(int argc, char**argv) {
return do_args(argc,argv);
}
/******************************************************************************
* main *
* *
* Main function *
******************************************************************************/
int main(int argc, char *argv[])
{
int error = 0;
l4_threadid_t dummy_l4id = L4_NIL_ID;
CORBA_Environment _env = dice_default_environment;
/* init */
do_args(argc, argv);
my_l4id = l4thread_l4_id( l4thread_myself() );
LOG("Hello, I'm running as "l4util_idfmt, l4util_idstr(my_l4id));
/* ask for 'con' (timeout = 5000 ms) */
if (names_waitfor_name(CON_NAMES_STR, &con_l4id, 50000) == 0)
{
LOG("PANIC: %s not registered at names", CON_NAMES_STR);
enter_kdebug("panic");
}
if (con_if_openqry_call(&con_l4id, MY_SBUF_SIZE, 0, 0,
L4THREAD_DEFAULT_PRIO,
&vc_l4id,
CON_VFB, &_env))
enter_kdebug("Ouch, open vc failed");
if (con_vc_smode_call(&vc_l4id, CON_OUT, &dummy_l4id, &_env))
enter_kdebug("Ouch, setup vc failed");
if (con_vc_graph_gmode_call(&vc_l4id, &gmode, &xres, &yres,
&bits_per_pixel, &bytes_per_pixel,
&bytes_per_line, &accel_flags,
&fn_x, &fn_y, &_env))
enter_kdebug("Ouch, graph_gmode failed");
if (bytes_per_pixel != 2)
{
printf("Graphics mode not 2 bytes/pixel, exiting\n");
con_vc_close_call(&vc_l4id, &_env);
exit(0);
}
if (create_logo())
enter_kdebug("Ouch, logo creation failed");
while (!error)
{
if ((error = clear_screen()))
enter_kdebug("Ouch, clear_screen failed");
if ((error = logo()))
enter_kdebug("Ouch, logo failed");
l4_sleep(2000);
}
if (con_vc_close_call(&vc_l4id, &_env))
enter_kdebug("Ouch, close vc failed?!");
LOG("Finally closed vc");
LOG("Going to bed ...");
l4_sleep(-1);
return 0;
}
int
main(int argc, char *const *argv)
{
struct sockaddr_in bindaddr;
socklen_t addrlen;
const char *isDA;
const char *proxyReg;
int connfd;
int lfd;
const int on = 1;
detachfromtty();
openlog("slpd", LOG_PID, LOG_DAEMON);
do_args(argc, argv);
/* If slpd has been configured to run as a DA, start it and exit */
isDA = SLPGetProperty("net.slp.isDA");
proxyReg = SLPGetProperty("net.slp.serializedRegURL");
if ((isDA && (strcasecmp(isDA, "true") == 0)) || proxyReg) {
run_slpd();
return (1);
}
if ((lfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
syslog(LOG_ERR, "socket failed: %s", strerror(errno));
cleanup_and_exit(1);
}
(void) setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on));
(void) memset((void *)&bindaddr, 0, sizeof (bindaddr));
bindaddr.sin_family = AF_INET;
bindaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
bindaddr.sin_port = htons(427);
if (bind(lfd, (const struct sockaddr *)&bindaddr, sizeof (bindaddr))
< 0) {
syslog(LOG_ERR, "bind failed: %s", strerror(errno));
cleanup_and_exit(1);
}
if (listen(lfd, 1) < 0) {
syslog(LOG_ERR, "listen failed: %s", strerror(errno));
cleanup_and_exit(1);
}
addrlen = sizeof (bindaddr);
if ((connfd = accept(lfd, (struct sockaddr *)&bindaddr, &addrlen))
< 0) {
syslog(LOG_ERR, "accept failed: %s", strerror(errno));
cleanup_and_exit(1);
}
(void) close(lfd);
(void) dup2(connfd, 0);
(void) close(connfd);
(void) dup2(0, 1);
(void) dup2(0, 2);
run_slpd();
return (1);
}
