static gpointer
do_init (gpointer data)
{
cs_opt_mem gum_cs_mem_callbacks = {
gum_capstone_malloc,
gum_capstone_calloc,
gum_capstone_realloc,
gum_capstone_free,
gum_vsnprintf
};
gum_memory_init ();
#if GLIB_CHECK_VERSION (2, 46, 0)
glib_init ();
gio_init ();
#endif
cs_option (0, CS_OPT_MEM, GPOINTER_TO_SIZE (&gum_cs_mem_callbacks));
_gum_tls_init ();
_gum_interceptor_init ();
_gum_tls_realize ();
return NULL;
}
PolkitResult polkit_check_authorization_dname(const char *dbus_name, const char *action_id)
{
glib_init();
PolkitSubject *subject = polkit_system_bus_name_new(dbus_name);
return do_check(subject, action_id);
}
static gpointer
do_init (gpointer data)
{
GumFeatureFlags features = (GumFeatureFlags) GPOINTER_TO_INT (data);
cs_opt_mem gum_cs_mem_callbacks = {
gum_capstone_malloc,
gum_capstone_calloc,
gum_capstone_realloc,
gum_capstone_free,
gum_vsnprintf
};
(void) features;
page_size = gum_query_page_size ();
gum_memory_init ();
#if GLIB_CHECK_VERSION (2, 42, 0)
glib_init ();
gio_init ();
#endif
cs_option (0, CS_OPT_MEM, GPOINTER_TO_SIZE (&gum_cs_mem_callbacks));
#ifdef HAVE_SYMBOL_BACKEND
if ((features & GUM_FEATURE_SYMBOL_LOOKUP) != 0)
_gum_symbol_util_init ();
#endif
_gum_interceptor_init ();
return NULL;
}
BOOL WINAPI
DllMain (HINSTANCE hinstDLL,
DWORD fdwReason,
LPVOID lpvReserved)
{
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
glib_dll = hinstDLL;
g_clock_win32_init ();
#ifdef THREADS_WIN32
g_thread_win32_init ();
#endif
glib_init ();
break;
case DLL_THREAD_DETACH:
#ifdef THREADS_WIN32
g_thread_win32_thread_detach ();
#endif
break;
default:
/* do nothing */
;
}
return TRUE;
}
static void init ()
{
#if GLIB_CHECK_VERSION (2, 46, 0)
glib_init ();
gio_init ();
#endif
gum_init ();
}
static void
glib_init_ctor (void)
{
#ifdef G_OS_WIN32
g_clock_win32_init ();
g_thread_win32_init ();
#endif
glib_init ();
}
PolkitResult polkit_check_authorization_pid(pid_t pid, const char *action_id)
{
glib_init();
PolkitSubject *subject = polkit_unix_process_new_for_owner(pid,
/*use start_time from /proc*/0,
/*use uid from /proc*/ -1);
return do_check(subject, action_id);
}
int
main(int argc, char **argv)
{
static TestUtilsTest tests[] = {
TU_TEST(test_sync, 60),
TU_END()
};
glib_init();
return testutils_run_tests(argc, argv, tests);
}
int
main(int argc, char **argv)
{
static TestUtilsTest tests[] = {
TU_TEST(test_old_impls, 90),
TU_TEST(test_inter_proc_locking, 60),
TU_TEST(test_intra_proc_locking, 60),
TU_END()
};
glib_init();
return testutils_run_tests(argc, argv, tests);
}
void device_api_init(void) {
glib_init();
device_property_init();
driverList = g_hash_table_new(g_str_hash, g_str_equal);
/* register other types and devices. */
null_device_register();
vfs_device_register();
#ifdef WANT_TAPE_DEVICE
tape_device_register();
#endif
rait_device_register();
#ifdef WANT_S3_DEVICE
s3_device_register();
#endif
}
void
frida_init (void)
{
static gsize frida_initialized = FALSE;
#if GLIB_CHECK_VERSION (2, 46, 0)
glib_init ();
gio_init ();
#endif
frida_error_quark (); /* Initialize early so GDBus will pick it up */
if (g_once_init_enter (&frida_initialized))
{
main_context = g_main_context_ref (g_main_context_default ());
main_loop = g_main_loop_new (main_context, FALSE);
main_thread = g_thread_new ("frida-main-loop", run_main_loop, NULL);
g_once_init_leave (&frida_initialized, TRUE);
}
}
int
main(int argc, char **argv)
{
#if defined(G_THREADS_ENABLED) && !defined(G_THREADS_IMPL_NONE)
static TestUtilsTest tests[] = {
TU_TEST(test_decr_wait, 90),
TU_TEST(test_wait_empty, 90),
TU_TEST(test_force_adjust, 90),
TU_TEST(test_force_set, 90),
TU_END()
};
glib_init();
return testutils_run_tests(argc, argv, tests);
#else
g_fprintf(stderr, "No thread support on this platform -- nothing to test\n");
return 0;
#endif
}
void
frida_agent_environment_init (void)
{
GMemVTable mem_vtable = {
gum_malloc,
gum_realloc,
gum_free,
gum_calloc,
gum_malloc,
gum_realloc
};
#if defined (G_OS_WIN32) && DEBUG_HEAP_LEAKS
int tmp_flag;
/*_CrtSetBreakAlloc (1337);*/
_CrtSetReportMode (_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile (_CRT_ERROR, _CRTDBG_FILE_STDERR);
tmp_flag = _CrtSetDbgFlag (_CRTDBG_REPORT_FLAG);
tmp_flag |= _CRTDBG_ALLOC_MEM_DF;
tmp_flag |= _CRTDBG_LEAK_CHECK_DF;
tmp_flag &= ~_CRTDBG_CHECK_CRT_DF;
_CrtSetDbgFlag (tmp_flag);
#endif
gum_memory_init ();
g_mem_set_vtable (&mem_vtable);
#if DEBUG_HEAP_LEAKS
g_setenv ("G_SLICE", "always-malloc", TRUE);
#endif
glib_init ();
g_log_set_default_handler (frida_agent_on_log_message, NULL);
g_log_set_always_fatal (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING);
gio_init ();
gum_init ();
}
void
frida_init (void)
{
static gsize frida_initialized = FALSE;
g_thread_set_garbage_handler (frida_on_pending_garbage, NULL);
glib_init ();
gio_init ();
gum_init ();
frida_error_quark (); /* Initialize early so GDBus will pick it up */
if (g_once_init_enter (&frida_initialized))
{
g_set_prgname ("frida");
main_context = g_main_context_ref (g_main_context_default ());
main_loop = g_main_loop_new (main_context, FALSE);
main_thread = g_thread_new ("frida-main-loop", run_main_loop, NULL);
g_once_init_leave (&frida_initialized, TRUE);
}
}
static void
gum_do_init (void)
{
cs_opt_mem gum_cs_mem_callbacks = {
gum_cs_malloc,
gum_cs_calloc,
gum_cs_realloc,
gum_cs_free,
(cs_vsnprintf_t) gum_vsnprintf
};
gum_memory_init ();
glib_init ();
gobject_init ();
gio_init ();
cs_option (0, CS_OPT_MEM, GPOINTER_TO_SIZE (&gum_cs_mem_callbacks));
_gum_tls_init ();
_gum_interceptor_init ();
_gum_tls_realize ();
}
int
main(int argc, char **argv)
{
int result;
static TestUtilsTest tests[] = {
TU_TEST(test_vfs_free_space, 90),
TU_END()
};
glib_init();
config_init(0, NULL);
device_api_init();
/* TODO: if more tests are added, we'll need a setup/cleanup hook
* for testutils */
device_path = setup_vtape_dir();
result = testutils_run_tests(argc, argv, tests);
cleanup_vtape_dir(device_path);
amfree(device_path);
return result;
}
void
gum_init_embedded (void)
{
ffi_mem_callbacks ffi_callbacks = {
(void * (*) (size_t)) gum_malloc,
(void * (*) (size_t, size_t)) gum_calloc,
gum_free,
gum_on_ffi_allocate,
gum_on_ffi_deallocate
};
GThreadCallbacks thread_callbacks = {
gum_on_thread_init,
gum_on_thread_realize,
gum_on_thread_dispose,
gum_on_thread_finalize
};
GFDCallbacks fd_callbacks = {
gum_on_fd_opened,
gum_on_fd_closed
};
#if !DEBUG_HEAP_LEAKS && !defined (HAVE_ASAN)
GMemVTable mem_vtable = {
gum_malloc,
gum_realloc,
gum_free,
gum_calloc,
gum_malloc,
gum_realloc
};
#endif
#if defined (G_OS_WIN32) && DEBUG_HEAP_LEAKS
int tmp_flag;
#endif
if (gum_initialized)
return;
gum_initialized = TRUE;
#if defined (G_OS_WIN32) && DEBUG_HEAP_LEAKS
/*_CrtSetBreakAlloc (1337);*/
_CrtSetReportMode (_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile (_CRT_ERROR, _CRTDBG_FILE_STDERR);
tmp_flag = _CrtSetDbgFlag (_CRTDBG_REPORT_FLAG);
tmp_flag |= _CRTDBG_ALLOC_MEM_DF;
tmp_flag |= _CRTDBG_LEAK_CHECK_DF;
tmp_flag &= ~_CRTDBG_CHECK_CRT_DF;
_CrtSetDbgFlag (tmp_flag);
#endif
gum_memory_init ();
ffi_set_mem_callbacks (&ffi_callbacks);
g_thread_set_callbacks (&thread_callbacks);
g_platform_audit_set_fd_callbacks (&fd_callbacks);
#if !DEBUG_HEAP_LEAKS && !defined (HAVE_ASAN)
if (RUNNING_ON_VALGRIND)
{
g_setenv ("G_SLICE", "always-malloc", TRUE);
}
else
{
g_mem_set_vtable (&mem_vtable);
}
#else
g_setenv ("G_SLICE", "always-malloc", TRUE);
#endif
glib_init ();
g_assertion_set_handler (gum_on_assert_failure, NULL);
g_log_set_default_handler (gum_on_log_message, NULL);
gum_do_init ();
g_set_prgname ("frida");
#if defined (HAVE_LINUX) && defined (HAVE_GLIBC)
gum_libdl_prevent_unload ();
#endif
gum_cached_interceptor = gum_interceptor_obtain ();
}
static void
glib_init_ctor (void)
{
glib_init ();
}
int
main(
int argc,
char ** argv)
{
config_overrides_t *cfg_ovr;
char *hostname;
char *auth;
char *service;
char *config = NULL;
int opt;
extern int optind;
extern char *optarg;
FILE *input_file;
int use_connect = 0;
int got_input_file = 0;
int i;
unsigned char gfd[32768];
glib_init();
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
// safe_fd(-1, 0);
safe_cd();
set_pname("amservice");
/* drop root privileges */
if (!set_root_privs(0)) {
error(_("amservice must be run setuid root"));
}
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
dbopen(DBG_SUBDIR_SERVER);
add_amanda_log_handler(amanda_log_stderr);
our_features = am_init_feature_set();
our_feature_string = am_feature_to_string(our_features);
/* process arguments */
for (i=0; i<argc; i++) {
g_debug("argv[%d] = %s", i, argv[i]);
}
for (i = 0;i < 32768; i++) {
gfd[i] = 0;
}
cfg_ovr = new_config_overrides(argc/2);
input_file = stdin;
while((opt = getopt_long(argc, argv, "o:f:s", long_options, NULL)) != EOF) {
switch(opt) {
case 1: printf("amservice-%s\n", VERSION);
return(0);
break;
case 2: g_free(our_feature_string);
g_free(our_features);
our_feature_string = g_strdup(optarg);
our_features = am_string_to_feature(our_feature_string);
break;
case 3: { gchar *copy_optarg = g_strdup(optarg);
gchar *coma = strchr(copy_optarg, ',');
gchar *stream_in;
if (nb_lstream == DATA_FD_COUNT) {
g_critical("Too many --stream, maximum is %d",
DATA_FD_COUNT);
exit(1);
} else if (coma) {
*coma++ = '\0';
stream_in = coma;
coma = strchr(coma, ',');
if (coma) {
*coma++ = '\0';
lstreams[nb_lstream].name = g_strdup(copy_optarg);
lstreams[nb_lstream].fd_in = atoi(stream_in);
lstreams[nb_lstream].fd_out = atoi(coma);
gfd[lstreams[nb_lstream].fd_in] = 1;
gfd[lstreams[nb_lstream].fd_out] = 1;
nb_lstream++;
}
}
if (!coma) {
g_critical("Invalid --stream option (%s)", optarg);
exit(1);
}
g_free(copy_optarg);
break;
}
case 4: g_free(config);
config = g_strdup(optarg);
break;
case 'o': add_config_override_opt(cfg_ovr, optarg);
break;
case 'f': if (got_input_file == 1) {
g_critical("Invalid two -f argument");
exit(1);
}
got_input_file = 1;
if (*optarg == '/') {
input_file = fopen(optarg, "r");
} else {
char *name = g_strjoin(NULL, get_original_cwd(), "/",
optarg, NULL);
input_file = fopen(name, "r");
amfree(name);
}
if (!input_file) {
g_critical("Cannot open input file '%s': %s",
optarg, strerror(errno));
exit(1);
}
break;
case 's': use_connect = 1;
break;
}
}
if (use_connect && !got_input_file) {
g_critical("The -s option require -f");
exit(1);
}
/* close all unused fd */
for (i = 3;i < 32768; i++) {
if (gfd[i] == 0 && i != dbfd() &&
(!got_input_file || i != fileno(input_file))) {
close(i);
}
}
argc -= optind, argv += optind;
if(argc < 3) usage();
/* set a default config */
set_config_overrides(cfg_ovr);
config_init(CONFIG_INIT_CLIENT|CONFIG_INIT_GLOBAL, NULL);
if (config) {
config_init(CONFIG_INIT_CLIENT | CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_OVERLAY, config);
}
dbrename(get_config_name(), DBG_SUBDIR_SERVER);
if (config_errors(NULL) >= CFGERR_WARNINGS) {
config_print_errors();
if (config_errors(NULL) >= CFGERR_ERRORS) {
g_critical(_("errors processing config file"));
}
}
conf_ctimeout = (time_t)getconf_int(CNF_CTIMEOUT);
hostname = argv[0];
auth = argv[1];
if (g_str_equal(auth,"NULL")) {
auth = getconf_str(CNF_AUTH);
}
service = argv[2];
/* start client side checks */
copy_stream = use_connect && got_input_file;
client_protocol(hostname, auth, service, config, input_file);
amfree(our_feature_string);
am_release_feature_set(our_features);
our_features = NULL;
if (got_input_file)
fclose(input_file);
dbclose();
return(remote_errors != 0);
}
int
main(
int argc,
char ** argv)
{
char ch;
am_feature_t *our_features = NULL;
char *our_feature_string = NULL;
char *options;
ssize_t n;
(void)argc; /* Quiet unused parameter warning */
(void)argv; /* Quiet unused parameter warning */
glib_init();
if (argc > 1 && argv && argv[1] && g_str_equal(argv[1], "--version")) {
printf("noop-%s\n", VERSION);
return (0);
}
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
safe_fd(-1, 0);
openbsd_fd_inform();
check_running_as(RUNNING_AS_CLIENT_LOGIN);
do {
/* soak up any stdin */
n = read(0, &ch, 1);
} while ((n > 0) || ((n < 0) && ((errno == EINTR) || (errno == EAGAIN))));
our_features = am_init_feature_set();
our_feature_string = am_feature_to_string(our_features);
options = g_strjoin(NULL, "OPTIONS features=",
our_feature_string,
";\n",
NULL);
amfree(our_feature_string);
am_release_feature_set(our_features);
our_features = NULL;
if (full_write(1, options, strlen(options)) < strlen(options)) {
error(_("error sending noop response: %s"), strerror(errno));
/*NOTREACHED*/
}
amfree(options);
close(0);
close(1);
close(2);
return (0); /* exit */
}
int
main(
int argc,
char ** argv)
{
#ifdef TEST
/* standalone test to ckeck wether the calculated file size is ok */
struct stat finfo;
int i;
off_t dump_total = (off_t)0;
off_t gtar_total = (off_t)0;
char *d;
int l, w;
glib_init();
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
safe_fd(-1, 0);
set_pname("calcsize");
dbopen(NULL);
config_init(CONFIG_INIT_CLIENT|CONFIG_INIT_GLOBAL, NULL);
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
if (argc < 2) {
g_fprintf(stderr,_("Usage: %s file[s]\n"),argv[0]);
return 1;
}
for(i=1; i<argc; i++) {
if(lstat(argv[i], &finfo) == -1) {
g_fprintf(stderr, "%s: %s\n", argv[i], strerror(errno));
continue;
}
g_printf("%s: st_size=%lu", argv[i],(unsigned long)finfo.st_size);
g_printf(": blocks=%llu\n", ST_BLOCKS(finfo));
dump_total += (ST_BLOCKS(finfo) + (off_t)1) / (off_t)2 + (off_t)1;
gtar_total += ROUND(4,(ST_BLOCKS(finfo) + (off_t)1));
}
g_printf(" gtar dump\n");
g_printf("total %-9lu %-9lu\n",gtar_total,dump_total);
return 0;
#else
int i;
char *dirname=NULL;
char *amname=NULL, *qamname=NULL;
char *filename=NULL, *qfilename = NULL;
if (argc > 1 && argv[1] && g_str_equal(argv[1], "--version")) {
printf("calcsize-%s\n", VERSION);
return (0);
}
safe_fd(-1, 0);
safe_cd();
set_pname("calcsize");
dbopen(DBG_SUBDIR_CLIENT);
config_init(CONFIG_INIT_CLIENT|CONFIG_INIT_GLOBAL, NULL);
dbprintf(_("version %s\n"), VERSION);
/* drop root privileges; we'll regain them for the required operations */
#ifdef WANT_SETUID_CLIENT
check_running_as(RUNNING_AS_CLIENT_LOGIN | RUNNING_AS_UID_ONLY);
if (!set_root_privs(0)) {
error(_("calcsize must be run setuid root"));
}
#else
check_running_as(RUNNING_AS_CLIENT_LOGIN);
#endif
argc--, argv++; /* skip program name */
/* need at least program, amname, and directory name */
if(argc < 4) {
error(_("Usage: %s config [BSDTAR|DUMP|STAR|GNUTAR] name dir [-X exclude-file] [-I include-file] [level date]*"),
get_pname());
/*NOTREACHED*/
}
dbprintf(_("config: %s\n"), *argv);
if (!g_str_equal(*argv, "NOCONFIG")) {
dbrename(*argv, DBG_SUBDIR_CLIENT);
}
argc--;
argv++;
/* parse backup program name */
if(g_str_equal(*argv, "DUMP")) {
#if !defined(DUMP) && !defined(XFSDUMP)
error("dump not available on this system");
/*NOTREACHED*/
#else
add_file_name = add_file_name_dump;
add_file = add_file_dump;
final_size = final_size_dump;
#endif
}
else if(g_str_equal(*argv, "BSDTAR")) {
add_file_name = add_file_name_gnutar;
add_file = add_file_gnutar;
final_size = final_size_gnutar;
use_gtar_excl++;
}
else if(g_str_equal(*argv, "GNUTAR")) {
#ifndef GNUTAR
error("gnutar not available on this system");
/*NOTREACHED*/
#else
add_file_name = add_file_name_gnutar;
add_file = add_file_gnutar;
final_size = final_size_gnutar;
use_gtar_excl++;
#endif
}
else {
add_file_name = add_file_name_unknown;
add_file = add_file_unknown;
final_size = final_size_unknown;
}
argc--, argv++;
/* the amanda name can be different from the directory name */
if (argc > 0) {
amname = *argv;
qamname = quote_string(amname);
argc--, argv++;
} else {
error("missing <name>");
/*NOTREACHED*/
}
/* the toplevel directory name to search from */
if (argc > 0) {
dirname = *argv;
argc--, argv++;
} else {
error("missing <dir>");
/*NOTREACHED*/
}
if ((argc > 1) && g_str_equal(*argv, "-X")) {
argv++;
if (!(use_gtar_excl || use_star_excl)) {
error("exclusion specification not supported");
/*NOTREACHED*/
}
filename = g_strdup(*argv);
qfilename = quote_string(filename);
if (access(filename, R_OK) != 0) {
g_fprintf(stderr,"Cannot open exclude file %s\n", qfilename);
use_gtar_excl = use_star_excl = 0;
} else {
exclude_sl = calc_load_file(filename);
if (!exclude_sl) {
g_fprintf(stderr,"Cannot open exclude file %s: %s\n", qfilename,
strerror(errno));
use_gtar_excl = use_star_excl = 0;
}
}
amfree(qfilename);
amfree(filename);
argc -= 2;
argv++;
} else {
use_gtar_excl = use_star_excl = 0;
}
if ((argc > 1) && g_str_equal(*argv, "-I")) {
argv++;
filename = g_strdup(*argv);
qfilename = quote_string(filename);
if (access(filename, R_OK) != 0) {
g_fprintf(stderr,"Cannot open include file %s\n", qfilename);
use_gtar_excl = use_star_excl = 0;
} else {
include_sl = calc_load_file(filename);
if (!include_sl) {
g_fprintf(stderr,"Cannot open include file %s: %s\n", qfilename,
strerror(errno));
use_gtar_excl = use_star_excl = 0;
}
}
amfree(qfilename);
amfree(filename);
argc -= 2;
argv++;
}
/* the dump levels to calculate sizes for */
ndumps = 0;
while(argc >= 2) {
if(ndumps < MAXDUMPS) {
dumplevel[ndumps] = atoi(argv[0]);
dumpdate [ndumps] = (time_t) atol(argv[1]);
ndumps++;
argc -= 2, argv += 2;
}
}
if(argc) {
error("leftover arg \"%s\", expected <level> and <date>", *argv);
/*NOTREACHED*/
}
if(is_empty_sl(include_sl)) {
traverse_dirs(dirname,".");
}
else {
sle_t *an_include = include_sl->first;
while(an_include != NULL) {
/*
char *adirname = stralloc2(dirname, an_include->name+1);
traverse_dirs(adirname);
amfree(adirname);
*/
traverse_dirs(dirname, an_include->name);
an_include = an_include->next;
}
}
for(i = 0; i < ndumps; i++) {
amflock(1, "size");
dbprintf("calcsize: %s %d SIZE %lld\n",
qamname, dumplevel[i],
(long long)final_size(i, dirname));
g_fprintf(stderr, "%s %d SIZE %lld\n",
qamname, dumplevel[i],
(long long)final_size(i, dirname));
fflush(stderr);
amfunlock(1, "size");
}
amfree(qamname);
return 0;
#endif
}