int
main (int argc, char argv, char env)
{
int a;
setjmp (0);
argc = a = argc;
reader_loop ();
return 0;
}
int main(int argc, char **argv)
{
struct cmdline_args args = {0};
int ret = 0;
opdb_reset();
ctrlc_init();
args.devarg.vcc_mv = 3000;
args.devarg.requested_serial = NULL;
if (parse_cmdline_args(argc, argv, &args) < 0)
return -1;
if (sockets_init() < 0)
return -1;
printc_dbg("%s\n", version_text);
if (setup_driver(&args) < 0) {
sockets_exit();
return -1;
}
simio_init();
if (!args.no_rc)
process_rc_file();
/* Process commands */
if (optind < argc) {
while (optind < argc) {
if (process_command(argv[optind++]) < 0) {
ret = -1;
break;
}
}
} else {
reader_loop();
}
simio_exit();
stab_exit();
device_destroy();
sockets_exit();
return ret;
}
int main(int argc, char *argv[])
{
Event event;
Reader reader;
/* Init struct */
clear_event(&event);
reader_init(&reader, argv[1]);
evh_register_handler(&reader, &lostRecordsHandler);
/*
evh_register_handler(&reader, &backInflightQueueBlockedHandler);
evh_register_handler(&reader, &backInflightQueueUnblockedHandler);
evh_register_handler(&reader, &frontSharedRingQueueBlockedHandler);
evh_register_handler(&reader, &frontSharedRingQueueUnblockedHandler);
evh_register_handler(&reader, &frontGrantQueueBlockedHandler);
evh_register_handler(&reader, &frontGrantQueueUnblockedHandler);
*/
evh_register_handler(&reader, &frontRequestQueueBlockedHandler);
evh_register_handler(&reader, &frontRequestQueueUnblockedHandler);
evh_register_handler(&reader, &backRequestQueueBlockedHandler);
evh_register_handler(&reader, &backRequestQueueUnblockedHandler);
evh_register_handler(&reader, &frontSharedRingRespQueueBlockedHandler);
evh_register_handler(&reader, &frontSharedRingRespQueueUnblockedHandler);
evh_register_handler(&reader, &backRequestInterruptSendHandler);
evh_register_handler(&reader, &backRequestInterruptReceiveHandler);
evh_register_handler(&reader, &backResponseInterruptSendHandler);
evh_register_handler(&reader, &backResponseInterruptReceiveHandler);
reader_loop(&reader);
reader_exit(&reader);
return 0;
}
int main(int argc, char *argv[])
{
Event event;
Reader reader;
/* Init struct */
clear_event(&event);
reader_init(&reader, argv[1]);
evh_register_handler(&reader, &lostRecordsHandler);
evh_register_handler(&reader, &exitToXenHandler);
evh_register_handler(&reader, &exitToGuestHandler);
reader_loop(&reader);
reader_exit(&reader);
return 0;
}
int main(int argc, char *argv[])
{
Event event;
Reader reader;
/* Init struct */
clear_event(&event);
reader_init(&reader, argv[1]);
evh_register_handler(&reader, &switchInfprevHandler);
evh_register_handler(&reader, &switchInfnextHandler);
evh_register_handler(&reader, &switchSchedHandler);
evh_register_handler(&reader, &domainWakeHandler);
evh_register_handler(&reader, &lostRecordsHandler);
reader_loop(&reader);
reader_exit(&reader);
return 0;
}
int main(int argc, char **argv) {
bool noCurses = false;
char *slash = strrchr(argv[0], '/');
debug = true;
if(!strcmp(slash ? slash + 1 : argv[0], "reader"))
noCurses = true;
load_dump(&dump, argv[1], argv[2], argv[3], argv[4]);
article_file_str = argv[1];
if(!noCurses) {
handler = search_handler;
curses_loop();
} else {
debug("calling reader_loop");
reader_loop();
}
return 0;
}
int main(int argc, char *argv[])
{
Event event;
Reader reader;
/* Init struct */
clear_event(&event);
reader_init(&reader, argv[1]);
evh_register_handler(&reader, &numEventsHandler);
evh_register_handler(&reader, &numExceptionsHandler);
evh_register_handler(&reader, &numExceptionsInXenHandler);
evh_register_handler(&reader, &numInterruptsHandler);
evh_register_handler(&reader, &numInterruptsInXenHandler);
evh_register_handler(&reader, &numHypercallsHandler);
evh_register_handler(&reader, &lostRecordsHandler);
reader_loop(&reader);
reader_exit(&reader);
return 0;
}
int
main (int argc, char **argv)
{
gpg_error_t err;
struct sock_ctx_s fd;
gsti_ctx_t ctx;
if (argc)
{
argc--;
argv++;
}
/* Initialize our local context object. */
memset (&fd, 0, sizeof fd);
/* Make sure we get secure memory. */
gsti_control (GSTI_SECMEM_INIT);
/* Initialize a GSTI context. */
err = gsti_init (&ctx);
log_rc (err, "init");
/* This context should be logged at debug level. */
gsti_set_log_level (ctx, GSTI_LOG_DEBUG);
/* Register our host key. */
err = gsti_set_hostkey (ctx, SECKEY);
log_rc (err, "set_hostkey");
/* Register our read/write functions. */
gsti_set_packet_handler_cb (ctx, mypkt_handler, 0);
gsti_set_writefnc (ctx, mywrite, &fd);
/* Register our auth callback function */
gsti_set_auth_callback (ctx, my_auth_cb, NULL);
/* Set simple banner message */
gsti_set_auth_banner (ctx, "Eddie lives somewhere in time...", 0);
#if 0
err = gsti_set_service (ctx, "[email protected],[email protected]");
log_err (err, "set-service");
#endif
/* Wait for a client to connect. */
wait_connection (&fd.listen_fd, &fd.conn_fd);
/* Fire up the engine. */
err = gsti_start (ctx);
log_rc (err, "start");
/* Process incoming data. */
err = reader_loop (&fd, ctx);
log_rc (err, "reader_loop");
/* Release the context. */
gsti_deinit (ctx);
/* And the secure memory. */
gsti_control (GSTI_SECMEM_RELEASE);
return 0;
}
int
main (int argc, char **argv)
{
struct sock_ctx_s fd;
gpg_error_t err;
gsti_ctx_t ctx;
struct gsti_pktdesc_s pkt;
unsigned short c_prefs[8] = {0};
unsigned short h_prefs[4] = {0};
int i;
int ready = 0;
if (argc)
{
argc--;
argv++;
}
/* Initialize our local context object. */
memset (&fd, 0, sizeof fd);
/* Make sure we get secure memory. */
gsti_control (GSTI_SECMEM_INIT);
/* We are single-threaded, thus no locking is required. */
gsti_control (GSTI_DISABLE_LOCKING);
/* Initialize a GSTI context. */
err = gsti_init (&ctx);
log_rc (err, "init");
/* This context should be logged at debug level. */
gsti_set_log_level (ctx, GSTI_LOG_DEBUG);
/* Enable DH group exchange */
/*gsti_set_kex_dhgex (ctx, 1024, 1024, 4096);*/
/* Set personal kex preferences */
c_prefs[0] = GSTI_CIPHER_CAST128;
c_prefs[1] = GSTI_CIPHER_SERPENT128;
c_prefs[2] = 0;
err = gsti_set_kex_prefs (ctx, GSTI_PREFS_ENCR, c_prefs, 2);
log_rc (err, "set_kex_prefs (encr)");
h_prefs[0] = GSTI_HMAC_SHA1;
h_prefs[1] = GSTI_HMAC_RMD160;
h_prefs[2] = GSTI_HMAC_MD5;
h_prefs[3] = 0;
err = gsti_set_kex_prefs (ctx, GSTI_PREFS_HMAC, h_prefs, 3);
log_rc (err, "set_kex_prefs (hmac)");
/* Register our read/write functions. */
gsti_set_packet_handler_cb (ctx, mypkt_handler, 0);
gsti_set_writefnc (ctx, mywrite, &fd);
gsti_set_control_cb (ctx, myctrl_handler, &ready);
/* Register our auth callback */
gsti_set_auth_callback (ctx, my_auth_cb, NULL);
/* Register a key and a user. */
err = gsti_set_client_key (ctx, SECKEY);
log_rc (err, "set_client_key");
err = gsti_set_client_user (ctx, "twoaday");
/*err = gsti_set_client_user (ctx, "root");*/
log_rc (err, "set_client_user");
#if 0
rc = gsti_set_service (ctx, "*****@*****.**");
log_rc (rc, "set-service");
#endif
/* Create a connection to the host given on the command line or to
localhost if no args are given. */
make_connection (&fd.conn_fd, argc ? *argv : "localhost");
/* Fire up the engine. */
err = gsti_start (ctx);
log_rc (err, "start");
/* Process incoming data until we are ready. */
err = reader_loop (&fd, ctx, &ready);
log_rc (err, "reader_loop");
/* Send 2 simple data packets. */
for (i = 0; i < 2; i++)
{
memset (&pkt, 0, sizeof pkt);
pkt.data = ((const unsigned char*)
"\xf0\x01\x00\x00\x00\x04" "hallo" "\x00\x00\x00\x00");
pkt.datalen = 15;
err = gsti_put_packet (ctx, &pkt);
log_rc (err, "put_packet");
err = gsti_put_packet (ctx, NULL);
log_rc (err, "flush_packet");
printf ("seqno %lu\n", pkt.seqno);
}
/* Release the context. */
gsti_deinit (ctx);
/* And the secure memory. */
gsti_control (GSTI_SECMEM_RELEASE);
return 0;
}
int main(int argc, char **argv)
{
struct cmdline_args args = {0};
int ret = 0;
setvbuf(stderr, NULL, _IOFBF, 0);
setvbuf(stdout, NULL, _IOFBF, 0);
opdb_reset();
ctrlc_init();
args.devarg.vcc_mv = 3000;
args.devarg.requested_serial = NULL;
if (parse_cmdline_args(argc, argv, &args) < 0)
goto fail_parse;
if (args.flags & OPT_EMBEDDED)
input_module = &input_async;
if (input_module->init() < 0)
goto fail_input;
output_set_embedded(args.flags & OPT_EMBEDDED);
if (sockets_init() < 0) {
ret = -1;
goto fail_sockets;
}
printc_dbg("%s", version_text);
printc_dbg("%s\n", chipinfo_copyright());
if (setup_driver(&args) < 0) {
ret = -1;
goto fail_driver;
}
if (device_probe_id(device_default, args.devarg.forced_chip_id) < 0)
printc_err("warning: device ID probe failed\n");
simio_init();
if (!(args.flags & OPT_NO_RC))
process_rc_file(args.alt_config);
/* Process commands */
if (optind < argc) {
while (optind < argc) {
if (process_command(argv[optind++]) < 0) {
ret = -1;
break;
}
}
} else {
reader_loop();
}
simio_exit();
device_destroy();
stab_exit();
fail_driver:
sockets_exit();
fail_sockets:
input_module->exit();
fail_input:
fail_parse:
/* We need to do this on Windows, because in embedded mode we
* may still have a running background thread for input. If so,
* returning from main() won't cause the process to terminate.
*/
#if defined(__CYGWIN__)
cygwin_internal(CW_EXIT_PROCESS,
(ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE, 1);
#elif defined(__Windows__)
ExitProcess(ret);
#endif
return ret;
}
