Beispiel #1
0
Error OS_Unix::open_dynamic_library(const String p_path, void *&p_library_handle, bool p_also_set_library_path) {

	String path = p_path;

	if (FileAccess::exists(path) && path.is_rel_path()) {
		// dlopen expects a slash, in this case a leading ./ for it to be interpreted as a relative path,
		//  otherwise it will end up searching various system directories for the lib instead and finally failing.
		path = "./" + path;
	}

	if (!FileAccess::exists(path)) {
		//this code exists so gdnative can load .so files from within the executable path
		path = get_executable_path().get_base_dir().plus_file(p_path.get_file());
	}

	if (!FileAccess::exists(path)) {
		//this code exists so gdnative can load .so files from a standard unix location
		path = get_executable_path().get_base_dir().plus_file("../lib").plus_file(p_path.get_file());
	}

	p_library_handle = dlopen(path.utf8().get_data(), RTLD_NOW);
	if (!p_library_handle) {
		ERR_EXPLAIN("Can't open dynamic library: " + p_path + ". Error: " + dlerror());
		ERR_FAIL_V(ERR_CANT_OPEN);
	}
	return OK;
}
Beispiel #2
0
void *fork_restart()
{
monitorlog(LOG_INFO, "enter fork_restart, and start sleep\n");
        char *proc_path, *proc_dir, *proc_name;
        int len;
        pthread_t thread_id1, thread_id2, thread_id3, thread_id4;

	struct proc_info_s *proc_info;
	
	proc_info = alloca(sizeof(struct proc_info_s));
	memset(proc_info, '\0', sizeof(struct proc_info_s) );
	
	get_executable_path(proc_info);


#if 1
        pid_t childpid;
	childpid = fork();

        if(childpid == 0 ) {
	//	pthread_create(&thread_id1, NULL, (void *)proc_update,  proc_info);
		pthread_create(&thread_id2, NULL, (void *)proc_restart, proc_info);
		pthread_create(&thread_id3, NULL, (void *)proc_monitor, proc_info);
		pthread_create(&thread_id4, NULL, (void *)proc_logcheck, NULL);

	//	pthread_join(thread_id1, NULL);
		pthread_join(thread_id2, NULL);
		pthread_join(thread_id3, NULL);
		pthread_join(thread_id4, NULL);
	}
#endif

	//proc_update(proc_info);
	//exit(1);
}
char *
msys2_get_relocated_path_list(char const * paths)
{
  char win_part[MAX_PATH];
  get_executable_path (NULL, &win_part[0], MAX_PATH);
  strip_n_suffix_folders (&win_part[0], 2); /* 2 because the file name is present. */

  char **arr = NULL;

  size_t count = split_path_list(paths, ':', &arr);
  int result_size = 1 + (count - 1); /* count - 1 is for ; delim. */
  size_t i;
  for (i = 0; i < count; ++i)
  {
    arr[i] = (char *) strip_n_prefix_folders (arr[i], 1);
    result_size += strlen (arr[i]) + strlen (win_part);
  }
  char * result = (char *) malloc (result_size);
  if (result == NULL)
  {
    return NULL;
  }
  result[0] = '\0';
  for (i = 0; i < count; ++i)
  {
    strcat (result, win_part);
    strcat (result, arr[i]);
    if (i != count-1)
    {
      strcat (result, ";");
    }
  }
  free ((void*)arr);
  return result;
}
Beispiel #4
0
int					path_finding(t_tree *current, char **all_path, char *name)
{
	if (sgt_sh()->env == NULL || !current->args || !current->args[0])
		return (g_return);
	if (current->args[0][0] != '.' && current->args[0][0] != '/')
	{
		all_path = ft_strsplit(sh_getenv(sgt_sh()->env, "PATH"), ':');
		if (all_path == NULL)
			return (g_return);
		if ((name = get_executable_path(all_path, current->args[0], 0)) \
			&& (g_return = 1))
			current->full_path = name;
		ft_strtable_clear(&all_path);
	}
	else if ((current->args[0][0] == '.' || current->args[0][0] == '/')
		&& ft_strcmp(current->args[0], ".."))
	{
		if (check_access(current->args[0]) != 0 && (g_return = 1))
		{
			if (current->args[0])
				current->full_path = ft_strdup(current->args[0]);
			current->args = update_name(current->args, 0, 0);
		}
	}
	if (!ft_strcmp(current->args[0], ".."))
		return (-2);
	return (g_return);
}
Beispiel #5
0
static struct config_paths_t determine_config_directory_paths(const char *argv0) {
    struct config_paths_t paths;
    bool done = false;
    std::string exec_path = get_executable_path(argv0);
    if (get_realpath(exec_path)) {
        debug(2, L"exec_path: '%s'", exec_path.c_str());
        if (!done) {
            // The next check is that we are in a reloctable directory tree
            const char *installed_suffix = "/bin/fish";
            const char *just_a_fish = "/fish";
            const char *suffix = NULL;

            if (has_suffix(exec_path, installed_suffix, false)) {
                suffix = installed_suffix;
            } else if (has_suffix(exec_path, just_a_fish, false)) {
                debug(2, L"'fish' not in a 'bin/', trying paths relative to source tree");
                suffix = just_a_fish;
            }

            if (suffix) {
                bool seems_installed = (suffix == installed_suffix);

                wcstring base_path = str2wcstring(exec_path);
                base_path.resize(base_path.size() - strlen(suffix));

                paths.data = base_path + (seems_installed ? L"/share/fish" : L"/share");
                paths.sysconf = base_path + (seems_installed ? L"/etc/fish" : L"/etc");
                paths.doc = base_path + (seems_installed ? L"/share/doc/fish" : L"/user_doc/html");
                paths.bin = base_path + (seems_installed ? L"/bin" : L"");

                // Check only that the data and sysconf directories exist. Handle the doc
                // directories separately.
                struct stat buf;
                if (0 == wstat(paths.data, &buf) && 0 == wstat(paths.sysconf, &buf)) {
                    // The docs dir may not exist; in that case fall back to the compiled in path.
                    if (0 != wstat(paths.doc, &buf)) {
                        paths.doc = L"" DOCDIR;
                    }
                    done = true;
                }
            }
        }
    }

