void
symplectic_basis(homol_t alpha, homol_t beta, const tree_t tree, sec_t c)
{
slong i, len = (c.d-1)*(c.m-1);
fmpz_mat_t m, p;
fmpz_mat_init(m, len, len);
fmpz_mat_init(p, len, len);
/* compute big intersection matrix, size len = (d-1)*(m-1) */
intersection_tree(m, tree, c.d, c.m);
symplectic_reduction(p, m, c.g);
fmpz_mat_clear(m);
for (i = 0; i < c.g; i++)
{
slong n;
fmpz * row;
/* loops alpha = even coordinates */
row = p->rows[2 * i];
n = count_coeffs(row, len);
loop_init(&alpha[i], n);
set_loops(alpha[i].l, n, row, c.m - 1, len);
/* loops beta = odd coordinates */
row = p->rows[2 * i + 1];
n = count_coeffs(row, len);
loop_init(&beta[i], n);
set_loops(beta[i].l, n, row, c.m - 1, len);
}
fmpz_mat_clear(p);
}
/// Loop run while idle
static void main_loop_init(void)
{
// Run next frame, do not auto-reload
static struct loop_timer frame_timer = {
.timer_cb = megawifi_init_cb,
.frames = 1
};
static struct loop_func megawifi_loop = {
.func_cb = idle_cb
};
loop_init(MW_MAX_LOOP_FUNCS, MW_MAX_LOOP_TIMERS);
loop_timer_add(&frame_timer);
loop_func_add(&megawifi_loop);
}
/// Global initialization
static void init(void)
{
// Initialize memory pool
mp_init(0);
// Initialize VDP
VdpInit();
// Initialize game loop
main_loop_init();
// Initialize MegaWiFi
mw_init(cmd_buf, MW_BUFLEN);
}
int main(void)
{
struct json_object *cmd;
engine_callback = main_callback;
if (engine_init() < 0)
exit(1);
signal(SIGINT, stop_loop);
loop_init();
initscr();
cbreak();
noecho();
keypad(stdscr, TRUE);
win_body_lines = LINES - 8;
// If you don't do this, the service config form won't be displayed
while (win_body_lines % 4 != 3)
win_body_lines--;
win_body = newwin(win_body_lines + 2, COLS, 2, 0);
box(win_body, 0 , 0);
keypad(win_body, TRUE);
win_header = newwin(2, COLS, 0, 0);
win_footer = newwin(2, COLS, LINES-2, 0);
// Print all windows, according to the man it's more efficient than 3
wnoutrefresh(win_header);
wnoutrefresh(win_body);
wnoutrefresh(win_footer);
doupdate();
context.current_context = CONTEXT_HOME;
context.serv = malloc(sizeof(struct userptr_data));
assert(context.serv != NULL);
context.tech = malloc(sizeof(struct userptr_data));
assert(context.tech != NULL);
// get_home_page (and render it)
cmd = json_object_new_object();
json_object_object_add(cmd, key_command, json_object_new_string("get_home_page"));
engine_query(cmd);
loop_run(true);
loop_terminate();
delwin(win_header);
delwin(win_body);
delwin(win_footer);
endwin();
return 0;
}
/* Set up the main loop. If proponly is set, don't set up ports for kpasswd or
* kadmin. May set *ctx_out even on error. */
static krb5_error_code
setup_loop(int proponly, verto_ctx **ctx_out)
{
krb5_error_code ret;
verto_ctx *ctx;
kadm5_server_handle_t handle = global_server_handle;
*ctx_out = ctx = loop_init(VERTO_EV_TYPE_SIGNAL);
if (ctx == NULL)
return ENOMEM;
ret = loop_setup_signals(ctx, global_server_handle, NULL);
if (ret)
return ret;
if (!proponly) {
ret = loop_add_udp_address(handle->params.kpasswd_port,
handle->params.kpasswd_listen);
if (ret)
return ret;
ret = loop_add_tcp_address(handle->params.kpasswd_port,
handle->params.kpasswd_listen);
if (ret)
return ret;
ret = loop_add_rpc_service(handle->params.kadmind_port,
handle->params.kadmind_listen,
KADM, KADMVERS, kadm_1);
if (ret)
return ret;
}
#ifndef DISABLE_IPROP
if (handle->params.iprop_enabled) {
ret = loop_add_rpc_service(handle->params.iprop_port,
handle->params.iprop_listen,
KRB5_IPROP_PROG, KRB5_IPROP_VERS,
krb5_iprop_prog_1);
if (ret)
return ret;
}
#endif
return loop_setup_network(ctx, global_server_handle, progname,
DEFAULT_TCP_LISTEN_BACKLOG);
}
int main(int argc, char **argv)
{
krb5_error_code retval;
krb5_context kcontext;
verto_ctx *ctx;
int errout = 0;
int i;
setlocale(LC_MESSAGES, "");
if (strrchr(argv[0], '/'))
argv[0] = strrchr(argv[0], '/')+1;
if (!(kdc_realmlist = (kdc_realm_t **) malloc(sizeof(kdc_realm_t *) *
KRB5_KDC_MAX_REALMS))) {
fprintf(stderr, _("%s: cannot get memory for realm list\n"), argv[0]);
exit(1);
}
memset(kdc_realmlist, 0,
(size_t) (sizeof(kdc_realm_t *) * KRB5_KDC_MAX_REALMS));
/*
* A note about Kerberos contexts: This context, "kcontext", is used
* for the KDC operations, i.e. setup, network connection and error
* reporting. The per-realm operations use the "realm_context"
* associated with each realm.
*/
retval = krb5int_init_context_kdc(&kcontext);
if (retval) {
com_err(argv[0], retval, _("while initializing krb5"));
exit(1);
}
krb5_klog_init(kcontext, "kdc", argv[0], 1);
kdc_err_context = kcontext;
kdc_progname = argv[0];
/* N.B.: After this point, com_err sends output to the KDC log
file, and not to stderr. We use the kdc_err wrapper around
com_err to ensure that the error state exists in the context
known to the krb5_klog callback. */
initialize_kdc5_error_table();
/*
* Scan through the argument list
*/
initialize_realms(kcontext, argc, argv);
ctx = loop_init(VERTO_EV_TYPE_NONE);
if (!ctx) {
kdc_err(kcontext, ENOMEM, _("while creating main loop"));
finish_realms();
return 1;
}
load_preauth_plugins(kcontext);
load_authdata_plugins(kcontext);
retval = setup_sam();
if (retval) {
kdc_err(kcontext, retval, _("while initializing SAM"));
finish_realms();
return 1;
}
/* Handle each realm's ports */
for (i=0; i<kdc_numrealms; i++) {
char *cp = kdc_realmlist[i]->realm_ports;
int port;
while (cp && *cp) {
if (*cp == ',' || isspace((int) *cp)) {
cp++;
continue;
}
port = strtol(cp, &cp, 10);
if (cp == 0)
break;
retval = loop_add_udp_port(port);
if (retval)
goto net_init_error;
}
cp = kdc_realmlist[i]->realm_tcp_ports;
while (cp && *cp) {
if (*cp == ',' || isspace((int) *cp)) {
cp++;
continue;
}
port = strtol(cp, &cp, 10);
if (cp == 0)
break;
retval = loop_add_tcp_port(port);
if (retval)
goto net_init_error;
}
}
/*
* Setup network listeners. Disallow network reconfig in response to
* routing socket messages if we're using worker processes, since the
* children won't be able to re-open the listener sockets. Hopefully our
* platform has pktinfo support and doesn't need reconfigs.
*/
if (workers == 0) {
retval = loop_setup_routing_socket(ctx, NULL, kdc_progname);
if (retval) {
kdc_err(kcontext, retval, _("while initializing routing socket"));
finish_realms();
return 1;
}
retval = loop_setup_signals(ctx, NULL, reset_for_hangup);
if (retval) {
kdc_err(kcontext, retval, _("while initializing signal handlers"));
finish_realms();
return 1;
}
}
if ((retval = loop_setup_network(ctx, NULL, kdc_progname))) {
net_init_error:
kdc_err(kcontext, retval, _("while initializing network"));
finish_realms();
return 1;
}
if (!nofork && daemon(0, 0)) {
kdc_err(kcontext, errno, _("while detaching from tty"));
finish_realms();
return 1;
}
if (pid_file != NULL) {
retval = write_pid_file(pid_file);
if (retval) {
kdc_err(kcontext, retval, _("while creating PID file"));
finish_realms();
return 1;
}
}
if (workers > 0) {
finish_realms();
retval = create_workers(ctx, workers);
if (retval) {
kdc_err(kcontext, errno, _("creating worker processes"));
return 1;
}
/* We get here only in a worker child process; re-initialize realms. */
initialize_realms(kcontext, argc, argv);
}
krb5_klog_syslog(LOG_INFO, _("commencing operation"));
if (nofork)
fprintf(stderr, _("%s: starting...\n"), kdc_progname);
verto_run(ctx);
loop_free(ctx);
krb5_klog_syslog(LOG_INFO, _("shutting down"));
unload_preauth_plugins(kcontext);
unload_authdata_plugins(kcontext);
krb5_klog_close(kdc_context);
finish_realms();
if (kdc_realmlist)
free(kdc_realmlist);
#ifndef NOCACHE
kdc_free_lookaside(kcontext);
#endif
krb5_free_context(kcontext);
return errout;
}
evLoop *main_loop () {
if (gLoop == NULL) gLoop = loop_init();
return gLoop;
}
int main(int argc, char **argv)
{
krb5_error_code retval;
krb5_context kcontext;
kdc_realm_t *realm;
verto_ctx *ctx;
int tcp_listen_backlog;
int errout = 0;
int i;
setlocale(LC_ALL, "");
if (strrchr(argv[0], '/'))
argv[0] = strrchr(argv[0], '/')+1;
shandle.kdc_realmlist = malloc(sizeof(kdc_realm_t *) *
KRB5_KDC_MAX_REALMS);
if (shandle.kdc_realmlist == NULL) {
fprintf(stderr, _("%s: cannot get memory for realm list\n"), argv[0]);
exit(1);
}
memset(shandle.kdc_realmlist, 0,
(size_t) (sizeof(kdc_realm_t *) * KRB5_KDC_MAX_REALMS));
/*
* A note about Kerberos contexts: This context, "kcontext", is used
* for the KDC operations, i.e. setup, network connection and error
* reporting. The per-realm operations use the "realm_context"
* associated with each realm.
*/
retval = krb5int_init_context_kdc(&kcontext);
if (retval) {
com_err(argv[0], retval, _("while initializing krb5"));
exit(1);
}
krb5_klog_init(kcontext, "kdc", argv[0], 1);
shandle.kdc_err_context = kcontext;
kdc_progname = argv[0];
/* N.B.: After this point, com_err sends output to the KDC log
file, and not to stderr. We use the kdc_err wrapper around
com_err to ensure that the error state exists in the context
known to the krb5_klog callback. */
initialize_kdc5_error_table();
/*
* Scan through the argument list
*/
initialize_realms(kcontext, argc, argv, &tcp_listen_backlog);
#ifndef NOCACHE
retval = kdc_init_lookaside(kcontext);
if (retval) {
kdc_err(kcontext, retval, _("while initializing lookaside cache"));
finish_realms();
return 1;
}
#endif
ctx = loop_init(VERTO_EV_TYPE_NONE);
if (!ctx) {
kdc_err(kcontext, ENOMEM, _("while creating main loop"));
finish_realms();
return 1;
}
load_preauth_plugins(&shandle, kcontext, ctx);
load_authdata_plugins(kcontext);
retval = setup_sam();
if (retval) {
kdc_err(kcontext, retval, _("while initializing SAM"));
finish_realms();
return 1;
}
/* Add each realm's listener addresses to the loop. */
for (i = 0; i < shandle.kdc_numrealms; i++) {
realm = shandle.kdc_realmlist[i];
if (*realm->realm_listen != '\0') {
retval = loop_add_udp_address(KRB5_DEFAULT_PORT,
realm->realm_listen);
if (retval)
goto net_init_error;
}
if (*realm->realm_tcp_listen != '\0') {
retval = loop_add_tcp_address(KRB5_DEFAULT_PORT,
realm->realm_tcp_listen);
if (retval)
goto net_init_error;
}
}
if (workers == 0) {
retval = loop_setup_signals(ctx, &shandle, reset_for_hangup);
if (retval) {
kdc_err(kcontext, retval, _("while initializing signal handlers"));
finish_realms();
return 1;
}
}
if ((retval = loop_setup_network(ctx, &shandle, kdc_progname,
tcp_listen_backlog))) {
net_init_error:
kdc_err(kcontext, retval, _("while initializing network"));
finish_realms();
return 1;
}
if (!nofork && daemon(0, 0)) {
kdc_err(kcontext, errno, _("while detaching from tty"));
finish_realms();
return 1;
}
if (pid_file != NULL) {
retval = write_pid_file(pid_file);
if (retval) {
kdc_err(kcontext, retval, _("while creating PID file"));
finish_realms();
return 1;
}
}
if (workers > 0) {
finish_realms();
retval = create_workers(ctx, workers);
if (retval) {
kdc_err(kcontext, errno, _("creating worker processes"));
return 1;
}
/* We get here only in a worker child process; re-initialize realms. */
initialize_realms(kcontext, argc, argv, NULL);
}
/* Initialize audit system and audit KDC startup. */
retval = load_audit_modules(kcontext);
if (retval) {
kdc_err(kcontext, retval, _("while loading audit plugin module(s)"));
finish_realms();
return 1;
}
krb5_klog_syslog(LOG_INFO, _("commencing operation"));
if (nofork)
fprintf(stderr, _("%s: starting...\n"), kdc_progname);
kau_kdc_start(kcontext, TRUE);
verto_run(ctx);
loop_free(ctx);
kau_kdc_stop(kcontext, TRUE);
krb5_klog_syslog(LOG_INFO, _("shutting down"));
unload_preauth_plugins(kcontext);
unload_authdata_plugins(kcontext);
unload_audit_modules(kcontext);
krb5_klog_close(kcontext);
finish_realms();
if (shandle.kdc_realmlist)
free(shandle.kdc_realmlist);
#ifndef NOCACHE
kdc_free_lookaside(kcontext);
#endif
krb5_free_context(kcontext);
return errout;
}
int main(int argc, char* argv[])
{
loop_handle * hd = &global_handle;
dvs_thread thread_in;
dvs_thread thread_out;
int res = TRUE;
int c;
memset(hd, 0, sizeof(loop_handle));
hd->running = TRUE;
hd->ndelay = 4;
while(--argc) {
argv++; // skip progamname
if(**argv == '-') {
c = tolower(*++*argv); // get option character
++*argv;
if(**argv == '=') ++*argv; // skip equalsign
if(**argv == ' ') ++*argv; // skip space
switch(c) {
case '2':
hd->buse2cards = TRUE;
break;
case 'a':
hd->baudioonly = TRUE;
break;
case 'b':
hd->bottom2top = TRUE; // flipping by using bottom2top
break;
case 'd':
hd->ndelay = atoi(*argv);
break;
case 'f':
hd->bfieldbased = TRUE;
break;
case 'v':
hd->bvideoonly = TRUE;
break;
case 'x':
hd->bverbose = TRUE;
break;
case 'p':
hd->banc = TRUE;
break;
case 'q':
hd->bancstreamer = TRUE;
break;
default:
res = usage();
}
} else {
res = usage();
}
}
if(hd->banc && hd->bancstreamer) {
printf("Parameter for anc overrides anc streamer.\n");
hd->bancstreamer = FALSE;
}
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
if(res) {
res = loop_init(hd);
}
if(res) {
if(!dvs_thread_create(&thread_in, loop_in, hd, &hd->finish)) {
printf("Creating input thread failed.\n");
res = FALSE;
}
}
if(res) {
if(!dvs_thread_create(&thread_out, loop_out, hd, &hd->finish)) {
printf("Creating output thread failed.\n");
res = FALSE;
}
}
if(res) {
do {
if(hd->bplayback) {
printf("playback mode\n");
} else {
printf("loop-through mode\n");
}
c = getc(stdin);
hd->bplayback = !hd->bplayback;
} while (hd->running);
}
dvs_cond_broadcast(&hd->common.ready, &hd->common.lock, FALSE);
dvs_thread_exitcode(&thread_in, &hd->finish);
dvs_thread_exitcode(&thread_out, &hd->finish);
loop_exit(hd);
signal(SIGTERM, NULL);
signal(SIGINT, NULL);
return (res == TRUE) ? 0 : 1;
}
