//PROGRAMA PRINCIPAL CD
void
ChangeDirectory(Comando* comando){
char* path;
int error;
char buf[1024];
char dir[1024];
if(comando->arg[1]!=NULL){
if(dollar(comando->arg[1][0])){
path=ConvertDollarVar(comando->arg[1]);
if(path!=NULL){
fprintf(stderr, "Error: cant change directory %s\n", path);
}
}
if(comando->arg[1][0]!='/'){
getcwd(buf, sizeof(buf));
sprintf(dir, "%s/%s", buf, comando->arg[1]);
error=change_directory(dir);
if(error){
fprintf(stderr, "Error: cant change directory %s\n", dir);
}
}else{
error=change_directory(comando->arg[1]);
if(error){
fprintf(stderr, "Error: cant change directory %s\n", dir);
}
}
}else{
path=getEnv("HOME");
error=change_directory(path);
if(error){
fprintf(stderr, "Error: cant change directory %s\n", path);
}
}
}
static gboolean write_input_device_info(const gchar *path,
GError **error) {
gchar *last_wd = getcwd(g_malloc(PATH_MAX), PATH_MAX),
*input_dev_path,
*device_name,
*device_port;
GDir *input_dir;
if (!change_directory(path, error))
goto out1;
/* If the subdirectory "input" exists, there's probably an input device
* attached to this i8042 port */
input_dir = g_dir_open("input", 0, error);
if (!input_dir) {
if (g_error_matches(*error, G_FILE_ERROR, G_FILE_ERROR_NOENT) ||
g_error_matches(*error, G_FILE_ERROR, G_FILE_ERROR_NOTDIR))
g_clear_error(error);
goto out2;
}
/* Find the directory containing the information on the device */
input_dev_path = NULL;
for (const gchar *dir_name = g_dir_read_name(input_dir);
dir_name != NULL && *error == NULL;
dir_name = g_dir_read_name(input_dir)) {
if (g_str_has_prefix(dir_name, "input")) {
input_dev_path = g_build_filename("input", dir_name, NULL);
break;
}
}
if (!input_dev_path)
goto out3;
if (!g_file_get_contents("description", &device_port, NULL, error))
goto out4;
if (!change_directory(input_dev_path, error))
goto out5;
if (!g_file_get_contents("name", &device_name, NULL, error))
goto out5;
g_strstrip(device_port);
g_strstrip(device_name);
printf("# \"%s\" on %s\n", device_name, device_port);
g_free(device_name);
out5: g_free(device_port);
out4: g_free(input_dev_path);
out3: g_dir_close(input_dir);
out2: change_directory(last_wd, error);
out1: g_free(last_wd);
return !(*error);
}
int
swap_dirs(void)
{
stack_entry_t item;
if(stack_top == 0)
return -1;
item = stack[--stack_top];
if(pushd() != 0)
{
free_entry(&item);
return -1;
}
if(change_directory(&lwin, item.lpane_dir) >= 0)
load_dir_list(&lwin, 0);
if(change_directory(&rwin, item.rpane_dir) >= 0)
load_dir_list(&rwin, 0);
fview_cursor_redraw(curr_view);
refresh_view_win(other_view);
free_entry(&item);
return 0;
}
BOOL FileSystem::Initialize()
{
Log(TAG "Initializing...");
IFileSystem::Initialize();
if (!this->pWorkDir)
{
char dir[1024];
char dir2[1024];
memset(dir2, '\0', 1024);
memset(dir, '\0', 1024);
get_current_directory(dir, 1024);
snprintf(dir2, 1024, "%s/%s", dir, FILESYSTEM_DEFAULT_PATH);
Info(TAG "Working dir is: %s", dir2);
if (change_directory(dir2))
{
Log(TAG "Could not change current directory.");
}
}
this->BuildFileTable();
this->Reset();
Log(TAG "Initialization completed. Free Memory: %d.", pMemoryManager->GetFreeMemory());
return TRUE;
}
int main(int argc, char **argv)
{
int i;
int pos;
char *commands[] = {"cd", "exit", "path"};
cmdArgv = malloc(MAX_CMD_ARGS * sizeof(char*));;
init();
while (TRUE) {
for (i = 0; i < MAX_CMD_ARGS; i++)
cmdArgv[i] = NULL;
cmdArgc = 0;
printf("$ ");
read_and_parse_input();
pos = find_position(commands, 3, cmdArgv[0]);
switch (pos) {
case 0:
change_directory();
break;
case 1:
exit(0);
break;
case 2:
manage_path();
break;
default:
exec_command();
break;
}
}
return 0;
}
int check_next(char *cmd, char **arg, char **env)
{
int ret;
ret = 0;
if (my_strcmp("echo", arg[0]) == 0)
{
if (arg[1] == NULL)
printf("Usage : echo [-neE] [VALUE] \n");
else
my_echo(&arg[1], 0, 0);
++ret;
}
if (my_strcmp("cd", arg[0]) == 0)
{
change_directory(arg[1], env);
++ret;
}
if (my_strcmp("history", cmd) == 0)
{
my_history();
++ret;
}
ret += check_again(cmd, arg, env);
return (ret);
}
/* Navigates the view to given mark if it's valid. Returns new value for
* save_msg flag. */
static int
navigate_to_bookmark(FileView *view, char mark)
{
const bookmark_t *const bmark = get_bookmark(mark);
if(is_bmark_valid(bmark))
{
if(change_directory(view, bmark->directory) >= 0)
{
load_dir_list(view, 1);
(void)ensure_file_is_selected(view, bmark->file);
}
}
else
{
if(!char_is_one_of(valid_bookmarks, mark))
status_bar_message("Invalid mark name");
else if(is_bmark_empty(bmark))
status_bar_message("Mark is not set");
else
status_bar_message("Mark is invalid");
move_to_list_pos(view, view->list_pos);
return 1;
}
return 0;
}
/*!
\brief Returns user's home directory.
\details Defined in dmzSystemFile.h.
\return Returns String containing users home directory.
*/
dmz::String
dmz::get_home_directory () {
String result (get_env ("HOME"));
if (!result) {
const String StartDir (get_current_directory ());
if (change_directory ("~")) { result = get_current_directory (); }
change_directory (StartDir);
}
return result;
}
int cd_fct(char *path)
{
int opt_p;
char *oldpwd;
char **tmp;
t_env *env;
tmp = ft_strsplit(path, ' ');
if ((opt_p = check_cd_path(&path, tmp)) < 0)
{
ft_putstr("cd: arguments invalid");
del_tab(tmp);
path = NULL;
return (0);
}
oldpwd = NULL;
oldpwd = getcwd(oldpwd, 0);
env = init_env(NULL);
if (change_directory(&path, env) != -1)
update_env(path, oldpwd, env);
else
return (0);
del_tab(tmp);
return (1);
}
/* Navigates the view to a given dir/file combination specified by the path. */
static void
navigate_to_selected_file(FileView *view, const char path[])
{
char name[NAME_MAX];
char *dir = strdup(path);
char *const last_slash = find_slashr(dir);
if(last_slash == NULL)
{
copy_str(name, sizeof(name), dir);
}
else
{
*last_slash = '\0';
copy_str(name, sizeof(name), last_slash + 1);
}
if(change_directory(view, dir) >= 0)
{
ui_sb_quick_msgf("%s", "Finding the correct directory...");
load_dir_list(view, 0);
(void)ensure_file_is_selected(view, name);
}
else
{
show_error_msgf("Invalid path", "Cannot change dir to \"%s\"", dir);
}
free(dir);
}
/* Goes one directory up from current location. Returns zero unless it won't
* make sense to continue going up (like on error or reaching root). */
static int
cd_to_parent_dir(FileView *view)
{
char dir_name[strlen(view->curr_dir) + 1];
int ret;
/* Return to original directory from custom view. */
if(flist_custom_active(view))
{
navigate_to(view, view->custom.orig_dir);
return 0;
}
/* Do nothing in root. */
if(is_root_dir(view->curr_dir))
{
return 1;
}
dir_name[0] = '\0';
extract_last_path_component(view->curr_dir, dir_name);
ret = change_directory(view, "../");
if(ret == -1)
{
return 1;
}
if(ret == 0)
{
load_dir_list(view, 0);
flist_set_pos(view, find_file_pos_in_list(view, dir_name));
}
return 0;
}
int sbcl_bin_install(struct install_options* param) {
int ret;
char* home=configdir();
char* impl=param->impl;
char* version=param->version;
char* impl_path= cat(home,impldir(param->arch,param->os,impl,version),NULL);
char* src=param->expand_path;
char* sbcl_home=cat(impl_path,"/lib/sbcl",NULL);
char* install_root=q(impl_path);
char* log_path=cat(home,"impls/log/",impl,"-",version,"/install.log",NULL);
cond_printf(0,"Building %s/%s...",impl,version);
ensure_directories_exist(impl_path);
ensure_directories_exist(log_path);
change_directory(src);
setenv("SBCL_HOME",sbcl_home,1);
setenv("INSTALL_ROOT",install_root,1);
ret=System("(cat find-gnumake.sh; echo find_gnumake)|sh");
if(ret!=0) {
fprintf(stderr,"'make' command not available.\n");
return 0;
}
ret=1;
if(system_redirect("sh install.sh",log_path)==-1)
ret=0;
s(home),s(impl_path),s(sbcl_home),s(install_root),s(log_path);
printf(" Done.\n");
return ret;
}
int
key_enter()
{
info_t cmd = CMD_PLAY;
struct dir_contents *contents;
char *name, *buf, *p;
unsigned int buf_size;
int ret = 0;
bool is_dir;
contents = file_list.contents;
// file or directory name
name = (char *)&contents->list[file_list.cur_idx]->name;
is_dir = is_directory(name);
if (is_dir)
buf_size = strlen(name) + 1;
else
buf_size = strlen(file_list.dir_name) + 1 + strlen(name) + 1;
buf = malloc(buf_size);
if (!buf) {
mvwprintw(status_win, 3, 5, "MALLOC ERROR");
return (-1);
}
if (is_dir) {
mvwprintw(status_win, 1, 5, "CHDIR ");
strncpy(buf, name, strlen(name));
buf[buf_size - 1] = '\0';
if (change_directory(buf) == -1) {
mvwprintw(status_win, 3, 5, "ERROR: %s", buf);
ret = -1;
}
free(buf);
return (ret);
} else {
// creating a full path for selected file
p = buf;
strncpy(p, file_list.dir_name, strlen(file_list.dir_name));
p += strlen(file_list.dir_name);
*p++ = '/';
strncpy(p, name, strlen(name));
p += strlen(name);
*p = '\0';
}
mvwprintw(status_win, 1, 5, "CMD: PLAY ");
pthread_mutex_lock(&ui_status_cache_mutex);
ui_status_cache = CMD_PLAY;
pthread_mutex_unlock(&ui_status_cache_mutex);
// send full path
ret = send_packet(sock_fd, cmd, buf);
free(buf);
return (ret);
}
void
Rescan(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
char *dir;
/*
* get the mask string from the File or Export mask widget and put in
* dirmask
*/
if (browse_up) {
FirstArg(XtNstring, &dirmask);
GetValues(browse_mask);
FirstArg(XtNstring, &dir);
GetValues(browse_dir);
if (change_directory(dir)) /* make sure we are there */
return;
strcpy(cur_browse_dir,dir); /* save in global var */
(void) MakeFileList(dir, dirmask, &dir_list, &file_list);
NewList(browse_flist, file_list);
NewList(browse_dlist, dir_list);
} else if (file_up) {
FirstArg(XtNstring, &dirmask);
GetValues(file_mask);
FirstArg(XtNstring, &dir);
GetValues(file_dir);
if (change_directory(dir)) /* make sure we are there */
return;
strcpy(cur_file_dir,dir); /* save in global var */
strcpy(cur_export_dir,dir); /* set export directory to file directory */
(void) MakeFileList(dir, dirmask, &dir_list, &file_list);
NewList(file_flist,file_list);
NewList(file_dlist,dir_list);
} else if (export_up) {
FirstArg(XtNstring, &dirmask);
GetValues(exp_mask);
FirstArg(XtNstring, &dir);
GetValues(exp_dir);
if (change_directory(dir)) /* make sure we are there */
return;
strcpy(cur_export_dir,dir); /* save in global var */
(void) MakeFileList(dir, dirmask, &dir_list, &file_list);
NewList(exp_flist, file_list);
NewList(exp_dlist, dir_list);
}
}
void process_command() {
int command_ptr = 0;
initialize_array(command, 80, 0);
copy_string(command, buffer + C(current_line, 2));
initialize_array(argument, ARGUMENT_HEAP_SIZE, 0);
send_rs(command, 10);
next_line();
if (str_equal(c_exit, command, 4)) {
put_char('b');
put_char('y');
put_char('e');
send_display(buffer);
halt();
} else if (str_equal(c_cd, command, 3)) {
int length = copy_string(argument, command + 3);
change_directory(argument, length);
} else if (command[0] == 0) {
return;
} else {
int ptr = 0;
while (command[command_ptr] != ' '
&& command[command_ptr] != 0
&& command_ptr < COLS) {
int byte = command[command_ptr];
if (byte >= 'a' && byte <= 'z') {
byte -= 0x20;
}
program_name[ptr] = byte;
command_ptr += 1;
ptr += 1;
}
program_name[ptr] = 0;
while (command[command_ptr] == ' ' && command_ptr < COLS) {
command_ptr += 1;
}
ptr = 0;
while (command[command_ptr] != ' '
&& command[command_ptr] != 0
&& command_ptr < COLS) {
argument[ptr] = command[command_ptr];
command_ptr += 1;
ptr += 1;
}
argument[ptr] = 0;
argument[ARGUMENT_HEAP_SIZE-1] = current_directory_id;
execute_bin(program_name, argument);
}
}
static gboolean write_machine_summary(GError **error) {
gchar *last_wd = getcwd(g_malloc(PATH_MAX), PATH_MAX),
*sys_vendor = NULL,
*product_name = NULL,
*product_version = NULL,
*bios_vendor = NULL,
*bios_date = NULL,
*bios_version = NULL;
if (!change_directory("/sys/class/dmi/id", error))
return FALSE;
if (!g_file_get_contents("sys_vendor", &sys_vendor, NULL, error) ||
!g_file_get_contents("product_name", &product_name, NULL, error) ||
!g_file_get_contents("product_version", &product_version, NULL, error) ||
!g_file_get_contents("bios_vendor", &bios_vendor, NULL, error) ||
!g_file_get_contents("bios_date", &bios_date, NULL, error) ||
!g_file_get_contents("bios_version", &bios_version, NULL, error))
goto out;
printf("# Manufacturer: %s"
"# Product Name: %s"
"# Version: %s"
"# BIOS Vendor: %s"
"# BIOS Date: %s"
"# BIOS Version: %s"
"#\n",
sys_vendor, product_name, product_version, bios_vendor, bios_date,
bios_version);
out:
g_free(sys_vendor);
g_free(product_name);
g_free(product_version);
g_free(bios_vendor);
g_free(bios_date);
g_free(bios_version);
change_directory(last_wd, error);
g_free(last_wd);
return !(*error);
}
TEST(chase_links_causes_link_to_be_resolved, IF(not_windows))
{
assert_success(os_mkdir("dir", 0700));
/* symlink() is not available on Windows, but other code is fine. */
#ifndef _WIN32
assert_success(symlink("dir", "dir-link"));
#endif
assert_non_null(get_cwd(curr_view->curr_dir, sizeof(curr_view->curr_dir)));
assert_true(change_directory(curr_view, "dir-link") >= 0);
assert_string_equal("dir", get_last_path_component(curr_view->curr_dir));
/* Go out of the directory so that we can remove it. */
assert_true(change_directory(curr_view, "..") >= 0);
assert_success(rmdir("dir"));
assert_success(remove("dir-link"));
}
INLINE void FileSystem::SetWorkDirectory(const char *dir)
{
IFileSystem::SetWorkDirectory(dir);
if (change_directory(dir))
{
Log(TAG "Could not change current directory.");
}
else
{
Log(TAG "Changing working directory to: %s", dir);
}
}
void
execute_volumes_cb(FileView *view, menu_info *m)
{
char path_buf[4];
snprintf(path_buf, 4, "%s", m->items[m->pos]);
if(change_directory(view, path_buf) < 0)
return;
load_dir_list(view, 0);
move_to_list_pos(view, 0);
}
int
popd(void)
{
if(stack_top == 0)
return -1;
stack_top--;
if(change_directory(&lwin, stack[stack_top].lpane_dir) >= 0)
load_dir_list(&lwin, 0);
if(change_directory(&rwin, stack[stack_top].rpane_dir) >= 0)
load_dir_list(&rwin, 0);
fview_cursor_redraw(curr_view);
refresh_view_win(other_view);
free_entry(&stack[stack_top]);
return 0;
}
TEST(chase_links_is_not_affected_by_chdir, IF(not_windows))
{
char pwd[PATH_MAX];
assert_success(os_mkdir("dir", 0700));
/* symlink() is not available on Windows, but other code is fine. */
#ifndef _WIN32
assert_success(symlink("dir", "dir-link"));
#endif
assert_non_null(get_cwd(pwd, sizeof(pwd)));
strcpy(curr_view->curr_dir, pwd);
assert_true(change_directory(curr_view, "dir-link") >= 0);
assert_success(chdir(".."));
assert_true(change_directory(curr_view, "..") >= 0);
assert_true(paths_are_equal(curr_view->curr_dir, pwd));
assert_success(rmdir("dir"));
assert_success(remove("dir-link"));
}
int win_drill::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QDialog::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: change_directory(); break;
default: ;
}
_id -= 1;
}
return _id;
}
/**
* Handle Input.
*/
bool handle_input(void) {
LOG_ENTRY;
if (is_quit_command(input_buffer)) {
exit_shell();
LOG_RETURN(false);
} else if (is_cd_command(input_buffer)) {
change_directory();
LOG_RETURN(false);
} else if (str_is_whitespace(input_buffer)) {
LOG_RETURN(false);
} else {
input_tokens = tokenize(input_buffer);
LOG_RETURN(true);
}
}
void popup_browse_panel(Widget w)
{
char *fval, *pval;
set_temp_cursor(wait_cursor);
XtSetSensitive(w, False);
browse_parent = w;
browse_up = True;
file_viewed[0] = '\0';
if (!browse_popup) {
get_directory(local_dir);
} else {
strcpy(local_dir, cur_browse_dir);
}
/* move to the file directory - if not the current dir
and set up the file/directory values
*/
pval = (char*) panel_get_value( pic_name_panel );
fval = strrchr(pval, '/');
if ( !fval ) { /* no path in name so just use name */
strcpy(browse_filename, pval);
} else { /* set us up in the same path as the file */
strcpy(local_dir, pval);
strcpy(browse_filename, fval+1);
local_dir[strlen(pval) - strlen(fval)] = '\0';
(void) change_directory(local_dir);
}
if (!browse_popup) {
create_browse_panel(w);
}
FirstArg(XtNstring, local_dir);
SetValues(browse_dir);
FirstArg(XtNstring, browse_filename);
SetValues(browse_selfile);
XtPopup(browse_popup, XtGrabNonexclusive);
Rescan(0, 0, 0, 0);
(void) XSetWMProtocols(tool_d, XtWindow(browse_popup), &wm_delete_window, 1);
/* if the file message window is up add it to the grab */
file_msg_add_grab();
set_cmap(XtWindow(browse_popup)); /* ensure most recent cmap is installed */
reset_cursor();
}
static void
updir_from_mount(FileView *view, fuse_mount_t *runner)
{
char *file;
int pos;
if(change_directory(view, runner->source_file_dir) < 0)
return;
load_dir_list(view, 0);
file = runner->source_file_name;
file += strlen(runner->source_file_dir) + 1;
pos = find_file_pos_in_list(view, file);
flist_set_pos(view, pos);
}
/* Windows has various limitations on characters used in file names. */
TEST(tilde_is_expanded_after_negation, IF(not_windows))
{
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s/~", sandbox);
assert_success(exec_commands("let $a = 'x'", &lwin, CIT_COMMAND));
assert_success(os_mkdir(path, 0700));
assert_success(exec_commands("auto DirEnter !~ let $a = 1", &lwin,
CIT_COMMAND));
assert_string_equal("x", env_get("a"));
assert_true(change_directory(curr_view, path) >= 0);
assert_string_equal("1", env_get("a"));
assert_success(rmdir(path));
}
/* Navigates the view to a given dir/file combination specified by the path. */
static void
navigate_to_selected_file(FileView *view, const char path[])
{
/* Check whether target path is directory while we don't change current
* working directory by invoking change_directory() function below. */
const int dst_is_dir = is_dir(path);
char name[NAME_MAX];
char *dir = strdup(path);
char *const last_slash = find_slashr(dir);
if(last_slash == NULL)
{
copy_str(name, sizeof(name), dir);
}
else
{
*last_slash = '\0';
copy_str(name, sizeof(name), last_slash + 1);
}
if(change_directory(view, dir) >= 0)
{
status_bar_message("Finding the correct directory...");
wrefresh(status_bar);
load_dir_list(view, 0);
if(dst_is_dir)
{
strcat(name, "/");
}
(void)ensure_file_is_selected(view, name);
}
else
{
show_error_msgf("Invalid path", "Cannot change dir to \"%s\"", dir);
}
free(dir);
}
/*
* builtin_cmd
*
* 내장 명령을 수행한다.
* 내장 명령이 아니면 1을 리턴한다.
*/
int builtin_cmd(int argc, char **argv)
{
// 내장 명령어 문자열과 argv[0]을 비교하여 각각의 처리 함수 호출
if ( (!strcmp (argv[0], "quit")) || (!strcmp (argv[0], "exit")) ) {
exit(0);
}
if ( !strcmp(argv[0], "ls")){
return list_files(argc, argv);
}
if ( !strcmp(argv[0], "ll")){
return list_all_files(argc, argv);
}
if ( !strcmp(argv[0], "cp")){
return copy_file(argc, argv);
}
if ( !strcmp(argv[0], "rm")){
return remove_file(argc, argv);
}
if ( !strcmp(argv[0], "move")){
return move_file(argc, argv);
}
if ( !strcmp(argv[0], "cd")){
return change_directory(argc, argv);
}
if ( !strcmp(argv[0], "pwd")){
return print_working_directory();
}
if ( !strcmp(argv[0], "mkdir")){
return make_directory(argc, argv);
}
if ( !strcmp(argv[0], "rmdir")){
return remove_directory(argc, argv);
}
if ( !strcmp(argv[0], "cpdir")){
return copy_directory(argc, argv);
}
// 내장 명령어가 아님.
printf("command not found\n");
return 1;
}
/* Comando cd do lado do servidor */
void kermit_server_cd(int socket, const char *params, unsigned int params_length) {
char error;
fprintf(stdout, "CHANGING DIRECTORY to \"%s\"\n", params);
/* Altera o diretório corrente para o especificado */
error = change_directory(params, 0);
/* Se não houve erro durante a mudança de diretório */
if(error == KERMIT_ERROR_SUCCESS) {
/* Envia um pacote indicando que a operação foi realizada com sucesso para o cliente */
fprintf(stdout, "Directory now is \"%s\", sending OK message over network...\n", get_current_directory());
send_kermit_packet(socket, "", 0, PACKET_TYPE_OK);
fprintf(stdout, "CD operation successfully done!\n");
/* Caso ocorra algum erro durante a mudança de diretório */
} else {
/* Envia um pacote contendo o código do erro para o cliente */
fprintf(stdout, "CD operation not possible, sending error over network... ");
send_kermit_packet(socket, &error, sizeof(char), PACKET_TYPE_ERROR);
fprintf(stdout, "Done!\n");
}
}
int main()
{
while (TRUE)
{
// print prompt and read into string array input.
print_prompt();
char* input[64];
scan_input(input);
int input_len = array_len(input);
int option = 0;
// if last parameter is an & then run child process in background.
/*if (input_len != 0 && !strcmp(input[input_len], "&"))
{
option = 1;
input[input_len] = NULL;
}*/
/* pass to change_directory if input is a cd command.
Else perform a fork and process input. */
if (input_len != 0 && !strcmp(input[0], "cd"))
{
change_directory(input);
}
else if (input_len != 0 && fork() != 0)
{
// code for parent process.
int statloc;
process_parent(&statloc, option);
}
else if (input_len != 0)
{
// code for forked child process.
process_child(input);
}
}
}