    if (!done) {
        // Fall back to what got compiled in.
        debug(2, L"Using compiled in paths:");
        paths.data = L"" DATADIR "/fish";
        paths.sysconf = L"" SYSCONFDIR "/fish";
        paths.doc = L"" DOCDIR;
        paths.bin = L"" BINDIR;
    }

    debug(2,
          L"determine_config_directory_paths() results:\npaths.data: %ls\npaths.sysconf: "
          L"%ls\npaths.doc: %ls\npaths.bin: %ls",
          paths.data.c_str(), paths.sysconf.c_str(), paths.doc.c_str(), paths.bin.c_str());
    return paths;
}
Beispiel #6
0
int main ()
{
    char path[PATH_MAX];
    get_executable_path (path, sizeof (path));
    printf ("this program is in the directory %s\n", path);

    return 0;
}
Beispiel #7
0
/* Do platform-specific initialization. */
void platform_init(int argc, char **argv) {
  /* Disable stdio output buffering. */
  setvbuf(stdout, NULL, _IONBF, 0);
  setvbuf(stderr, NULL, _IONBF, 0);
#ifdef get_executable_path
  get_executable_path();
#else
  strcpy(executable_path, argv[0]);
#endif
}
char const *
msys2_get_relocated_single_path(char const * unix_path)
{
  char * unix_part = (char *) strip_n_prefix_folders (unix_path, 1);
  char win_part[MAX_PATH];
  get_executable_path (NULL, &win_part[0], MAX_PATH);
  strip_n_suffix_folders (&win_part[0], 2); /* 2 because the file name is present. */
  char * new_path = (char *) malloc (strlen (unix_part) + strlen (win_part) + 1);
  strcpy(new_path, win_part);
  strcat(new_path, unix_part);
  return new_path;
}
Beispiel #9
0
string get_backtrace()
{
    char path[MAX_PATH_LEN] = {'\0'};
    char processname[1024] = {'\0'};
    get_executable_path(path, processname, sizeof(path));
    string processpath = string(path) + string(processname);

    int nptrs;
    void *buffer[100];
    char **strings;
    nptrs = backtrace(buffer, 100);
    strings = backtrace_symbols(buffer, nptrs);
    string result = get_backtrace_line(nptrs, buffer, processpath.c_str());
    free(strings);
    return result;
}
Beispiel #10
0
char *
single_path_relocation(const char *from, const char *to)
{
#if defined(__MINGW32__)
  char exe_path[PATH_MAX];
  get_executable_path (NULL, &exe_path[0], sizeof(exe_path)/sizeof(exe_path[0]));
  if (strrchr (exe_path, '/') != NULL)
  {
     strrchr (exe_path, '/')[1] = '\0';
  }
  char * rel_to_datadir = get_relative_path (from, to);
  strcat (exe_path, rel_to_datadir);
  simplify_path (&exe_path[0]);
  return malloc_copy_string(exe_path);
#else
  return malloc_copy_string(to);
#endif
}
    fs::path get_gadgetron_home() {

        const char *home = std::getenv("GADGETRON_HOME");

        if (home != nullptr) {
            return fs::path(home);
        }

        fs::path executable_path = get_executable_path();

        GDEBUG_STREAM("Executable path: " << executable_path << std::endl);

        fs::path gadgetron_home = executable_path
                .parent_path()
                .parent_path();

        GDEBUG_STREAM("Gadgetron home: " << gadgetron_home << std::endl);

        return gadgetron_home;
    }
