int main(int argc, char * argv[])
{
DEBUG_INIT(NULL);
volatile struct exception exp;
TRY_CATCH(exp, MASK_ALL) {
wrapper_main(argc, argv);
}
GType
gst_vdp_output_buffer_get_type (void)
{
static GType _gst_vdp_output_buffer_type;
if (G_UNLIKELY (_gst_vdp_output_buffer_type == 0)) {
static const GTypeInfo info = {
sizeof (GstBufferClass),
NULL,
NULL,
gst_vdp_output_buffer_class_init,
NULL,
NULL,
sizeof (GstVdpOutputBuffer),
0,
(GInstanceInitFunc) gst_vdp_output_buffer_init,
NULL
};
_gst_vdp_output_buffer_type = g_type_register_static (GST_TYPE_BUFFER,
"GstVdpOutputBuffer", &info, 0);
DEBUG_INIT ();
}
return _gst_vdp_output_buffer_type;
}
int main()
{
DDRA = 0xff;
DDRB = 0x00;
PORTB = 0x00;
DDRB |= _BV(EMPH_BIT);
DEBUG_INIT();
timer_init();
sei();
uint8_t leds = 1;
for (;;) {
PORTA = leds;
delayms(250);
delayms(250);
if (!(leds <<= 1))
leds++;
service_ide();
if (SDCARD_INSERTED)
handle_sdcard();
}
return 0;
}
GType
gst_vdp_mpeg_frame_get_type (void)
{
static GType _gst_vdp_mpeg_frame_type = 0;
if (G_UNLIKELY (_gst_vdp_mpeg_frame_type == 0)) {
static const GTypeInfo info = {
sizeof (GstVdpMpegFrameClass),
NULL,
NULL,
gst_vdp_mpeg_frame_class_init,
NULL,
NULL,
sizeof (GstVdpMpegFrame),
0,
(GInstanceInitFunc) gst_vdp_mpeg_frame_init,
NULL
};
_gst_vdp_mpeg_frame_type = g_type_register_static (GST_TYPE_VIDEO_FRAME,
"GstVdpMpegFrame", &info, 0);
DEBUG_INIT ();
}
return _gst_vdp_mpeg_frame_type;
}
int main(int argc, const char *argv[])
{
int opt;
poptContext pc;
struct main_context *main_ctx;
int ret;
uid_t uid;
gid_t gid;
struct poptOption long_options[] = {
POPT_AUTOHELP
SSSD_MAIN_OPTS
SSSD_SERVER_OPTS(uid, gid)
POPT_TABLEEND
};
/* Set debug level to invalid value so we can decide if -d 0 was used. */
debug_level = SSSDBG_INVALID;
umask(DFL_RSP_UMASK);
pc = poptGetContext(argv[0], argc, argv, long_options, 0);
while((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
default:
fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
return 1;
}
}
poptFreeContext(pc);
DEBUG_INIT(debug_level);
/* set up things like debug, signals, daemonization, etc... */
debug_log_file = "sssd_pac";
ret = server_setup("sssd[pac]", 0, uid, gid,
CONFDB_PAC_CONF_ENTRY, &main_ctx);
if (ret != EOK) return 2;
ret = die_if_parent_died();
if (ret != EOK) {
/* This is not fatal, don't return */
DEBUG(SSSDBG_OP_FAILURE, "Could not set up to exit when parent process does\n");
}
ret = pac_process_init(main_ctx,
main_ctx->event_ctx,
main_ctx->confdb_ctx);
if (ret != EOK) return 3;
/* loop on main */
server_loop(main_ctx);
return 0;
}
int main(int argc, const char *argv[])
{
int rv;
int no_cleanup = 0;
poptContext pc;
int opt;
struct poptOption long_options[] = {
POPT_AUTOHELP
SSSD_DEBUG_OPTS
{"no-cleanup", 'n', POPT_ARG_NONE, &no_cleanup, 0,
_("Do not delete the test database after a test run"), NULL },
POPT_TABLEEND
};
const UnitTest tests[] = {
/* Utility functions unit test */
unit_test(dyndns_test_get_ifaddr),
/* Dynamic DNS update unit tests*/
unit_test_setup_teardown(dyndns_test_ok,
dyndns_test_setup, dyndns_test_teardown),
unit_test_setup_teardown(dyndns_test_error,
dyndns_test_setup, dyndns_test_teardown),
unit_test_setup_teardown(dyndns_test_timeout,
dyndns_test_setup, dyndns_test_teardown),
unit_test_setup_teardown(dyndns_test_interval,
dyndns_test_setup, dyndns_test_teardown),
};
/* Set debug level to invalid value so we can deside if -d 0 was used. */
debug_level = SSSDBG_INVALID;
pc = poptGetContext(argv[0], argc, argv, long_options, 0);
while((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
default:
fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
return 1;
}
}
poptFreeContext(pc);
DEBUG_INIT(debug_level);
/* Even though normally the tests should clean up after themselves
* they might not after a failed run. Remove the old db to be sure */
tests_set_cwd();
test_dom_suite_cleanup(TESTS_PATH, TEST_CONF_DB, TEST_SYSDB_FILE);
test_dom_suite_setup(TESTS_PATH);
rv = run_tests(tests);
if (rv == 0 && !no_cleanup) {
test_dom_suite_cleanup(TESTS_PATH, TEST_CONF_DB, TEST_SYSDB_FILE);
}
return rv;
}
int main (void){
DEBUG_INIT();
cli_rx = (cli_rx_fpt)uart0_getc;
cli_tx = (cli_tx_fpt)uart0_putc;
for(;;){
cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
cli_putstr(algo_name);
cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
cmd_interface(cmdlist);
}
}
int main (void){
DEBUG_INIT();
uart_putstr("\r\n");
cli_rx = uart_getc;
cli_tx = uart_putc;
shavs_algolist=(hfdesc_t**)algolist;
shavs_algo=(hfdesc_t*)&sha256_desc;
for(;;){
uart_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
uart_putstr(algo_name);
uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
cmd_interface(cmdlist);
}
}
int main (void){
DEBUG_INIT();
cli_rx = (cli_rx_fpt)uart0_getc;
cli_tx = (cli_tx_fpt)uart0_putc;
cmacvs_algolist=(bcdesc_t**)algolist;
cmacvs_algo=(bcdesc_t*)&aes128_desc;
for(;;){
cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
cli_putstr(algo_name);
cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
cmd_interface(cmdlist);
}
}
GType
gst_vdp_sink_get_type (void)
{
static GType vdp_sink_type = 0;
if (!vdp_sink_type) {
static const GTypeInfo vdp_sink_info = {
sizeof (VdpSinkClass),
gst_vdp_sink_base_init,
NULL,
(GClassInitFunc) gst_vdp_sink_class_init,
NULL,
NULL,
sizeof (VdpSink),
0,
(GInstanceInitFunc) gst_vdp_sink_init,
};
static const GInterfaceInfo iface_info = {
(GInterfaceInitFunc) gst_vdp_sink_interface_init,
NULL,
NULL,
};
static const GInterfaceInfo navigation_info = {
(GInterfaceInitFunc) gst_vdp_sink_navigation_init,
NULL,
NULL,
};
static const GInterfaceInfo overlay_info = {
(GInterfaceInitFunc) gst_vdp_sink_xoverlay_init,
NULL,
NULL,
};
vdp_sink_type = g_type_register_static (GST_TYPE_VIDEO_SINK,
"VdpSink", &vdp_sink_info, 0);
g_type_add_interface_static (vdp_sink_type, GST_TYPE_IMPLEMENTS_INTERFACE,
&iface_info);
g_type_add_interface_static (vdp_sink_type, GST_TYPE_NAVIGATION,
&navigation_info);
g_type_add_interface_static (vdp_sink_type, GST_TYPE_X_OVERLAY,
&overlay_info);
}
DEBUG_INIT ();
return vdp_sink_type;
}
int main(void)
{
//initialize_memory();
DEBUG_INIT();
#if ! defined(USE_SCHEDULE)
bus_init();
ifs_init();
#endif /* USE_SCHEDULE */
ttpa_setstate(TTPA_STATE_UNSYNC);
while(1) {
#if defined(USE_SCHEDULE)
schedule();
#endif
}
return 0;
}
int main(void)
{
int i;
DEBUG_INIT("debug_test");
PAF;
for(i=0;i<100;i++)
test1(i);
for(i=0;i<100;i++)
test2(i);
PIF;
exit(0);
}
void Inicializer::initTop() {
bool exclusions[MAXT][MAXT] = {false};
readTopoFile(exclusions); // EXCLUDE LOADED CORRECTLY 7.8. 2015
fprintf (stdout, "\nTopology succesfully read. Generating pair interactions...\n");
//fill ia_params combinations and topology parameters
topo.genParamPairs(exclusions);
topo.genTopoParams();
setParticlesParams();
initSwitchList();
initGroupLists();
conf->sysvolume = 0;
for (unsigned int i=0; i<conf->pvec.size(); i++)
conf->sysvolume += topo.ia_params[conf->pvec[i].type][conf->pvec[i].type].volume;
if(sim->nGrandCanon != 0) {
bool existGrand = false;
int i=0;
while(topo.moleculeParam[i].name != NULL) {
if(topo.moleculeParam[i].activity != -1.0 )
existGrand = true;
i++;
}
if(!existGrand) {
cout << "In options nGrandCanon != 0, but no activity set for any species in top.init" << endl;
exit(1);
}
}
DEBUG_INIT("Finished with reading the topology");
#ifdef ENABLE_MPI // Parallel tempering check
// probability to switch replicas = exp ( -0.5 * dT*dT * N / (1 + dT) )
printf("Probability to switch replicas is roughly: %f\n",exp(-0.5 * conf->pvec.size() * sim->dtemp * sim->dtemp / (1.0 + sim->dtemp)) );
#endif
topDealoc();
}
int main (void){
DEBUG_INIT();
cli_rx = (cli_rx_fpt)uart0_getc;
cli_tx = (cli_tx_fpt)uart0_putc;
shavs_algolist=(hfdesc_t**)algolist;
shavs_algo=(hfdesc_t*)&echo256_desc;
for(;;){
cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
cli_putstr(algo_name);
cli_putstr_P(PSTR("; "));
cli_putstr(__DATE__);
cli_putstr_P(PSTR(" "));
cli_putstr(__TIME__);
cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
cmd_interface(cmdlist);
}
}
int
main(int argc, char * argv[])
{
char * target_fn = NULL;
DEBUG_INIT(NULL);
opts = parse_args(argc, argv);
assert(opts != NULL);
target_fn = argv[opts->cmd_idx];
assert(opts->cmd_idx < argc);
/* check ckpt file and target file */
struct stat s;
if (stat(opts->ckpt_fn, &s) != 0) {
SYS_ERROR("file %s doesn't exists\n", opts->ckpt_fn);
return -1;
}
if (!S_ISREG(s.st_mode)) {
SYS_ERROR("file %s not a regular file\n", opts->ckpt_fn);
return -1;
}
if (stat(target_fn, &s) != 0) {
SYS_ERROR("file %s doesn't exists\n", target_fn);
return -1;
}
if (!S_ISREG(s.st_mode)) {
SYS_ERROR("file %s not a regular file\n", target_fn);
return -1;
}
/* start */
volatile struct exception exp;
TRY_CATCH(exp, MASK_ALL) {
cf = load_ckpt_file(opts->ckpt_fn);
gdbloader_main(target_fn);
close_ckpt_file(cf);
ptrace_detach(TRUE);
} CATCH (exp) {
int main(int argc, const char *argv[])
{
int opt;
poptContext pc;
int number_failed;
struct poptOption long_options[] = {
POPT_AUTOHELP
{ "debug-level", 'd', POPT_ARG_INT, &debug_level, 0, "Set debug level", NULL },
POPT_TABLEEND
};
/* Set debug level to invalid value so we can deside if -d 0 was used. */
debug_level = SSSDBG_INVALID;
pc = poptGetContext(argv[0], argc, argv, long_options, 0);
while((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
default:
fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
return 1;
}
}
poptFreeContext(pc);
DEBUG_INIT(debug_level);
tests_set_cwd();
Suite *s = crypto_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_ENV);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
int main(int argc, const char **argv)
{
int ret = EXIT_SUCCESS;
struct tools_ctx *tctx = NULL;
const char *pc_username = NULL;
int pc_debug = SSSDBG_DEFAULT;
int pc_remove = 0;
int pc_force = 0;
int pc_kick = 0;
poptContext pc = NULL;
struct poptOption long_options[] = {
POPT_AUTOHELP
{ "debug", '\0', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &pc_debug,
0, _("The debug level to run with"), NULL },
{ "remove", 'r', POPT_ARG_NONE, NULL, 'r',
_("Remove home directory and mail spool"), NULL },
{ "no-remove", 'R', POPT_ARG_NONE, NULL, 'R',
_("Do not remove home directory and mail spool"), NULL },
{ "force", 'f', POPT_ARG_NONE, NULL, 'f',
_("Force removal of files not owned by the user"), NULL },
{ "kick", 'k', POPT_ARG_NONE, NULL, 'k',
_("Kill users' processes before removing him"), NULL },
POPT_TABLEEND
};
debug_prg_name = argv[0];
ret = set_locale();
if (ret != EOK) {
DEBUG(1, ("set_locale failed (%d): %s\n", ret, strerror(ret)));
ERROR("Error setting the locale\n");
ret = EXIT_FAILURE;
goto fini;
}
/* parse parameters */
pc = poptGetContext(NULL, argc, argv, long_options, 0);
poptSetOtherOptionHelp(pc, "USERNAME");
while ((ret = poptGetNextOpt(pc)) > 0) {
switch (ret) {
case 'r':
pc_remove = DO_REMOVE_HOME;
break;
case 'R':
pc_remove = DO_NOT_REMOVE_HOME;
break;
case 'f':
pc_force = DO_FORCE_REMOVAL;
break;
case 'k':
pc_kick = 1;
break;
}
}
DEBUG_INIT(pc_debug);
if (ret != -1) {
BAD_POPT_PARAMS(pc, poptStrerror(ret), ret, fini);
}
pc_username = poptGetArg(pc);
if (pc_username == NULL) {
BAD_POPT_PARAMS(pc, _("Specify user to delete\n"), ret, fini);
}
CHECK_ROOT(ret, debug_prg_name);
ret = init_sss_tools(&tctx);
if (ret != EOK) {
DEBUG(1, ("init_sss_tools failed (%d): %s\n", ret, strerror(ret)));
if (ret == ENOENT) {
ERROR("Error initializing the tools - no local domain\n");
} else {
ERROR("Error initializing the tools\n");
}
ret = EXIT_FAILURE;
goto fini;
}
/* if the domain was not given as part of FQDN, default to local domain */
ret = parse_name_domain(tctx, pc_username);
if (ret != EOK) {
ERROR("Invalid domain specified in FQDN\n");
ret = EXIT_FAILURE;
goto fini;
}
/*
* Fills in defaults for ops_ctx user did not specify.
*/
ret = userdel_defaults(tctx, tctx->confdb, tctx->octx, pc_remove);
if (ret != EOK) {
ERROR("Cannot set default values\n");
ret = EXIT_FAILURE;
goto fini;
}
ret = sysdb_getpwnam_sync(tctx,
tctx->sysdb,
tctx->octx->name,
tctx->octx);
if (ret != EOK) {
/* Error message will be printed in the switch */
goto done;
}
if ((tctx->octx->uid < tctx->local->id_min) ||
(tctx->local->id_max && tctx->octx->uid > tctx->local->id_max)) {
ERROR("User %1$s is outside the defined ID range for domain\n",
tctx->octx->name);
ret = EXIT_FAILURE;
goto fini;
}
if (pc_kick) {
ret = kick_user(tctx);
if (ret != EOK) {
tctx->error = ret;
goto done;
}
}
/* userdel */
ret = userdel(tctx, tctx->sysdb, tctx->octx);
if (ret != EOK) {
goto done;
}
/* Set SELinux login context - must be done after transaction is done
* b/c libselinux calls getpwnam */
ret = del_seuser(tctx->octx->name);
if (ret != EOK) {
ERROR("Cannot reset SELinux login context\n");
ret = EXIT_FAILURE;
goto fini;
}
if (!pc_kick) {
ret = is_logged_in(tctx, tctx->octx->uid);
switch(ret) {
case ENOENT:
break;
case EOK:
ERROR("WARNING: The user (uid %1$lu) was still logged in when "
"deleted.\n", (unsigned long) tctx->octx->uid);
break;
case ENOSYS:
ERROR("Cannot determine if the user was logged in on this "
"platform");
break;
default:
ERROR("Error while checking if the user was logged in\n");
break;
}
}
ret = run_userdel_cmd(tctx);
if (ret != EOK) {
ERROR("The post-delete command failed: %1$s\n", strerror(ret));
goto fini;
}
/* Delete user from memory cache */
ret = sss_mc_refresh_user(pc_username);
if (ret != EOK) {
ERROR("NSS request failed (%1$d). Entry might remain in memory "
"cache.\n", ret);
/* Nothing we can do about it */
}
if (tctx->octx->remove_homedir) {
ret = remove_homedir(tctx,
tctx->octx->home,
tctx->octx->maildir,
tctx->octx->name,
tctx->octx->uid,
pc_force);
if (ret == EPERM) {
ERROR("Not removing home dir - not owned by user\n");
} else if (ret != EOK) {
ERROR("Cannot remove homedir: %1$s\n", strerror(ret));
ret = EXIT_FAILURE;
goto fini;
}
}
ret = EOK;
done:
if (ret) {
DEBUG(1, ("sysdb operation failed (%d)[%s]\n", ret, strerror(ret)));
switch (ret) {
case ENOENT:
ERROR("No such user in local domain. "
"Removing users only allowed in local domain.\n");
break;
default:
ERROR("Internal error. Could not remove user.\n");
break;
}
ret = EXIT_FAILURE;
goto fini;
}
ret = EXIT_SUCCESS;
fini:
talloc_free(tctx);
poptFreeContext(pc);
exit(ret);
}
int main(int argc, char *argv[])
{
/*
* Alloc the global structures
* We can access these structs via the macro in ec_globals.h
*/
globals_alloc();
GBL_PROGRAM = strdup(EC_PROGRAM);
GBL_VERSION = strdup(EC_VERSION);
SAFE_CALLOC(GBL_DEBUG_FILE, strlen(EC_PROGRAM) + strlen("-") + strlen(EC_VERSION) + strlen("_debug.log") + 1, sizeof(char));
sprintf(GBL_DEBUG_FILE, "%s-%s_debug.log", GBL_PROGRAM, EC_VERSION);
DEBUG_INIT();
DEBUG_MSG("main -- here we go !!");
/* initialize the filter mutex */
filter_init_mutex();
/* register the main thread as "init" */
ec_thread_register(EC_PTHREAD_SELF, "init", "initialization phase");
/* activate the signal handler */
signal_handler();
/* ettercap copyright */
fprintf(stdout, "\n" EC_COLOR_BOLD "%s %s" EC_COLOR_END " copyright %s %s\n\n",
GBL_PROGRAM, GBL_VERSION, EC_COPYRIGHT, EC_AUTHORS);
/* getopt related parsing... */
parse_options(argc, argv);
/* check the date */
time_check();
/* load the configuration file */
load_conf();
/*
* get the list of available interfaces
*
* this function will not return if the -I option was
* specified on command line. it will instead print the
* list and exit
*/
capture_getifs();
/* initialize the user interface */
ui_init();
/* initialize the network subsystem */
network_init();
/*
* always disable the kernel ip forwarding (except when reading from file).
* the forwarding will be done by ettercap.
*/
if(!GBL_OPTIONS->read && !GBL_OPTIONS->unoffensive && !GBL_OPTIONS->only_mitm) {
disable_ip_forward();
#ifdef OS_LINUX
if (!GBL_OPTIONS->read)
disable_interface_offload();
#endif
/* binds ports and set redirect for ssl wrapper */
if(GBL_SNIFF->type == SM_UNIFIED && GBL_OPTIONS->ssl_mitm)
ssl_wrap_init();
}
/*
* drop root privileges
* we have already opened the sockets with high privileges
* we don't need anymore root privs.
*/
drop_privs();
/***** !! NO PRIVS AFTER THIS POINT !! *****/
/* load all the plugins */
plugin_load_all();
/* print how many dissectors were loaded */
conf_dissectors();
/* load the mac-fingerprints */
manuf_init();
/* load the tcp-fingerprints */
fingerprint_init();
/* load the services names */
services_init();
/* load http known fileds for user/pass */
http_fields_init();
#ifdef HAVE_EC_LUA
/* Initialize lua */
ec_lua_init();
#endif
/* set the encoding for the UTF-8 visualization */
set_utf8_encoding((u_char*)GBL_CONF->utf8_encoding);
/* print all the buffered messages */
if (GBL_UI->type == UI_TEXT)
USER_MSG("\n");
ui_msg_flush(MSG_ALL);
/**** INITIALIZATION PHASE TERMINATED ****/
/*
* we are interested only in the mitm attack i
* if entered, this function will not return...
*/
if (GBL_OPTIONS->only_mitm)
only_mitm();
/* create the dispatcher thread */
ec_thread_new("top_half", "dispatching module", &top_half, NULL);
/* this thread becomes the UI then displays it */
ec_thread_register(EC_PTHREAD_SELF, GBL_PROGRAM, "the user interface");
ui_start();
/********************************************
* reached only when the UI is shutted down
********************************************/
/* Call all the proper stop methods to ensure
* that no matter what UI was selected, everything is
* turned off gracefully */
clean_exit(0);
return 0; //Never reaches here
}
int
main(int argc, const char *argv[])
{
int opt;
poptContext pc;
int debug_fd = -1;
errno_t ret;
int sysvol_gpt_version;
int result;
TALLOC_CTX *main_ctx = NULL;
uint8_t *buf = NULL;
ssize_t len = 0;
struct input_buffer *ibuf = NULL;
struct response *resp = NULL;
size_t written;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"debug-level", 'd', POPT_ARG_INT, &debug_level, 0,
_("Debug level"), NULL},
{"debug-timestamps", 0, POPT_ARG_INT, &debug_timestamps, 0,
_("Add debug timestamps"), NULL},
{"debug-microseconds", 0, POPT_ARG_INT, &debug_microseconds, 0,
_("Show timestamps with microseconds"), NULL},
{"debug-fd", 0, POPT_ARG_INT, &debug_fd, 0,
_("An open file descriptor for the debug logs"), NULL},
{"debug-to-stderr", 0, POPT_ARG_NONE | POPT_ARGFLAG_DOC_HIDDEN,
&debug_to_stderr, 0,
_("Send the debug output to stderr directly."), NULL },
POPT_TABLEEND
};
/* Set debug level to invalid value so we can decide if -d 0 was used. */
debug_level = SSSDBG_INVALID;
pc = poptGetContext(argv[0], argc, argv, long_options, 0);
while((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
default:
fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
_exit(-1);
}
}
poptFreeContext(pc);
DEBUG_INIT(debug_level);
debug_prg_name = talloc_asprintf(NULL, "[sssd[gpo_child[%d]]]", getpid());
if (debug_prg_name == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, "talloc_asprintf failed.\n");
goto fail;
}
if (debug_fd != -1) {
ret = set_debug_file_from_fd(debug_fd);
if (ret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE, "set_debug_file_from_fd failed.\n");
}
}
DEBUG(SSSDBG_TRACE_FUNC, "gpo_child started.\n");
main_ctx = talloc_new(NULL);
if (main_ctx == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, "talloc_new failed.\n");
talloc_free(discard_const(debug_prg_name));
goto fail;
}
talloc_steal(main_ctx, debug_prg_name);
buf = talloc_size(main_ctx, sizeof(uint8_t)*IN_BUF_SIZE);
if (buf == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, "talloc_size failed.\n");
goto fail;
}
ibuf = talloc_zero(main_ctx, struct input_buffer);
if (ibuf == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, "talloc_zero failed.\n");
goto fail;
}
DEBUG(SSSDBG_TRACE_FUNC, "context initialized\n");
errno = 0;
len = sss_atomic_read_s(STDIN_FILENO, buf, IN_BUF_SIZE);
if (len == -1) {
ret = errno;
DEBUG(SSSDBG_CRIT_FAILURE, "read failed [%d][%s].\n", ret, strerror(ret));
goto fail;
}
close(STDIN_FILENO);
ret = unpack_buffer(buf, len, ibuf);
if (ret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE,
"unpack_buffer failed.[%d][%s].\n", ret, strerror(ret));
goto fail;
}
DEBUG(SSSDBG_TRACE_FUNC, "performing smb operations\n");
result = perform_smb_operations(ibuf->cached_gpt_version,
ibuf->smb_server,
ibuf->smb_share,
ibuf->smb_path,
ibuf->smb_cse_suffix,
&sysvol_gpt_version);
if (result != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE,
"perform_smb_operations failed.[%d][%s].\n",
result, strerror(result));
goto fail;
}
ret = prepare_response(main_ctx, sysvol_gpt_version, result, &resp);
if (ret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE, "prepare_response failed. [%d][%s].\n",
ret, strerror(ret));
goto fail;
}
errno = 0;
written = sss_atomic_write_s(STDOUT_FILENO, resp->buf, resp->size);
if (written == -1) {
ret = errno;
DEBUG(SSSDBG_CRIT_FAILURE, "write failed [%d][%s].\n", ret,
strerror(ret));
goto fail;
}
if (written != resp->size) {
DEBUG(SSSDBG_CRIT_FAILURE, "Expected to write %zu bytes, wrote %zu\n",
resp->size, written);
goto fail;
}
DEBUG(SSSDBG_TRACE_FUNC, "gpo_child completed successfully\n");
close(STDOUT_FILENO);
talloc_free(main_ctx);
return EXIT_SUCCESS;
fail:
DEBUG(SSSDBG_CRIT_FAILURE, "gpo_child failed!\n");
close(STDOUT_FILENO);
talloc_free(main_ctx);
return EXIT_FAILURE;
}
int CHOLMOD(start)
(
cholmod_common *Common
)
{
int k ;
if (Common == NULL)
{
return (FALSE) ;
}
/* ---------------------------------------------------------------------- */
/* user error handling routine */
/* ---------------------------------------------------------------------- */
Common->error_handler = NULL ;
/* ---------------------------------------------------------------------- */
/* integer and numerical types */
/* ---------------------------------------------------------------------- */
Common->itype = ITYPE ;
Common->dtype = DTYPE ;
/* ---------------------------------------------------------------------- */
/* default control parameters */
/* ---------------------------------------------------------------------- */
CHOLMOD(defaults) (Common) ;
Common->try_catch = FALSE ;
/* ---------------------------------------------------------------------- */
/* memory management routines */
/* ---------------------------------------------------------------------- */
/* The user can replace cholmod's memory management routines by redefining
* these function pointers. */
#ifndef NMALLOC
/* stand-alone ANSI C program */
Common->malloc_memory = malloc ;
Common->free_memory = free ;
Common->realloc_memory = realloc ;
Common->calloc_memory = calloc ;
#else
/* no memory manager defined at compile-time; MUST define one at run-time */
Common->malloc_memory = NULL ;
Common->free_memory = NULL ;
Common->realloc_memory = NULL ;
Common->calloc_memory = NULL ;
#endif
/* ---------------------------------------------------------------------- */
/* complex arithmetic routines */
/* ---------------------------------------------------------------------- */
Common->complex_divide = CHOLMOD(divcomplex) ;
Common->hypotenuse = CHOLMOD(hypot) ;
/* ---------------------------------------------------------------------- */
/* print routine */
/* ---------------------------------------------------------------------- */
#ifndef NPRINT
/* stand-alone ANSI C program */
Common->print_function = printf ;
#else
/* printing disabled */
Common->print_function = NULL ;
#endif
/* ---------------------------------------------------------------------- */
/* workspace */
/* ---------------------------------------------------------------------- */
/* This code assumes the workspace held in Common is not initialized. If
* it is, then a memory leak will occur because the pointers are
* overwritten with NULL. */
Common->nrow = 0 ;
Common->mark = EMPTY ;
Common->xworksize = 0 ;
Common->iworksize = 0 ;
Common->Flag = NULL ;
Common->Head = NULL ;
Common->Iwork = NULL ;
Common->Xwork = NULL ;
Common->no_workspace_reallocate = FALSE ;
/* ---------------------------------------------------------------------- */
/* statistics */
/* ---------------------------------------------------------------------- */
/* fl and lnz are computed in cholmod_analyze and cholmod_rowcolcounts */
Common->fl = EMPTY ;
Common->lnz = EMPTY ;
/* modfl is computed in cholmod_updown, cholmod_rowadd, and cholmod_rowdel*/
Common->modfl = EMPTY ;
/* all routines use status as their error-report code */
Common->status = CHOLMOD_OK ;
Common->malloc_count = 0 ; /* # calls to malloc minus # calls to free */
Common->memory_usage = 0 ; /* peak memory usage (in bytes) */
Common->memory_inuse = 0 ; /* current memory in use (in bytes) */
Common->nrealloc_col = 0 ;
Common->nrealloc_factor = 0 ;
Common->ndbounds_hit = 0 ;
Common->rowfacfl = 0 ;
Common->aatfl = EMPTY ;
/* Common->called_nd is TRUE if cholmod_analyze called or NESDIS */
Common->called_nd = FALSE ;
Common->blas_ok = TRUE ; /* false if BLAS int overflow occurs */
/* ---------------------------------------------------------------------- */
/* default SuiteSparseQR knobs and statististics */
/* ---------------------------------------------------------------------- */
for (k = 0 ; k < 4 ; k++) Common->SPQR_xstat [k] = 0 ;
for (k = 0 ; k < 10 ; k++) Common->SPQR_istat [k] = 0 ;
for (k = 0 ; k < 10 ; k++) Common->other1 [k] = 0 ;
for (k = 0 ; k < 6 ; k++) Common->other2 [k] = 0 ;
for (k = 0 ; k < 10 ; k++) Common->other3 [k] = 0 ;
for (k = 0 ; k < 16 ; k++) Common->other4 [k] = 0 ;
for (k = 0 ; k < 16 ; k++) Common->other5 [k] = (void *) NULL ;
Common->SPQR_grain = 1 ; /* no Intel TBB multitasking, by default */
Common->SPQR_small = 1e6 ; /* target min task size for TBB */
Common->SPQR_shrink = 1 ; /* controls SPQR shrink realloc */
Common->SPQR_nthreads = 0 ; /* 0: let TBB decide how many threads to use */
/* ---------------------------------------------------------------------- */
/* GPU initializations */
/* ---------------------------------------------------------------------- */
#ifdef GPU_BLAS
Common->cublasHandle = NULL ;
Common->cudaStreamSyrk = NULL ;
Common->cudaStreamGemm = NULL ;
Common->cudaStreamTrsm = NULL ;
Common->cudaStreamPotrf [0] = NULL ;
Common->cudaStreamPotrf [1] = NULL ;
Common->cudaStreamPotrf [2] = NULL ;
Common->cublasEventPotrf [0] = NULL ;
Common->cublasEventPotrf [2] = NULL ;
Common->HostPinnedMemory = NULL ;
Common->devPotrfWork = NULL ;
Common->devSyrkGemmPtrLx = NULL ;
Common->devSyrkGemmPtrC = NULL ;
Common->GemmUsed = 0 ;
Common->SyrkUsed = 0 ;
Common->syrkStart = 0 ;
#endif
DEBUG_INIT ("cholmod start", Common) ;
return (TRUE) ;
}
int main(int argc, char* const* argv)
{
pst_file pstfile;
pst_index_ll *ptr;
char *outdir = NULL, *file = NULL, *outname = NULL;
char *buf = NULL;
int c;
FILE *fp;
while ((c = getopt(argc, argv, "o:")) != -1) {
switch (c) {
case 'o':
outdir = optarg;
break;
default:
printf("Unknown switch %c\n", c);
}
}
if (optind < argc) {
file = argv[optind];
} else {
printf("Usage: dumpblocks [options] pstfile\n");
printf("\tcopies the datablocks from the pst file into separate files\n");
printf("Options: \n");
printf("\t-o target\tSpecify the output directory\n");
exit(1);
}
DEBUG_INIT("dumpblocks.log", NULL);
DEBUG_ENT("main");
printf("Opening file %s\n", file);
if (pst_open(&pstfile, file)) {
printf("Failed to open file %s\n", file);
exit(1);
}
printf("Reading Indexes\n");
if (pst_load_index(&pstfile)) {
printf("Failed to load indexes in file %s\n", argv[1]);
exit(1);
}
if (outdir != NULL)
if (chdir(outdir)) {
printf("Failed to change into directory %s\n", outdir);
exit(1);
}
ptr = pstfile.i_head;
outname = (char *) pst_malloc(OUT_BUF);
printf("Saving blocks\n");
while (ptr != NULL) {
size_t c;
c = pst_ff_getIDblock_dec(&pstfile, ptr->i_id, &buf);
if (c) {
snprintf(outname, OUT_BUF, "%#"PRIx64, ptr->i_id);
if ((fp = fopen(outname, "wb")) == NULL) {
printf("Failed to open file %s\n", outname);
continue;
}
pst_fwrite(buf, 1, c, fp);
fclose(fp);
} else {
printf("Failed to read block i_id %#"PRIx64"\n", ptr->i_id);
}
ptr = ptr->next;
}
pst_close(&pstfile);
DEBUG_RET();
return 0;
}
bool Inicializer::initConfig(FILE** infile, std::vector<Particle > &pvec) {
int err,fields,tmp_type;
long j,current;
char * line, line2[STRLEN];
size_t line_size = (STRLEN + 1) * sizeof(char);
line = (char *) malloc(line_size);
//Particle chorig[MAXCHL];
double maxlength = 0.0;
for(int i = 0; i < MAXT; i++){
if(maxlength < topo.ia_params[i][i].len[0])
maxlength = topo.ia_params[i][i].len[0];
}
if(myGetLine(&line, &line_size, *infile) == -1){
fprintf (stderr, "ERROR: Could not read box size (Inicializer::initConfig)\n\n");
return false;
}
strip_comment(line);
trim(line);
#ifdef WEDGE
double angle, innerR, outerR;
Vector box;
if (sscanf(line, "%le %le %le %le", &outerR, &innerR, &box.z, &angle) != 4) {
if(myGetLine(&line, &line_size, infile) == -1){
fprintf (stderr, "ERROR: Could not read box size.\n\n");
return false;
}
aftercommand(line2,line,BOXSEP);
strip_comment(line2);
trim(line2);
if (sscanf(line2, "%le %le %le %le", &box.z, &angle, &outerR, &innerR) != 4) {
fprintf (stderr, "ERROR: Could not read box size.\n\n");
return false;
}
}
conf->geo = Wedge(box.z, angle, outerR, innerR); //(double box.z, double angle, double outerR, double innerR)
#else
Vector box;
if (sscanf(line, "%le %le %le", &(box.x), &(box.y), &(box.z) ) != 3) {
if(myGetLine(&line, &line_size, *infile) == -1){
fprintf (stderr, "ERROR: Could not read box size2.\n\n");
return false;
}
aftercommand(line2,line,BOXSEP);
strip_comment(line2);
trim(line2);
if (sscanf(line2, "%le %le %le", &(box.x), &(box.y), &(box.z) ) != 3) {
fprintf (stderr, "ERROR: Could not read box size3.\n\n");
return false;
}
}
conf->geo = Cuboid(box);
#endif
if (conf->geo.box.x < maxlength * 2.0 + 2.0) {
printf ("WARNING: x (%f) geo.box length is less than two spherocylinders long (%f).\n\n", conf->geo.box.x, maxlength * 2.0 + 2.0);
exit(1);
}
if (conf->geo.box.y < maxlength * 2.0 + 2.0) {
printf ("WARNING: y (%f) geo.box length is less than two spherocylinders long (%f).\n\n", conf->geo.box.y, maxlength * 2.0 + 2.0);
exit(1);
}
if (conf->geo.box.z < maxlength * 2.0 + 2.0) {
printf ("WARNING: z (%f) geo.box length is less than two spherocylinders long (%f).\n\n", conf->geo.box.z, maxlength * 2.0 + 2.0);
exit(1);
}
DEBUG_INIT("Position of the particle");
for(unsigned int i=0; i < pvec.size(); i++) {
if(myGetLine(&line, &line_size, *infile) == -1){
break;
}
strip_comment(line);
trim(line);
fields = sscanf(line, "%le %le %le %le %le %le %le %le %le %d",
&pvec[i].pos.x, &pvec[i].pos.y, &pvec[i].pos.z,
&pvec[i].dir.x, &pvec[i].dir.y, &pvec[i].dir.z,
&pvec[i].patchdir[0].x, &pvec[i].patchdir[0].y, &pvec[i].patchdir[0].z,
&pvec[i].switched);
pvec[i].patchdir[1].x = pvec[i].patchdir[1].y = pvec[i].patchdir[1].z =0;
pvec[i].chdir[0].x = pvec[i].chdir[0].y = pvec[i].chdir[0].z =0;
pvec[i].chdir[1].x = pvec[i].chdir[1].y = pvec[i].chdir[1].z =0;
DEBUG_INIT("Line: %s\nNumber of Fields: %d", line, fields);
if (fields == 9){
pvec[i].switched = 0;
fprintf(stdout, "WARNING: Particle %u is assumed to be not switched!\n", i+1);
fields++;
}
if (fields != 10) {
fprintf (stderr, "ERROR: Could not read coordinates for particle %u.\n \
Did you specify box size at the begining?\n\n", i+1);
free(line);
exit (1);
}
/* Scale position vector to the unit cube */
#ifdef WEDGE
pvec[i].pos.x /= conf->geo.box.x;
pvec[i].pos.y /= conf->geo.box.y;
pvec[i].pos.z /= conf->geo.box.z;
conf->geo.usePBC(&pvec[i]);
#else
// For analysis of sheet
//conf->geo.usePBC2(&pvec[i]); // range 0 - box
pvec[i].pos.x /= conf->geo.box.x;
pvec[i].pos.y /= conf->geo.box.y;
pvec[i].pos.z /= conf->geo.box.z;
// for compatibility unfortunately
conf->geo.usePBC(&pvec[i]);
#endif
if ((topo.ia_params[pvec[i].type][pvec[i].type].geotype[0]<SP)&&( DOT(pvec[i].dir, pvec[i].dir) < ZEROTOL )) {
//DEBUG_INIT("Geotype = %d < %d", conf->pvec[i].geotype,SP);
fprintf (stderr,
"ERROR: Null direction vector supplied for particle %u.\n\n", i+1);
free(line);
return false;
} else {
pvec[i].dir.normalise();
}
if ((topo.ia_params[pvec[i].type][pvec[i].type].geotype[0]<SP)&&( DOT(pvec[i].patchdir[0], pvec[i].patchdir[0]) < ZEROTOL )) {
fprintf (stderr,
"ERROR: Null patch vector supplied for particle %u.\n\n", i+1);
free(line);
return false;
} else {
ortogonalise(&pvec[i].patchdir[0],&pvec[i].dir);
pvec[i].patchdir[0].normalise();
}
// Switch the type
if(pvec[i].switched){
if(pvec[i].switchtype == 0){
fprintf(stderr, "ERROR: Particle %u switched even though it has no switchtype", i);
free(line);
exit(1);
}
tmp_type = pvec[i].type;
pvec[i].type = pvec[i].switchtype;
pvec[i].switchtype = tmp_type;
}
DEBUG_INIT("%ld:\t%lf\t%lf\t%lf", i, pvec[i].pos.x, pvec[i].pos.y, pvec[i].pos.z);
}
int main(int argc, const char **argv)
{
TALLOC_CTX *mem_ctx = NULL;
int pc_debug = SSSDBG_DEFAULT;
const char *pc_domain = NULL;
const char *pc_user = NULL;
struct poptOption long_options[] = {
POPT_AUTOHELP
{ "debug", '\0', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &pc_debug, 0,
_("The debug level to run with"), NULL },
{ "domain", 'd', POPT_ARG_STRING, &pc_domain, 0,
_("The SSSD domain to use"), NULL },
POPT_TABLEEND
};
poptContext pc = NULL;
const char *user;
struct sss_ssh_ent *ent;
size_t i;
char *repr;
int ret;
debug_prg_name = argv[0];
ret = set_locale();
if (ret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE,
("set_locale() failed (%d): %s\n", ret, strerror(ret)));
ERROR("Error setting the locale\n");
ret = EXIT_FAILURE;
goto fini;
}
mem_ctx = talloc_new(NULL);
if (!mem_ctx) {
ERROR("Not enough memory\n");
ret = EXIT_FAILURE;
goto fini;
}
/* parse parameters */
pc = poptGetContext(NULL, argc, argv, long_options, 0);
poptSetOtherOptionHelp(pc, "USER");
while ((ret = poptGetNextOpt(pc)) > 0)
;
DEBUG_INIT(pc_debug);
if (ret != -1) {
BAD_POPT_PARAMS(pc, poptStrerror(ret), ret, fini);
}
pc_user = poptGetArg(pc);
if (pc_user == NULL) {
BAD_POPT_PARAMS(pc, _("User not specified\n"), ret, fini);
}
/* append domain to username if domain is specified */
if (pc_domain) {
user = talloc_asprintf(mem_ctx, "%s@%s", pc_user, pc_domain);
if (!user) {
ERROR("Not enough memory\n");
ret = EXIT_FAILURE;
goto fini;
}
} else {
user = pc_user;
}
/* look up public keys */
ret = sss_ssh_get_ent(mem_ctx, SSS_SSH_GET_USER_PUBKEYS,
user, NULL, &ent);
if (ret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE,
("sss_ssh_get_ent() failed (%d): %s\n", ret, strerror(ret)));
ERROR("Error looking up public keys\n");
ret = EXIT_FAILURE;
goto fini;
}
/* print results */
for (i = 0; i < ent->num_pubkeys; i++) {
ret = sss_ssh_format_pubkey(mem_ctx, &ent->pubkeys[i], &repr);
if (ret != EOK) {
DEBUG(SSSDBG_OP_FAILURE,
("sss_ssh_format_pubkey() failed (%d): %s\n",
ret, strerror(ret)));
continue;
}
printf("%s\n", repr);
}
ret = EXIT_SUCCESS;
fini:
poptFreeContext(pc);
talloc_free(mem_ctx);
return ret;
}
int main(int argc, const char *argv[])
{
int ret;
int kerr;
int opt;
int debug_fd = -1;
poptContext pc;
TALLOC_CTX *main_ctx = NULL;
uint8_t *buf = NULL;
ssize_t len = 0;
const char *ccname = NULL;
time_t expire_time = 0;
struct input_buffer *ibuf = NULL;
struct response *resp = NULL;
size_t written;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"debug-level", 'd', POPT_ARG_INT, &debug_level, 0,
_("Debug level"), NULL},
{"debug-timestamps", 0, POPT_ARG_INT, &debug_timestamps, 0,
_("Add debug timestamps"), NULL},
{"debug-microseconds", 0, POPT_ARG_INT, &debug_microseconds, 0,
_("Show timestamps with microseconds"), NULL},
{"debug-fd", 0, POPT_ARG_INT, &debug_fd, 0,
_("An open file descriptor for the debug logs"), NULL},
POPT_TABLEEND
};
/* Set debug level to invalid value so we can decide if -d 0 was used. */
debug_level = SSSDBG_INVALID;
pc = poptGetContext(argv[0], argc, argv, long_options, 0);
while((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
default:
fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
_exit(-1);
}
}
poptFreeContext(pc);
DEBUG_INIT(debug_level);
debug_prg_name = talloc_asprintf(NULL, "[sssd[ldap_child[%d]]]", getpid());
if (!debug_prg_name) {
DEBUG(SSSDBG_CRIT_FAILURE, ("talloc_asprintf failed.\n"));
goto fail;
}
if (debug_fd != -1) {
ret = set_debug_file_from_fd(debug_fd);
if (ret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE, ("set_debug_file_from_fd failed.\n"));
}
}
DEBUG(SSSDBG_TRACE_FUNC, ("ldap_child started.\n"));
main_ctx = talloc_new(NULL);
if (main_ctx == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, ("talloc_new failed.\n"));
talloc_free(discard_const(debug_prg_name));
goto fail;
}
talloc_steal(main_ctx, debug_prg_name);
buf = talloc_size(main_ctx, sizeof(uint8_t)*IN_BUF_SIZE);
if (buf == NULL) {
DEBUG(1, ("talloc_size failed.\n"));
goto fail;
}
ibuf = talloc_zero(main_ctx, struct input_buffer);
if (ibuf == NULL) {
DEBUG(1, ("talloc_size failed.\n"));
goto fail;
}
DEBUG(SSSDBG_TRACE_INTERNAL, ("context initialized\n"));
errno = 0;
len = sss_atomic_read_s(STDIN_FILENO, buf, IN_BUF_SIZE);
if (len == -1) {
ret = errno;
DEBUG(SSSDBG_CRIT_FAILURE, ("read failed [%d][%s].\n", ret, strerror(ret)));
goto fail;
}
close(STDIN_FILENO);
ret = unpack_buffer(buf, len, ibuf);
if (ret != EOK) {
DEBUG(1, ("unpack_buffer failed.[%d][%s].\n", ret, strerror(ret)));
goto fail;
}
DEBUG(SSSDBG_TRACE_INTERNAL, ("getting TGT sync\n"));
kerr = ldap_child_get_tgt_sync(main_ctx,
ibuf->realm_str, ibuf->princ_str,
ibuf->keytab_name, ibuf->lifetime,
&ccname, &expire_time);
if (kerr != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE, ("ldap_child_get_tgt_sync failed.\n"));
/* Do not return, must report failure */
}
ret = prepare_response(main_ctx, ccname, expire_time, kerr, &resp);
if (ret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE, ("prepare_response failed. [%d][%s].\n",
ret, strerror(ret)));
goto fail;
}
errno = 0;
written = sss_atomic_write_s(STDOUT_FILENO, resp->buf, resp->size);
if (written == -1) {
ret = errno;
DEBUG(SSSDBG_CRIT_FAILURE, ("write failed [%d][%s].\n", ret,
strerror(ret)));
goto fail;
}
if (written != resp->size) {
DEBUG(SSSDBG_CRIT_FAILURE, ("Expected to write %d bytes, wrote %d\n",
resp->size, written));
goto fail;
}
DEBUG(SSSDBG_TRACE_FUNC, ("ldap_child completed successfully\n"));
close(STDOUT_FILENO);
talloc_free(main_ctx);
_exit(0);
fail:
DEBUG(SSSDBG_CRIT_FAILURE, ("ldap_child failed!\n"));
close(STDOUT_FILENO);
talloc_free(main_ctx);
_exit(-1);
}
int main(int argc, const char **argv)
{
gid_t pc_gid = 0;
int pc_debug = SSSDBG_DEFAULT;
struct poptOption long_options[] = {
POPT_AUTOHELP
{ "debug", '\0', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &pc_debug,
0, _("The debug level to run with"), NULL },
{ "append-group", 'a', POPT_ARG_STRING, NULL,
'a', _("Groups to add this group to"), NULL },
{ "remove-group", 'r', POPT_ARG_STRING, NULL,
'r', _("Groups to remove this group from"), NULL },
{ "gid", 'g', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &pc_gid,
0, _("The GID of the group"), NULL },
POPT_TABLEEND
};
poptContext pc = NULL;
struct tools_ctx *tctx = NULL;
char *addgroups = NULL, *rmgroups = NULL;
int ret;
errno_t sret;
const char *pc_groupname = NULL;
char *badgroup = NULL;
bool in_transaction = false;
debug_prg_name = argv[0];
ret = set_locale();
if (ret != EOK) {
DEBUG(1, ("set_locale failed (%d): %s\n", ret, strerror(ret)));
ERROR("Error setting the locale\n");
ret = EXIT_FAILURE;
goto fini;
}
/* parse parameters */
pc = poptGetContext(NULL, argc, argv, long_options, 0);
poptSetOtherOptionHelp(pc, "GROUPNAME");
while ((ret = poptGetNextOpt(pc)) > 0) {
switch (ret) {
case 'a':
addgroups = poptGetOptArg(pc);
if (addgroups == NULL) {
BAD_POPT_PARAMS(pc, _("Specify group to add to\n"),
ret, fini);
}
break;
case 'r':
rmgroups = poptGetOptArg(pc);
if (rmgroups == NULL) {
BAD_POPT_PARAMS(pc, _("Specify group to remove from\n"),
ret, fini);
}
break;
}
}
if (ret != -1) {
BAD_POPT_PARAMS(pc, poptStrerror(ret), ret, fini);
}
/* groupname is an argument without --option */
pc_groupname = poptGetArg(pc);
if (pc_groupname == NULL) {
BAD_POPT_PARAMS(pc, _("Specify group to modify\n"), ret, fini);
}
DEBUG_INIT(pc_debug);
CHECK_ROOT(ret, debug_prg_name);
ret = init_sss_tools(&tctx);
if (ret != EOK) {
DEBUG(1, ("init_sss_tools failed (%d): %s\n", ret, strerror(ret)));
if (ret == ENOENT) {
ERROR("Error initializing the tools - no local domain\n");
} else {
ERROR("Error initializing the tools\n");
}
ret = EXIT_FAILURE;
goto fini;
}
ret = parse_name_domain(tctx, pc_groupname);
if (ret != EOK) {
ERROR("Invalid domain specified in FQDN\n");
ret = EXIT_FAILURE;
goto fini;
}
/* check the username to be able to give sensible error message */
ret = sysdb_getgrnam_sync(tctx, tctx->sysdb, tctx->octx->name, tctx->octx);
if (ret != EOK) {
ERROR("Cannot find group in local domain, "
"modifying groups is allowed only in local domain\n");
ret = EXIT_FAILURE;
goto fini;
}
tctx->octx->gid = pc_gid;
if (addgroups) {
ret = parse_groups(tctx, addgroups, &tctx->octx->addgroups);
if (ret != EOK) {
DEBUG(1, ("Cannot parse groups to add the group to\n"));
ERROR("Internal error while parsing parameters\n");
ret = EXIT_FAILURE;
goto fini;
}
ret = parse_group_name_domain(tctx, tctx->octx->addgroups);
if (ret != EOK) {
DEBUG(1, ("Cannot parse FQDN groups to add the group to\n"));
ERROR("Member groups must be in the same domain as parent group\n");
ret = EXIT_FAILURE;
goto fini;
}
/* Check group names in the LOCAL domain */
ret = check_group_names(tctx, tctx->octx->addgroups, &badgroup);
if (ret != EOK) {
ERROR("Cannot find group %1$s in local domain, "
"only groups in local domain are allowed\n", badgroup);
ret = EXIT_FAILURE;
goto fini;
}
}
if (rmgroups) {
ret = parse_groups(tctx, rmgroups, &tctx->octx->rmgroups);
if (ret != EOK) {
DEBUG(1, ("Cannot parse groups to remove the group from\n"));
ERROR("Internal error while parsing parameters\n");
ret = EXIT_FAILURE;
goto fini;
}
ret = parse_group_name_domain(tctx, tctx->octx->rmgroups);
if (ret != EOK) {
DEBUG(1, ("Cannot parse FQDN groups to remove the group from\n"));
ERROR("Member groups must be in the same domain as parent group\n");
ret = EXIT_FAILURE;
goto fini;
}
/* Check group names in the LOCAL domain */
ret = check_group_names(tctx, tctx->octx->rmgroups, &badgroup);
if (ret != EOK) {
ERROR("Cannot find group %1$s in local domain, "
"only groups in local domain are allowed\n", badgroup);
ret = EXIT_FAILURE;
goto fini;
}
}
if (id_in_range(tctx->octx->gid, tctx->octx->domain) != EOK) {
ERROR("The selected GID is outside the allowed range\n");
ret = EXIT_FAILURE;
goto fini;
}
tctx->error = sysdb_transaction_start(tctx->sysdb);
if (tctx->error != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to start transaction\n"));
goto done;
}
in_transaction = true;
/* groupmod */
tctx->error = groupmod(tctx, tctx->sysdb, tctx->octx);
if (tctx->error) {
goto done;
}
tctx->error = sysdb_transaction_commit(tctx->sysdb);
if (tctx->error != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to commit transaction\n"));
goto done;
}
in_transaction = false;
ret = sss_mc_refresh_group(pc_groupname);
if (ret != EOK) {
ERROR("NSS request failed (%1$d). Entry might remain in memory "
"cache.\n", ret);
/* Nothing we can do about it */
}
ret = sss_mc_refresh_grouplist(tctx, tctx->octx->addgroups);
if (ret != EOK) {
ERROR("NSS request failed (%1$d). Entry might remain in memory "
"cache.\n", ret);
/* Nothing we can do about it */
}
ret = sss_mc_refresh_grouplist(tctx, tctx->octx->rmgroups);
if (ret != EOK) {
ERROR("NSS request failed (%1$d). Entry might remain in memory "
"cache.\n", ret);
/* Nothing we can do about it */
}
done:
if (in_transaction) {
sret = sysdb_transaction_cancel(tctx->sysdb);
if (sret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to cancel transaction\n"));
}
}
if (tctx->error) {
ret = tctx->error;
DEBUG(1, ("sysdb operation failed (%d)[%s]\n", ret, strerror(ret)));
switch (ret) {
case ENOENT:
ERROR("Could not modify group - check if member group names are correct\n");
break;
case EFAULT:
ERROR("Could not modify group - check if groupname is correct\n");
break;
default:
ERROR("Transaction error. Could not modify group.\n");
break;
}
ret = EXIT_FAILURE;
goto fini;
}
ret = EXIT_SUCCESS;
fini:
free(addgroups);
free(rmgroups);
poptFreeContext(pc);
talloc_free(tctx);
exit(ret);
}
int main(int argc, const char **argv)
{
int ret = EXIT_SUCCESS;
int pc_debug = SSSDBG_DEFAULT;
const char *pc_groupname = NULL;
struct tools_ctx *tctx = NULL;
poptContext pc = NULL;
struct poptOption long_options[] = {
POPT_AUTOHELP
{ "debug", '\0', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &pc_debug,
0, _("The debug level to run with"), NULL },
POPT_TABLEEND
};
debug_prg_name = argv[0];
ret = set_locale();
if (ret != EOK) {
DEBUG(1, ("set_locale failed (%d): %s\n", ret, strerror(ret)));
ERROR("Error setting the locale\n");
ret = EXIT_FAILURE;
goto fini;
}
/* parse ops_ctx */
pc = poptGetContext(NULL, argc, argv, long_options, 0);
poptSetOtherOptionHelp(pc, "GROUPNAME");
if ((ret = poptGetNextOpt(pc)) < -1) {
BAD_POPT_PARAMS(pc, poptStrerror(ret), ret, fini);
}
DEBUG_INIT(pc_debug);
pc_groupname = poptGetArg(pc);
if (pc_groupname == NULL) {
BAD_POPT_PARAMS(pc, _("Specify group to delete\n"), ret, fini);
}
CHECK_ROOT(ret, debug_prg_name);
ret = init_sss_tools(&tctx);
if (ret != EOK) {
DEBUG(1, ("init_sss_tools failed (%d): %s\n", ret, strerror(ret)));
if (ret == ENOENT) {
ERROR("Error initializing the tools - no local domain\n");
} else {
ERROR("Error initializing the tools\n");
}
ret = EXIT_FAILURE;
goto fini;
}
/* if the domain was not given as part of FQDN, default to local domain */
ret = parse_name_domain(tctx, pc_groupname);
if (ret != EOK) {
ERROR("Invalid domain specified in FQDN\n");
ret = EXIT_FAILURE;
goto fini;
}
ret = sysdb_getgrnam_sync(tctx, tctx->sysdb, tctx->octx->name, tctx->octx);
if (ret != EOK) {
/* Error message will be printed in the switch */
goto done;
}
if ((tctx->octx->gid < tctx->local->id_min) ||
(tctx->local->id_max && tctx->octx->gid > tctx->local->id_max)) {
ERROR("Group %1$s is outside the defined ID range for domain\n",
tctx->octx->name);
ret = EXIT_FAILURE;
goto fini;
}
/* groupdel */
ret = groupdel(tctx, tctx->sysdb, tctx->octx);
if (ret != EOK) {
goto done;
}
/* Delete group from memory cache */
ret = sss_mc_refresh_group(pc_groupname);
if (ret != EOK) {
ERROR("NSS request failed (%1$d). Entry might remain in memory "
"cache.\n", ret);
/* Nothing we can do about it */
}
ret = EOK;
done:
if (ret) {
DEBUG(1, ("sysdb operation failed (%d)[%s]\n", ret, strerror(ret)));
switch (ret) {
case ENOENT:
ERROR("No such group in local domain. "
"Removing groups only allowed in local domain.\n");
break;
default:
ERROR("Internal error. Could not remove group.\n");
break;
}
ret = EXIT_FAILURE;
goto fini;
}
ret = EXIT_SUCCESS;
fini:
talloc_free(tctx);
poptFreeContext(pc);
exit(ret);
}
int CHOLMOD(start)
(
cholmod_common *Common
)
{
if (Common == NULL)
{
return (FALSE) ;
}
/* ---------------------------------------------------------------------- */
/* user error handling routine */
/* ---------------------------------------------------------------------- */
Common->error_handler = NULL ;
/* ---------------------------------------------------------------------- */
/* integer and numerical types */
/* ---------------------------------------------------------------------- */
Common->itype = ITYPE ;
Common->dtype = DTYPE ;
/* ---------------------------------------------------------------------- */
/* default control parameters */
/* ---------------------------------------------------------------------- */
CHOLMOD(defaults) (Common) ;
Common->try_catch = FALSE ;
/* ---------------------------------------------------------------------- */
/* memory management routines */
/* ---------------------------------------------------------------------- */
/* The user can replace cholmod's memory management routines by redefining
* these function pointers. */
#ifndef NMALLOC
/* stand-alone ANSI C program */
Common->malloc_memory = malloc ;
Common->free_memory = free ;
Common->realloc_memory = realloc ;
Common->calloc_memory = calloc ;
#else
/* no memory manager defined at compile-time; MUST define one at run-time */
Common->malloc_memory = NULL ;
Common->free_memory = NULL ;
Common->realloc_memory = NULL ;
Common->calloc_memory = NULL ;
#endif
/* ---------------------------------------------------------------------- */
/* complex arithmetic routines */
/* ---------------------------------------------------------------------- */
Common->complex_divide = CHOLMOD(divcomplex) ;
Common->hypotenuse = CHOLMOD(hypot) ;
/* ---------------------------------------------------------------------- */
/* print routine */
/* ---------------------------------------------------------------------- */
#ifndef NPRINT
/* stand-alone ANSI C program */
Common->print_function = printf ;
#else
/* printing disabled */
Common->print_function = NULL ;
#endif
/* ---------------------------------------------------------------------- */
/* workspace */
/* ---------------------------------------------------------------------- */
/* This code assumes the workspace held in Common is not initialized. If
* it is, then a memory leak will occur because the pointers are
* overwritten with NULL. */
Common->nrow = 0 ;
Common->mark = EMPTY ;
Common->xworksize = 0 ;
Common->iworksize = 0 ;
Common->Flag = NULL ;
Common->Head = NULL ;
Common->Iwork = NULL ;
Common->Xwork = NULL ;
/* ---------------------------------------------------------------------- */
/* statistics */
/* ---------------------------------------------------------------------- */
/* fl and lnz are computed in cholmod_analyze and cholmod_rowcolcounts */
Common->fl = EMPTY ;
Common->lnz = EMPTY ;
/* modfl is computed in cholmod_updown, cholmod_rowadd, and cholmod_rowdel*/
Common->modfl = EMPTY ;
/* all routines use status as their error-report code */
Common->status = CHOLMOD_OK ;
Common->malloc_count = 0 ; /* # calls to malloc minus # calls to free */
Common->memory_usage = 0 ; /* peak memory usage (in bytes) */
Common->memory_inuse = 0 ; /* current memory in use (in bytes) */
Common->nrealloc_col = 0 ;
Common->nrealloc_factor = 0 ;
Common->ndbounds_hit = 0 ;
Common->rowfacfl = 0 ;
DEBUG_INIT ("cholmod start") ;
return (TRUE) ;
}
int main(int argc, char* const* argv) {
pst_item *item = NULL;
pst_desc_tree *d_ptr;
char *temp = NULL; //temporary char pointer
int c;
char *d_log = NULL;
while ((c = getopt(argc, argv, "d:hV"))!= -1) {
switch (c) {
case 'd':
d_log = optarg;
break;
case 'h':
usage(argv[0]);
exit(0);
break;
case 'V':
version();
exit(0);
break;
default:
usage(argv[0]);
exit(1);
break;
}
}
#ifdef DEBUG_ALL
// force a log file
if (!d_log) d_log = "lspst.log";
#endif // defined DEBUG_ALL
DEBUG_INIT(d_log, NULL);
DEBUG_ENT("main");
if (argc <= optind) {
usage(argv[0]);
exit(2);
}
// Open PST file
if (pst_open(&pstfile, argv[optind])) DIE(("Error opening File\n"));
// Load PST index
if (pst_load_index(&pstfile)) DIE(("Index Error\n"));
pst_load_extended_attributes(&pstfile);
d_ptr = pstfile.d_head; // first record is main record
item = pst_parse_item(&pstfile, d_ptr, NULL);
if (!item || !item->message_store) {
DEBUG_RET();
DIE(("Could not get root record\n"));
}
// default the file_as to the same as the main filename if it doesn't exist
if (!item->file_as.str) {
if (!(temp = strrchr(argv[1], '/')))
if (!(temp = strrchr(argv[1], '\\')))
temp = argv[1];
else
temp++; // get past the "\\"
else
temp++; // get past the "/"
item->file_as.str = strdup(temp);
item->file_as.is_utf8 = 1;
}
d_ptr = pst_getTopOfFolders(&pstfile, item);
if (!d_ptr) DIE(("Top of folders record not found. Cannot continue\n"));
process(item, d_ptr->child); // do the childred of TOPF
pst_freeItem(item);
pst_close(&pstfile);
DEBUG_RET();
return 0;
}
int main(int argc, char** argv)
{
DEBUG_INIT(argv[0]);
BEGIN;
PRINT(L"-- minihash --------------------------------\n");
{
bz_Minihash* m;
m = bz_minihash_new();
PRINT(L"class: ");wprintf(L"%ls",m->type->name);wprintf(L"\n");
put(m,str(L"x"),val(1));
put(m,str(L"y"),val(2));
put(m,str(L"z"),val(3));
PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
PRINT(L"x=1: ");wprintf(L"%i",(int)get(m,str(L"x")));wprintf(L"\n");
PRINT(L"x=2: ");wprintf(L"%i",(int)get(m,str(L"y")));wprintf(L"\n");
PRINT(L"x=3: ");wprintf(L"%i",(int)get(m,str(L"z")));wprintf(L"\n");
put(m,str(L"x"),val(1));
put(m,str(L"y"),val(2));
put(m,str(L"z"),val(3));
PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
PRINT(L"x=1: ");wprintf(L"%i",(int)get(m,str(L"x")));wprintf(L"\n");
PRINT(L"y=2: ");wprintf(L"%i",(int)get(m,str(L"y")));wprintf(L"\n");
PRINT(L"z=3: ");wprintf(L"%i",(int)get(m,str(L"z")));wprintf(L"\n");
put(m,str(L"x"),val(10));
put(m,str(L"y"),val(20));
put(m,str(L"z"),val(30));
PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
PRINT(L"x=10: ");wprintf(L"%i",(int)get(m,str(L"x")));wprintf(L"\n");
PRINT(L"y=20: ");wprintf(L"%i",(int)get(m,str(L"y")));wprintf(L"\n");
PRINT(L"z=30: ");wprintf(L"%i",(int)get(m,str(L"z")));wprintf(L"\n");
put(m,str(L"sam"),val(L"SAM"));
put(m,str(L"was"),val(L"WAS"));
put(m,str(L"here"),val(L"HERE"));
PRINT(L"sam=SAM: ");wprintf(L"%ls",(char*)get(m,str(L"sam")));wprintf(L"\n");
PRINT(L"was=WAS: ");wprintf(L"%ls",(char*)get(m,str(L"was")));wprintf(L"\n");
PRINT(L"here=HERE: ");wprintf(L"%ls",(char*)get(m,str(L"here")));wprintf(L"\n");
PRINT(L"sam defined at: ");
wprintf(L"file:%ls line:%i",bz_string_to_wstr(get_filename(m,str(L"sam"))),get_line(m,str(L"sam")));
wprintf(L"\n");
PRINT(L"was defined at: ");
wprintf(L"file:%ls line:%i",bz_string_to_wstr(get_filename(m,str(L"was"))),get_line(m,str(L"was")));
wprintf(L"\n");
PRINT(L"here defined at: ");
wprintf(L"file:%ls line:%i",bz_string_to_wstr(get_filename(m,str(L"here"))),get_line(m,str(L"here")));
wprintf(L"\n");
}
{
bz_Minihash* m = bz_minihash_new();
put(m,str(L"00"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"01"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"02"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"03"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"04"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"05"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"06"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"07"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"08"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"09"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"10"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"11"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"12"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"13"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"14"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"15"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"16"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"17"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"18"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"19"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"20"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"21"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"22"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"23"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"24"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"25"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"26"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"27"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"28"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"29"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"30"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
put(m,str(L"31"),val(0)); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"31")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"30")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"29")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"28")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"27")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"26")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"25")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"24")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"23")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"22")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"21")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"20")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"19")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"18")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"17")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"16")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"15")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"14")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"13")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"12")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"11")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
delete(m,str(L"10")); PRINT(L"length: ");wprintf(L"%i",bz_minihash_length(m));wprintf(L"\n");
PRINT(L"00: ");wprintf(L"%i",(int)(get(m,str(L"00")) == bz_EMPTY));wprintf(L"\n");
PRINT(L"10: ");wprintf(L"%i",(int)(get(m,str(L"10")) == bz_EMPTY));wprintf(L"\n");
}
END; exit(0);
}
int main(int argc, char* const* argv)
{
// pass the id number to display on the command line
char *fname, *sid;
uint64_t i_id;
int c;
DEBUG_INIT("getidblock.log", NULL);
DEBUG_ENT("main");
while ((c = getopt(argc, argv, "bp")) != -1) {
switch (c) {
case 'b':
// enable binary output
binary = 1;
break;
case 'p':
// enable procesing of block
process = 1;
break;
default:
usage();
exit(EXIT_FAILURE);
}
}
if (optind + 1 >= argc) {
// no more items on the cmd
usage();
exit(EXIT_FAILURE);
}
fname = argv[optind];
sid = argv[optind + 1];
i_id = (uint64_t)strtoll(sid, NULL, 0);
DEBUG_INFO(("Opening file\n"));
memset(&pstfile, 0, sizeof(pstfile));
if (pst_open(&pstfile, fname, NULL)) {
DIE(("Error opening file\n"));
}
DEBUG_INFO(("Loading Index\n"));
if (pst_load_index(&pstfile) != 0) {
DIE(("Error loading file index\n"));
}
if (i_id) {
dumper(i_id);
}
else {
size_t i;
for (i = 0; i < pstfile.i_count; i++) {
dumper(pstfile.i_table[i].i_id);
}
dump_desc(pstfile.d_head, NULL);
}
if (pst_close(&pstfile) != 0) {
DIE(("pst_close failed\n"));
}
DEBUG_RET();
return 0;
}