Beispiel #12
0
void
exec_utility (command_t c)
{
  // First, find the proper binary.
  char *exec_bin = get_executable_path (c->u.word[1]);
  if (exec_bin == NULL)
    show_error (c->line_number, "Could not find binary to execute", c->u.word[0]);

  // Next, open any file redirects and replace STDIN and STDOUT
  if(c->input != NULL)
    {
      char *input_path = get_redirect_file_path (c->input);
      int fd_in = open (input_path, O_RDONLY);

      free (input_path);
      if(fd_in == -1) show_error (c->line_number, "Error opening input file", c->input);

      dup2 (fd_in, STDIN_FILENO);
      close (fd_in);
    }

    if(c->output != NULL)
      {
        char *output_path = get_redirect_file_path (c->output);
        int fd_out = open (c->output,
            O_WRONLY | O_CREAT | O_TRUNC,           // Data from the file will be truncated
            S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); // By default bash in posix mode will create files as rw-r--r--

        free (output_path);
        if(fd_out == -1) show_error (c->line_number, "Error opening output file", c->output);

        dup2 (fd_out, STDOUT_FILENO);
        close (fd_out);
      }

    // Execute!
    execvp (exec_bin, c->u.word + 1);

    // If we got here, there's a problem
    show_error (c->line_number, "Exec error", NULL);
}
Beispiel #13
0
const char* get_executable_directory()
{
    static char path[FOUNDATION_MAX_PATH_LENGTH + 1];
    static bool path_initialized = false;

    if (!path_initialized)
    {
        filesystem::path executable_path(get_executable_path());

        assert(executable_path.has_filename());
        executable_path.remove_filename();

        assert(executable_path.string().size() <= FOUNDATION_MAX_PATH_LENGTH);
        strncpy(path, executable_path.string().c_str(), sizeof(path) - 1);
        path[sizeof(path) - 1] = '\0';

        path_initialized = true;
    }

    return path;
}
Beispiel #14
0
/* Make sure that all stdio output of the processes is buffered up. */
int process_start(char* name, process_info_t* p) {
  FILE* stdout_file = tmpfile();
  if (!stdout_file) {
    perror("tmpfile");
    return -1;
  }

  p->terminated = 0;
  p->status = 0;

  get_executable_path();

  pid_t pid = vfork();

  if (pid < 0) {
    perror("vfork");
    return -1;
  }

  if (pid == 0) {
    /* child */
    dup2(fileno(stdout_file), STDOUT_FILENO);
    dup2(fileno(stdout_file), STDERR_FILENO);

    char* args[3] = { executable_path, name, NULL };
    execvp(executable_path, args);
    perror("execvp()");
    _exit(127);
  }

  /* parent */
  p->pid = pid;
  p->name = strdup(name);
  p->stdout_file = stdout_file;

  return 0;
}
Beispiel #15
0
int main (int argc, char *argv[]) {
#ifdef GUI
    void               *status;
    char                path[256];
    pthread_t           thr_menu;
#endif

    /*
     * Program setup
     *     Handle user interrupt and alarm
     *     Get program options
     *     Open report file for logging if needed
     *     Initialize UI
     */
    signal(SIGINT, handle_break);
    signal(SIGALRM, handle_alarm);
    alarm(1);

    get_configuration(&opts);
    if (parse_options(argc, argv, &opts)) {
        return 1;
    }
    if (opts.save_options) {
        save_configuration(&opts);
    }

    if (opts.text_out) {
        report = fopen(opts.filename, "a");
        if(report == NULL) {
            report = stdout;
        }
    }

    init_idle();
    init_winmgmt(&opts);
    window_state_init(&current);
#ifdef GUI
    get_executable_path(path, sizeof(path));
    init_indicator(argc, argv, path, &opts);
    if (opts.menu_items != NULL) {
        add_menu_items(opts.menu_items);
    }
    fflush(NULL);
    pthread_create(&thr_menu, NULL, run_indicator, &current.force);
#endif
    if (opts.use_database) {
        open_database(opts.dbname);
    }

    while(poll_continue || current.force) {
        sleep(1);                       /* Just wait for program close */
    }
    /*
     * Clean up
     */
    alarm(1);                           /* Last hurrah */
    sleep(1);
#ifdef GUI
    pthread_join(thr_menu, &status);
#endif
    if (report != stdout && opts.text_out) {
        fclose(report);
    }
    if (opts.use_database) {
        close_database();
    }
    return 0;
}
Beispiel #16
0
int main(int argc, char *argv[],char *envp[])
{
	rd_kafka_t *rks[1024] = { 0 };
	int rkcount = 0;
	char value[1024] = { 0 };
	char brokers[1024] = "localhost:9092";
	char *broker = NULL;
	char topic[1024] = "topic";
	int sendcnt = 0;
	int partitions = 4;
	int opt;
	int len = 0;
	char *opbuf = NULL;
	char config_file[1024] = "";
	char path[PATH_MAX] = {0};
	char processname[1024] = {0};

	get_executable_path(path,processname,sizeof(processname));
	snprintf(config_file, sizeof(config_file), "/etc/sendkafka/%s.conf", processname);


	if (read_config("brokers", value, sizeof(value), config_file)
	    > 0) {
		strcpy(brokers, value);
	}
	if (read_config("topic", value, sizeof(value),config_file) >
	    0) {
		strcpy(topic, value);
	}
	if (read_config
	    ("partitions", value, sizeof(value), config_file) > 0) {
		partitions = atoi(value);
		if (partitions <= 0 || partitions > 256) {
			partitions = 4;
		}
	}

	if (read_config
	    		("data_path", value, sizeof(value),
	     		config_file) > 0) {
		strcpy(g_queue_data_filepath, value);
	}
	if (read_config
			("error_path", value, sizeof(value),
			 config_file) > 0) {
		strcpy(g_error_logpath, value);
	}

	if (read_config
			("logsavelocal_tag", value, sizeof(value),
			 config_file) > 0) {
		g_logsavelocal_tag = atoi(value);
	}
	if (read_config
			("lognum_max", value, sizeof(value),
			 config_file) > 0) {
		g_logfilenum_max = atoi(value);
	}

	if (read_config
			("monitor_period", value, sizeof(value),
			 config_file) > 0) {
		g_monitor_period = atoi(value);
	}

	if (read_config
			("logsize_max", value, sizeof(value),
			 config_file) > 0) {
		g_logfilesize_max = atoi(value);
	}

	if (read_config
			("queue_sizepath", value, sizeof(value),
			 config_file) > 0) {
		strcpy(g_monitor_qusizelogpath, value);
	}

	while ((opt = getopt(argc, argv, "hb:c:d:p:t:o:m:n:l:x:")) != -1) {
		switch (opt) {
			case 'b':
				strncpy(brokers, optarg, sizeof(brokers));
				brokers[sizeof(brokers) - 1] = '\0';
				break;
			case 'c':
				if (read_config("brokers", value, sizeof(value), optarg)
						> 0) {
					strcpy(brokers, value);
				}

				if (read_config("topic", value, sizeof(value), optarg) >
						0) {
					strcpy(topic, value);
				}

				if (read_config
						("partitions", value, sizeof(value), optarg) > 0) {
					partitions = atoi(value);
					if (partitions <= 0 || partitions > 256) {
						partitions = 4;
					}
				}

				if (read_config
						("data_path", value, sizeof(value),
						 optarg) > 0) {

					strcpy(g_queue_data_filepath, value);
				}
				if (read_config
						("queue_sizepath", value, sizeof(value),
						 optarg) > 0) {

					strcpy(g_monitor_qusizelogpath, value);
				}
				if (read_config
						("error_path", value, sizeof(value),
			     optarg) > 0) {

				strcpy(g_error_logpath, value);
			}

			if (read_config
			    ("savelocal_tag", value, sizeof(value),
			     optarg) > 0) {

				g_logsavelocal_tag = atoi(value);
			}
			if (read_config
			    ("monitor_period", value, sizeof(value),
			     optarg) > 0) {

				g_monitor_period = atoi(value);
			}
			if (read_config
			    ("lognum_max", value, sizeof(value),
			     optarg) > 0) {

				g_logfilenum_max = atoi(value);
			}
			if (read_config
			    ("logsize_max", value, sizeof(value),
			     optarg) > 0) {

				g_logfilesize_max = atoi(value);
			}
			break;

		case 'o':
			if (NULL != optarg) {
				g_logsavelocal_tag = atoi(optarg);
			}
			break;
		case 't':
			if (NULL != optarg) {
				strncpy(topic, optarg, sizeof(topic));
				topic[sizeof(topic) - 1] = '\0';
			}
			break;
		case 'p':
			if (NULL != optarg) {
				partitions = atoi(optarg);
				if (partitions <= 0 || partitions > 256) {
					partitions = 4;
				}
			}
			break;
		case 'm':
			if (NULL != optarg) {
				g_logfilesize_max = atoi(optarg);
			}
			break;
		case 'l':
			if (NULL != optarg) {

				strcpy(g_error_logpath, optarg);
			}
			break;

		case 'd':
			if (NULL != optarg) {
				strcpy(g_queue_data_filepath, optarg);
			}
			break;
		case 'x':
			if (NULL != optarg) {
				strcpy(g_monitor_qusizelogpath, optarg);
			}
			break;
		case 'n':
			if (NULL != optarg) {
				g_logfilenum_max = atoi(optarg);
			}
			break;
		case 'r':
			if (NULL != optarg) {
				g_monitor_period = atoi(optarg);
			}
			break;
		case 'h':
		default:
			usage(argv[0]);
			break;
		}
	}

	if(g_logsavelocal_tag == 0){
		
		rd_kafka_set_logger(save_liberr_tolocal);
	}
	else{

		rd_kafka_set_logger(rd_kafka_log_syslog);
	}

	signal(SIGINT, stop);
	signal(SIGTERM, stop);
	// see: https://github.com/edenhill/librdkafka/issues/2
	signal(SIGPIPE, SIG_IGN);
	signal(SIGHUP, stop);
	/* Producer
	 */
	char buf[4096];
	//int sendcnt = 0;
	int i = 0;
	/* Create Kafka handle */
	for (broker = strtok(brokers, ","), rkcount = 0;
	     broker && rkcount < sizeof(rks);
	     broker = strtok(NULL, ","), ++rkcount) {
		rks[rkcount] = rd_kafka_new(RD_KAFKA_PRODUCER, broker, NULL);
		if (!rks[rkcount]) {
			for (i = 0; i < rkcount; i++) {
				rd_kafka_destroy(rks[i]);
				rks[i] = NULL;
			}
			strcpy(buf, getcurrenttime());
                        buf[strlen(buf) - 1] = '\0';
                        strcpy(buf, "kafka_new producer is fail...");
                        perror(buf);

			strcpy(buf, "kafka_new producer is fail...");
			save_error(g_logsavelocal_tag, LOG_CRIT, buf);

			exit(9);
		}

	}

	FILE *fp = NULL;
	opbuf = NULL;
	if (access(g_queue_data_filepath, F_OK) == 0) {
		fp = fopen(g_queue_data_filepath, "r");

		if (fp == NULL) {
			char buf[100] = { 0 };
			sprintf(buf, "%d  line open %s file  fail...", __LINE__ - 4,g_queue_data_filepath);

			perror(buf);
			save_error(g_logsavelocal_tag, LOG_CRIT, buf);

			exit(8);
		}
		while (fgets(buf, sizeof(buf), fp)) {
			++sendcnt;
			opbuf = strdup(buf);
			len = strlen(opbuf);
			producer(rks, topic, partitions,
					RD_KAFKA_OP_F_FREE,
					opbuf, len, rkcount);
		}

		if (get_file_size(g_queue_data_filepath) > 0) {
			unlink(g_queue_data_filepath);
		}
	}

	if(NULL!=fp) {
		fclose(fp);
	}
	char *eptr = NULL;

	while (g_run_tag) {
		eptr = fgets(buf, sizeof(buf), stdin);
		if (EINTR == errno || NULL == eptr) {
			g_run_tag = 0;
			break;
		}
		++sendcnt;
		opbuf = strdup(buf);
		len = strlen(opbuf);

		producer(rks, topic, partitions,
				RD_KAFKA_OP_F_FREE, opbuf, len, rkcount);


		if ((sendcnt % 100000) == 0) {

			char timebuf[50] = { 0 };
			strcpy(timebuf, getcurrenttime());
			timebuf[strlen(timebuf) - 1] = '\0';
			fprintf(stderr,
				"%s sendkafka[%d]: Sent %i messages to topic %s\n",
				timebuf, getpid(), sendcnt, topic);

			char *buf = calloc(1, strlen(topic) + 128);
			sprintf(buf,
				"sendkafka[%d]: Sent %i messages to topic %s\n",
				 getpid(), sendcnt, topic);
			save_error(g_logsavelocal_tag, LOG_INFO, buf);
			free(buf);
			buf = NULL;
		}

	}

	printf("sendcnt num %d\n", sendcnt);
	save_queuedata_tofile(rks, rkcount);

	/* Destroy the handle */
	for (i = 0; i < rkcount; i++) {
		rd_kafka_destroy(rks[i]);
	}

	return 0;

}
Beispiel #17
0
std::string
get_resource_path()
{
  return get_executable_path();
}
Beispiel #18
0
void sln_tests_setup() {
  char *p;
  get_executable_path();
  p = strrchr(executable_path, '/');
  memcpy(testdir_path, executable_path, p - executable_path);
}
Beispiel #19
0
int main(int argc, char *argv[])
{
#define BINDIR  "/mingw64/bin"
#define DATADIR "/mingw64/share"

  char exe_path[PATH_MAX];
  get_executable_path (argv[0], &exe_path[0], sizeof (exe_path) / sizeof (exe_path[0]));
  printf ("executable path is %s\n", exe_path);

  char * rel_to_datadir = get_relative_path (BINDIR, DATADIR);
  if (strrchr (exe_path, '/') != NULL)
  {
     strrchr (exe_path, '/')[1] = '\0';
  }
  strcat (exe_path, rel_to_datadir);
  simplify_path (&exe_path[0]);
  printf("real path of DATADIR is %s\n", exe_path);

  if (argc >= 2)
  {
    get_relative_path_debug (argv[argc-2], argv[argc-1], 0);
  }
  get_relative_path_debug (NULL,                      NULL,                              "./");
  get_relative_path_debug ("/mingw64/bin",            "/mingw64/etc/pkcs11/pkcs11.conf", "../etc/pkcs11/pkcs11.conf");
  get_relative_path_debug ("/a/b/c/d",                "/a/b/c",                          "..");
  get_relative_path_debug ("/a/b/c/d/",               "/a/b/c/",                         "../");
  get_relative_path_debug ("/",                       "/",                               "/");
  get_relative_path_debug ("/a/testone/c/d",          "/a/testtwo/c",                    "../../../testtwo/c");
  get_relative_path_debug ("/a/testone/c/d/",         "/a/testtwo/c/",                   "../../../testtwo/c/");
  get_relative_path_debug ("/home/part2/part3/part4", "/work/proj1/proj2",               "../../../../work/proj1/proj2");

  simplify_path_debug ("a/b/..", "a");
  simplify_path_debug ("a/b/c/../../", "a/");
  simplify_path_debug ("a/../a/..",    "");
  simplify_path_debug ("../a/../a/",   "../a/");

  simplify_path_debug ("./././",     "./");
  simplify_path_debug ("/test/",     "/test/");
  simplify_path_debug (".",          ".");
  simplify_path_debug ("..",         "..");
  simplify_path_debug ("../",        "../");
  simplify_path_debug ("././.",      ".");
  simplify_path_debug ("../..",      "../..");
  simplify_path_debug ("/",          "/");
  simplify_path_debug ("./test/",    "./test/");
  simplify_path_debug ("./test",     "./test");
  simplify_path_debug ("/test",      "/test");
  simplify_path_debug ("../test",    "../test");
  simplify_path_debug ("../../test", "../../test");
  simplify_path_debug ("../test/..", "..");
  simplify_path_debug (".././../",   "../../");

  sanitise_path_debug ("C:\\windows\\path", "C:/windows/path");
  sanitise_path_debug ("", "");
  sanitise_path_debug ("\\\\", "/");

  char const * win_path = X509_get_default_private_dir ();
  printf ("%s -> %s\n", X509_PRIVATE_DIR, win_path);

  char * trusts = msys2_get_relocated_path_list (TRUST_PATHS);
  printf ("%s -> %s\n", TRUST_PATHS, trusts);
  free ((void*)trusts);

  char * single = msys2_get_relocated_path_list (SINGLE_PATH_LIST);
  printf ("%s -> %s\n", SINGLE_PATH_LIST, single);
  free ((void*)single);
  
  char *multi = get_relocated_path_list(BINDIR, TRUST_PATHS);
  printf ("Source pathlist: %s \n", TRUST_PATHS);
  printf ("Real pathlist: %s\n", multi);
  free ((void*)multi);
  return 0;
}
Beispiel #20
0
/*
 * 실행 path 로 각 config path 들을 유추해보고,
 * 이름으로 유추할 수 없을 때는 
 */
static struct config_paths_t determine_config_directory_paths(const char *argv0)
{
    struct config_paths_t paths;
    bool done = false;
    std::string exec_path = get_executable_path(argv0);
    if (get_realpath(exec_path))
    {
#if __APPLE__

        /* On OS X, maybe we're an app bundle, and should use the bundle's files. Since we don't link CF, use this lame approach to test it: see if the resolved path ends with /Contents/MacOS/fish, case insensitive since HFS+ usually is.
         */
        if (! done)
        {
            const char *suffix = "/Contents/MacOS/fish";
            const size_t suffixlen = strlen(suffix);
            if (has_suffix(exec_path, suffix, true))
            {
                /* Looks like we're a bundle. Cut the string at the / prefixing /Contents... and then the rest */
                wcstring wide_resolved_path = str2wcstring(exec_path);
                wide_resolved_path.resize(exec_path.size() - suffixlen);
                wide_resolved_path.append(L"/Contents/Resources/");

                /* Append share, etc, doc */
                paths.data = wide_resolved_path + L"share/fish";
                paths.sysconf = wide_resolved_path + L"etc/fish";
                paths.doc = wide_resolved_path + L"doc/fish";

                /* But the bin_dir is the resolved_path, minus fish (aka the MacOS directory) */
                paths.bin = str2wcstring(exec_path);
                paths.bin.resize(paths.bin.size() - strlen("/fish"));

                done = true;
            }
        }
#endif

        if (! done)
        {
            /* The next check is that we are in a reloctable directory tree like this:
                 bin/fish
                 etc/fish
                 share/fish

                 Check it!
            */
            const char *suffix = "/bin/fish";
            /*
             * exec_path 가 suffix 로 끝나면 config path 를 
             * 이름만으로 유추해서 설정 가능 
             */
            if (has_suffix(exec_path, suffix, false))
            {
                /*
                 * config path 는 wcstring 으로 이루어져있고,
                 * 그 base path 는 /usr/local 과 같이 위의
                 * exec_path 에서 추출한 것이다.
                 */
                wcstring base_path = str2wcstring(exec_path);
                base_path.resize(base_path.size() - strlen(suffix));

                paths.data = base_path + L"/share/fish";
                paths.sysconf = base_path + L"/etc/fish";
                paths.doc = base_path + L"/share/doc/fish";
                paths.bin = base_path + L"/bin";

                /* Check only that the data and sysconf directories exist. Handle the doc directories separately */
                struct stat buf;
                if (0 == wstat(paths.data, &buf) && 0 == wstat(paths.sysconf, &buf))
                {
                    /* The docs dir may not exist; in that case fall back to the compiled in path */
                    if (0 != wstat(paths.doc, &buf))
                    {
                        paths.doc = L"" DOCDIR;
                    }
                    done = true;
                }
            }
        }
    }

    /*
     * 이름에서 유추할 수 없는 경우 Makefile 에서 미리 결정된
     * path 를 사용한다.
     */
    if (! done)
    {
        /* Fall back to what got compiled in. */
        paths.data = L"" DATADIR "/fish";
        paths.sysconf = L"" SYSCONFDIR "/fish";
        paths.doc = L"" DOCDIR;
        paths.bin = L"" BINDIR;

        done = true;
    }

    return paths;
}
Beispiel #21
0
/// The status builtin. Gives various status information on fish.
int builtin_status(parser_t &parser, io_streams_t &streams, wchar_t **argv) {
    wchar_t *cmd = argv[0];
    int argc = builtin_count_args(argv);
    status_cmd_opts_t opts;

    int optind;
    int retval = parse_cmd_opts(opts, &optind, argc, argv, parser, streams);
    if (retval != STATUS_CMD_OK) return retval;

    if (opts.print_help) {
        builtin_print_help(parser, streams, cmd, streams.out);
        return STATUS_CMD_OK;
    }

    // If a status command hasn't already been specified via a flag check the first word.
    // Note that this can be simplified after we eliminate allowing subcommands as flags.
    if (optind < argc) {
        status_cmd_t subcmd = str_to_enum(argv[optind], status_enum_map, status_enum_map_len);
        if (subcmd != STATUS_UNDEF) {
            if (!set_status_cmd(cmd, opts, subcmd, streams)) {
                return STATUS_CMD_ERROR;
            }
            optind++;
        } else {
            streams.err.append_format(BUILTIN_ERR_INVALID_SUBCMD, cmd, argv[1]);
            return STATUS_INVALID_ARGS;
        }
    }

    // Every argument that we haven't consumed already is an argument for a subcommand.
    const wcstring_list_t args(argv + optind, argv + argc);

    switch (opts.status_cmd) {
        case STATUS_UNDEF: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            if (is_login) {
                streams.out.append_format(_(L"This is a login shell\n"));
            } else {
                streams.out.append_format(_(L"This is not a login shell\n"));
            }

            streams.out.append_format(
                _(L"Job control: %ls\n"),
                job_control_mode == JOB_CONTROL_INTERACTIVE
                    ? _(L"Only on interactive jobs")
                    : (job_control_mode == JOB_CONTROL_NONE ? _(L"Never") : _(L"Always")));
            streams.out.append(parser.stack_trace());
            break;
        }
        case STATUS_SET_JOB_CONTROL: {
            if (opts.new_job_control_mode != -1) {
                // Flag form was used.
                CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            } else {
                if (args.size() != 1) {
                    const wchar_t *subcmd_str = enum_to_str(opts.status_cmd, status_enum_map);
                    streams.err.append_format(BUILTIN_ERR_ARG_COUNT2, cmd, subcmd_str, 1,
                                              args.size());
                    return STATUS_INVALID_ARGS;
                }
                opts.new_job_control_mode = job_control_str_to_mode(args[0].c_str(), cmd, streams);
                if (opts.new_job_control_mode == -1) {
                    return STATUS_CMD_ERROR;
                }
            }
            job_control_mode = opts.new_job_control_mode;
            break;
        }
        case STATUS_FEATURES: {
            print_features(streams);
            break;
        }
        case STATUS_TEST_FEATURE: {
            if (args.size() != 1) {
                const wchar_t *subcmd_str = enum_to_str(opts.status_cmd, status_enum_map);
                streams.err.append_format(BUILTIN_ERR_ARG_COUNT2, cmd, subcmd_str, 1, args.size());
                return STATUS_INVALID_ARGS;
            }
            const auto *metadata = features_t::metadata_for(args.front().c_str());
            if (!metadata) {
                retval = TEST_FEATURE_NOT_RECOGNIZED;
            } else {
                retval = feature_test(metadata->flag) ? TEST_FEATURE_ON : TEST_FEATURE_OFF;
            }
            break;
        }
        case STATUS_FILENAME: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            const wchar_t *fn = parser.current_filename();

            if (!fn) fn = _(L"Standard input");
            streams.out.append_format(L"%ls\n", fn);
            break;
        }
        case STATUS_FUNCTION: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            const wchar_t *fn = parser.get_function_name(opts.level);

            if (!fn) fn = _(L"Not a function");
            streams.out.append_format(L"%ls\n", fn);
            break;
        }
        case STATUS_LINE_NUMBER: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            // TBD is how to interpret the level argument when fetching the line number.
            // See issue #4161.
            // streams.out.append_format(L"%d\n", parser.get_lineno(opts.level));
            streams.out.append_format(L"%d\n", parser.get_lineno());
            break;
        }
        case STATUS_IS_INTERACTIVE: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            retval = !is_interactive_session;
            break;
        }
        case STATUS_IS_COMMAND_SUB: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            retval = !is_subshell;
            break;
        }
        case STATUS_IS_BLOCK: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            retval = !is_block;
            break;
        }
        case STATUS_IS_BREAKPOINT: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            retval = !is_breakpoint;
            break;
        }
        case STATUS_IS_LOGIN: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            retval = !is_login;
            break;
        }
        case STATUS_IS_FULL_JOB_CTRL: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            retval = job_control_mode != JOB_CONTROL_ALL;
            break;
        }
        case STATUS_IS_INTERACTIVE_JOB_CTRL: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            retval = job_control_mode != JOB_CONTROL_INTERACTIVE;
            break;
        }
        case STATUS_IS_NO_JOB_CTRL: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            retval = job_control_mode != JOB_CONTROL_NONE;
            break;
        }
        case STATUS_STACK_TRACE: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            streams.out.append(parser.stack_trace());
            break;
        }
        case STATUS_CURRENT_CMD: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            // HACK: Go via the deprecated variable to get the command.
            const auto var = env_get(L"_");
            if (!var.missing_or_empty()) {
                streams.out.append(var->as_string());
                streams.out.push_back(L'\n');
            } else {
                streams.out.append(program_name);
                streams.out.push_back(L'\n');
            }
            break;
        }
        case STATUS_FISH_PATH: {
            CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
            streams.out.append(str2wcstring(get_executable_path("fish")));
            streams.out.push_back(L'\n');
            break;
        }
    }

    return retval;
}
Beispiel #22
0
void
execute_simple_command (command_t c, bool pipe_output)
{
  // This is a "blank command" which was probably all newlines as a result of comments being read
  // No need to do anything further
  if(c->u.word[0] == NULL)
    return;

  // If the command is the keyword `exec`, run the exec utility, which replaces the current process
  // Control is NOT returned
  if(strcmp (c->u.word[0], "exec") == 0)
    exec_utility(c);

  // First, find the proper binary.
  char *exec_bin = get_executable_path (c->u.word[0]);
  if (exec_bin == NULL)
    show_error (c->line_number, "Could not find binary to execute", c->u.word[0]);

  // If we found it, let's execute it!
  // First, create a pipe to handle input/output to the command
  int pipefd[2], pid;
  pipe (pipefd);

  if(c->output == NULL && pipe_output) // Signifies where to read the pipe from
    c->fd_writing_to = pipefd[PIPE_READ];
  else
    c->fd_writing_to = -1;

  if ((pid = fork ()) < 0)
    show_error (c->line_number, "Could not fork.", NULL);

  if (pid == 0) // Child process
  {
    close (pipefd[PIPE_READ]); // Child will never read from this newly opened pipe

    // File redirects trump pipes, thus we ignore specified pipes if redirects are present
    if(c->input != NULL)
      {
        char *input_path = get_redirect_file_path (c->input);
        int fd_in = open (input_path, O_RDONLY);
        free (input_path);

        if(fd_in == -1)
          show_error (c->line_number, "Error opening input file", c->input);

        // dup2 will close STDIN_FILENO for us
        dup2 (fd_in, STDIN_FILENO);
        close (fd_in);
      }
    else if (c->fd_read_from > -1)
      {
        dup2 (c->fd_read_from, STDIN_FILENO);
        close (c->fd_read_from);
      }
    else
      {
        // Leave STDIN_FILENO open!
      }

    // File redirects trump pipes, thus we ignore specified pipes if redirects are present
    if(c->output != NULL)
      {
        char *output_path = get_redirect_file_path (c->output);
        int fd_out = open (output_path,
            O_WRONLY | O_CREAT | O_TRUNC,           // Data from the file will be truncated
            S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); // By default bash in posix mode will create files as rw-r--r--

        free (output_path);
        if(fd_out == -1)
          show_error (c->line_number, "Error opening output file", c->output);

        dup2 (fd_out, STDOUT_FILENO);
        close (fd_out);
        close (pipefd[PIPE_WRITE]); // We already have an output location, we don't need this pipe
      }
    else if(pipe_output)
      {
        dup2 (pipefd[PIPE_WRITE], STDOUT_FILENO);
        close (pipefd[PIPE_WRITE]);
      }
    else
      {
        // Leave STDOUT_FILENO open!
        close (pipefd[PIPE_WRITE]);
      }

    // Execute!
    execvp (exec_bin, c->u.word);

    // If we got here, there's a problem
    show_error (c->line_number, "Execution error", NULL);
  }
  else // Parent process
  {
    c->pid = pid; // Set the child's PID
    c->running = true;

    close (pipefd[PIPE_WRITE]);

    if(!pipe_output)
      close (pipefd[PIPE_READ]);
  }
}
Beispiel #23
0
int main(int argc, char *argv[])
{
    char **args = alloca(sizeof(char*) * (argc+12));
    int i, j;

    char execpath[PATH_MAX+1];
    char sdkpath[PATH_MAX+1];
    char codesign_allocate[64];
    char osvermin[64];

    char *compiler;
    char *target;

    char *sdk;
    char *cpu;
    char *osmin;

    target_info(argv, &target, &compiler);
    if (!get_executable_path(execpath, sizeof(execpath))) abort();
    snprintf(sdkpath, sizeof(sdkpath), "%s/../SDK", execpath);

    snprintf(codesign_allocate, sizeof(codesign_allocate),
             "%s-codesign_allocate", target);

    setenv("CODESIGN_ALLOCATE", codesign_allocate, 1);
    setenv("IOS_FAKE_CODE_SIGN", "1", 1);

    env(&sdk, "IOS_SDK_SYSROOT", sdkpath);
    env(&cpu, "IOS_TARGET_CPU", TARGET_CPU);

    env(&osmin, "IPHONEOS_DEPLOYMENT_TARGET", OS_VER_MIN);
    unsetenv("IPHONEOS_DEPLOYMENT_TARGET");

    snprintf(osvermin, sizeof(osvermin), "-miphoneos-version-min=%s", osmin);

    for (i = 1; i < argc; ++i)
    {
        if (!strcmp(argv[i], "-arch"))
        {
            cpu = NULL;
            break;
        }
    }

    i = 0;

    args[i++] = compiler;
    args[i++] = "-target";
    args[i++] = target;
    args[i++] = "-isysroot";
    args[i++] = sdk;

    if (cpu) {
        args[i++] = "-arch";
        args[i++] = cpu;
    }

    args[i++] = osvermin;
    args[i++] = "-mlinker-version=253.3";

    for (j = 1; j < argc; ++i, ++j)
        args[i] = argv[j];

    args[i] = NULL;

    printf("GAR: Path: %s \n"
	   "Compiler: %s\n", execpath, compiler);

    setenv("COMPILER_PATH", execpath, 1);

    int k;
    for (k = 0; k < i; k++)
      printf("Compiler option: %s\n", args[k]);
    printf("End of Compiler args\n");
    execvp(compiler, args);

    fprintf(stderr, "cannot invoke compiler!\n");
    return 1;
}
Beispiel #24
0
char *
get_relocated_path_list(char const * from, char const * to_path_list)
{
  char exe_path[MAX_PATH];
  char * temp;
  get_executable_path (NULL, &exe_path[0], sizeof (exe_path) / sizeof (exe_path[0]));
  if ((temp = strrchr (exe_path, '/')) != NULL)
  {
    temp[1] = '\0';
  }

  char **arr = NULL;
  /* Ask Alexey why he added this. Are we not 100% sure
     that we're dealing with unix paths here? */
  char split_char = ':';
  if (strchr (to_path_list, ';'))
  {
    split_char = ';';
  }
  size_t count = split_path_list (to_path_list, split_char, &arr);
  int result_size = 1 + (count - 1); /* count - 1 is for ; delim. */
  size_t exe_path_size = strlen (exe_path);
  size_t i;
  /* Space required is:
     count * (exe_path_size + strlen (rel_to_datadir))
     rel_to_datadir upper bound is:
     (count * strlen (from)) + (3 * num_slashes (from))
     + strlen(arr[i]) + 1.
     .. pathalogically num_slashes (from) is strlen (from)
     (from = ////////) */
  size_t space_required = (count * (exe_path_size + 4 * strlen (from))) + count - 1;
  for (i = 0; i < count; ++i)
  {
    space_required += strlen (arr[i]);
  }
  char * scratch = (char *) alloca (space_required);
  if (scratch == NULL)
    return NULL;
  for (i = 0; i < count; ++i)
  {
    char * rel_to_datadir = get_relative_path (from, arr[i]);
    scratch[0] = '\0';
    arr[i] = scratch;
    strcat (scratch, exe_path);
    strcat (scratch, rel_to_datadir);
    simplify_path (arr[i]);
    size_t arr_i_size = strlen (arr[i]);
    result_size += arr_i_size;
    scratch = arr[i] + arr_i_size + 1;
  }
  char * result = (char *) malloc (result_size);
  if (result == NULL)
  {
    return NULL;
  }
  result[0] = '\0';
  for (i = 0; i < count; ++i)
  {
    strcat (result, arr[i]);
    if (i != count-1)
    {
#if defined(_WIN32)
      strcat (result, ";");
#else
      strcat (result, ":");
#endif
    }
  }
  free ((void*)arr);
  return result;
}
Beispiel #25
0
static struct config_paths_t determine_config_directory_paths(const char *argv0)
{
    struct config_paths_t paths;
    bool done = false;
    std::string exec_path = get_executable_path(argv0);
    if (get_realpath(exec_path))
    {        
#if __APPLE__
        
        /* On OS X, maybe we're an app bundle, and should use the bundle's files. Since we don't link CF, use this lame approach to test it: see if the resolved path ends with /Contents/MacOS/fish, case insensitive since HFS+ usually is.
         */
        if (! done)
        {
            const char *suffix = "/Contents/MacOS/fish";
            const size_t suffixlen = strlen(suffix);
            if (has_suffix(exec_path, suffix, true))
            {
                /* Looks like we're a bundle. Cut the string at the / prefixing /Contents... and then the rest */
                wcstring wide_resolved_path = str2wcstring(exec_path);
                wide_resolved_path.resize(exec_path.size() - suffixlen);
                wide_resolved_path.append(L"/Contents/Resources/");
                
                /* Append share, etc, doc */
                paths.data = wide_resolved_path + L"share/fish";
                paths.sysconf = wide_resolved_path + L"etc/fish";
                paths.doc = wide_resolved_path + L"doc/fish";
                
                /* But the bin_dir is the resolved_path, minus fish (aka the MacOS directory) */
                paths.bin = str2wcstring(exec_path);
                paths.bin.resize(paths.bin.size() - strlen("/fish"));
                
                done = true;
            }
        }
#endif
        
        if (! done)
        {
            /* The next check is that we are in a reloctable directory tree like this:
                 bin/fish
                 etc/fish
                 share/fish
                 
                 Check it!
            */
            const char *suffix = "/bin/fish";
            if (has_suffix(exec_path, suffix, false))
            {
                wcstring base_path = str2wcstring(exec_path);
                base_path.resize(base_path.size() - strlen(suffix));
                
                paths.data = base_path + L"/share/fish";
                paths.sysconf = base_path + L"/etc/fish";
                paths.doc = base_path + L"/share/doc/fish";
                paths.bin = base_path + L"/bin";
                
                struct stat buf;
                if (0 == wstat(paths.data, &buf) && 0 == wstat(paths.sysconf, &buf))
                {
                    done = true;
                }
            }
        }
    }
    
    if (! done)
    {
        /* Fall back to what got compiled in. */
        paths.data = L"" DATADIR "/fish";
        paths.sysconf = L"" SYSCONFDIR "/fish";
        paths.doc = L"" DATADIR "/doc/fish";
        paths.bin = L"" PREFIX "/bin";
        
        done = true;
    }
    
    return paths;
}
Beispiel #26
0
static struct config_paths_t determine_config_directory_paths(const char *argv0) {
    struct config_paths_t paths;
    bool done = false;
    std::string exec_path = get_executable_path(argv0);
    if (get_realpath(exec_path)) {
        debug(2, L"exec_path: '%s', argv[0]: '%s'", exec_path.c_str(), argv0);
        // TODO: we should determine program_name from argv0 somewhere in this file

#ifdef CMAKE_BINARY_DIR
        // Detect if we're running right out of the CMAKE build directory
        if (string_prefixes_string(CMAKE_BINARY_DIR, exec_path.c_str())) {
            debug(2, "Running out of build directory, using paths relative to CMAKE_SOURCE_DIR:\n %s", CMAKE_SOURCE_DIR);

            done = true;
            paths.data = wcstring{L"" CMAKE_SOURCE_DIR} + L"/share";
            paths.sysconf = wcstring{L"" CMAKE_SOURCE_DIR} + L"/etc";
            paths.doc = wcstring{L"" CMAKE_SOURCE_DIR} + L"/user_doc/html";
            paths.bin = wcstring{L"" CMAKE_BINARY_DIR};
        }
#endif

        if (!done) {
            // The next check is that we are in a reloctable directory tree
            const char *installed_suffix = "/bin/fish";
            const char *just_a_fish = "/fish";
            const char *suffix = NULL;

            if (has_suffix(exec_path, installed_suffix, false)) {
                suffix = installed_suffix;
            } else if (has_suffix(exec_path, just_a_fish, false)) {
                debug(2, L"'fish' not in a 'bin/', trying paths relative to source tree");
                suffix = just_a_fish;
            }

            if (suffix) {
                bool seems_installed = (suffix == installed_suffix);

                wcstring base_path = str2wcstring(exec_path);
                base_path.resize(base_path.size() - std::strlen(suffix));

                paths.data = base_path + (seems_installed ? L"/share/fish" : L"/share");
                paths.sysconf = base_path + (seems_installed ? L"/etc/fish" : L"/etc");
                paths.doc = base_path + (seems_installed ? L"/share/doc/fish" : L"/user_doc/html");
                paths.bin = base_path + (seems_installed ? L"/bin" : L"");

                // Check only that the data and sysconf directories exist. Handle the doc
                // directories separately.
                struct stat buf;
                if (0 == wstat(paths.data, &buf) && 0 == wstat(paths.sysconf, &buf)) {
                    // The docs dir may not exist; in that case fall back to the compiled in path.
                    if (0 != wstat(paths.doc, &buf)) {
                        paths.doc = L"" DOCDIR;
                    }
                    done = true;
                }
            }
        }
    }

    if (!done) {
        // Fall back to what got compiled in.
        debug(2, L"Using compiled in paths:");
        paths.data = L"" DATADIR "/fish";
        paths.sysconf = L"" SYSCONFDIR "/fish";
        paths.doc = L"" DOCDIR;
        paths.bin = L"" BINDIR;
    }

    debug(2,
          L"determine_config_directory_paths() results:\npaths.data: %ls\npaths.sysconf: "
          L"%ls\npaths.doc: %ls\npaths.bin: %ls",
          paths.data.c_str(), paths.sysconf.c_str(), paths.doc.c_str(), paths.bin.c_str());
    return paths;
}