void EnhancedPosition::run()
{
LOG_INFO_MSG(gCtx,"Starting EnhancedPosition dispatcher...");
gnssRegisterPositionCallback(&cbPosition);
gnssRegisterSatelliteDetailCallback(&cbSatelliteDetail);
}
void EnhancedPosition::shutdown()
{
LOG_INFO_MSG(gCtx,"Shutting down EnhancedPosition dispatcher...");
gnssDeregisterPositionCallback(&cbPosition);
gnssDeregisterSatelliteDetailCallback(&cbSatelliteDetail);
}
int TcpClient::run(Request& req, std::ostream& out) {
int returnCode = -1;
try {
std::ostringstream request_stream;
write_request(req, request_stream);
this->send(request_stream.str());
this->receive(rcvBuffer_);
std::stringstream response_stream;
response_stream.write((char*)rcvBuffer_.data(), rcvBuffer_.size());
string line;
while (response_stream) {
std::getline(response_stream, line);
if(endsWith(line,"__JANOSH_EOF")) {
out << line.substr(0, line.size() - string("__JANOSH_EOF").size());
std::getline(response_stream, line);
returnCode = std::stoi(line);
if (returnCode == 0) {
LOG_DEBUG_STR("Successful");
} else {
LOG_INFO_MSG("Failed", returnCode);
}
break;
}
out << line << '\n';
}
} catch (std::exception& ex) {
LOG_ERR_MSG("Caught in tcp_client run", ex.what());
}
return returnCode;
}
int
vifm_system(char command[])
{
#ifdef _WIN32
system("cls");
#endif
LOG_INFO_MSG("Shell command: %s", command);
return run_in_shell_no_cls(command);
}
int
capture_output_to_menu(FileView *view, const char cmd[], menu_info *m)
{
FILE *file, *err;
char *line = NULL;
int x;
pid_t pid;
LOG_INFO_MSG("Capturing output of the command to a menu: %s", cmd);
pid = background_and_capture((char *)cmd, &file, &err);
if(pid == (pid_t)-1)
{
show_error_msgf("Trouble running command", "Unable to run: %s", cmd);
return 0;
}
show_progress("", 0);
ui_cancellation_reset();
ui_cancellation_enable();
wait_for_data_from(pid, file, 0);
x = 0;
while((line = read_line(file, line)) != NULL)
{
char *expanded_line;
show_progress("Loading menu", 1000);
m->items = realloc(m->items, sizeof(char *)*(x + 1));
expanded_line = expand_tabulation_a(line, cfg.tab_stop);
if(expanded_line != NULL)
{
m->items[x++] = expanded_line;
}
wait_for_data_from(pid, file, 0);
}
m->len = x;
ui_cancellation_disable();
fclose(file);
print_errors(err);
if(ui_cancellation_requested())
{
append_to_string(&m->title, "(cancelled) ");
append_to_string(&m->empty_msg, " (cancelled)");
}
return display_menu(m, view);
}
/* Copies file/directory overwriting destination files if requested. Returns
* non-zero on error, otherwise zero is returned. */
static int
op_cp(void *data, const char src[], const char dst[], int overwrite)
{
#ifndef _WIN32
char *escaped_src, *escaped_dst;
char cmd[6 + PATH_MAX*2 + 1];
int result;
escaped_src = escape_filename(src, 0);
escaped_dst = escape_filename(dst, 0);
if(escaped_src == NULL || escaped_dst == NULL)
{
free(escaped_dst);
free(escaped_src);
return -1;
}
snprintf(cmd, sizeof(cmd),
"cp %s -R " PRESERVE_FLAGS " %s %s",
overwrite ? "" : NO_CLOBBER, escaped_src, escaped_dst);
LOG_INFO_MSG("Running cp command: \"%s\"", cmd);
result = background_and_wait_for_errors(cmd);
free(escaped_dst);
free(escaped_src);
return result;
#else
int ret;
if(is_dir(src))
{
char cmd[6 + PATH_MAX*2 + 1];
snprintf(cmd, sizeof(cmd), "xcopy \"%s\" \"%s\" ", src, dst);
to_back_slash(cmd);
if(is_vista_and_above())
strcat(cmd, "/B ");
if(overwrite)
{
strcat(cmd, "/Y ");
}
strcat(cmd, "/E /I /H /R > NUL");
ret = system(cmd);
}
else
{
ret = (CopyFileA(src, dst, 0) == 0);
}
return ret;
#endif
}
static int
op_removesl(void *data, const char *src, const char *dst)
{
#ifndef _WIN32
char *escaped;
char cmd[16 + PATH_MAX];
int result;
escaped = escape_filename(src, 0);
if(escaped == NULL)
return -1;
snprintf(cmd, sizeof(cmd), "rm -rf %s", escaped);
LOG_INFO_MSG("Running rm command: \"%s\"", cmd);
result = background_and_wait_for_errors(cmd);
free(escaped);
return result;
#else
if(is_dir(src))
{
char buf[PATH_MAX];
int err;
int i;
snprintf(buf, sizeof(buf), "%s%c", src, '\0');
for(i = 0; buf[i] != '\0'; i++)
if(buf[i] == '/')
buf[i] = '\\';
SHFILEOPSTRUCTA fo = {
.hwnd = NULL,
.wFunc = FO_DELETE,
.pFrom = buf,
.pTo = NULL,
.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI,
};
err = SHFileOperation(&fo);
log_msg("Error: %d", err);
return err;
}
else
{
int ok;
DWORD attributes = GetFileAttributesA(src);
if(attributes & FILE_ATTRIBUTE_READONLY)
SetFileAttributesA(src, attributes & ~FILE_ATTRIBUTE_READONLY);
ok = DeleteFile(src);
if(!ok)
LOG_WERROR(GetLastError());
return !ok;
}
#endif
}
static int
op_chmod(void *data, const char *src, const char *dst)
{
char cmd[128 + PATH_MAX];
char *escaped;
escaped = escape_filename(src, 0);
snprintf(cmd, sizeof(cmd), "chmod %s %s", (char *)data, escaped);
free(escaped);
LOG_INFO_MSG("Running chmod command: \"%s\"", cmd);
return background_and_wait_for_errors(cmd);
}
static int
op_rmdir(void *data, const char *src, const char *dst)
{
#ifndef _WIN32
char cmd[128 + PATH_MAX];
char *escaped;
escaped = escape_filename(src, 0);
snprintf(cmd, sizeof(cmd), "rmdir %s", escaped);
free(escaped);
LOG_INFO_MSG("Running rmdir command: \"%s\"", cmd);
return background_and_wait_for_errors(cmd);
#else
return RemoveDirectory(src) == 0;
#endif
}
/* Moves file/directory overwriting destination files if requested. Returns
* non-zero on error, otherwise zero is returned. */
static int
op_mv(void *data, const char src[], const char dst[], int overwrite)
{
#ifndef _WIN32
struct stat st;
char *escaped_src, *escaped_dst;
char cmd[6 + PATH_MAX*2 + 1];
int result;
if(lstat(dst, &st) == 0)
return -1;
escaped_src = escape_filename(src, 0);
escaped_dst = escape_filename(dst, 0);
if(escaped_src == NULL || escaped_dst == NULL)
{
free(escaped_dst);
free(escaped_src);
return -1;
}
snprintf(cmd, sizeof(cmd), "mv %s %s %s", overwrite ? "" : NO_CLOBBER,
escaped_src, escaped_dst);
free(escaped_dst);
free(escaped_src);
LOG_INFO_MSG("Running mv command: \"%s\"", cmd);
if((result = background_and_wait_for_errors(cmd)) != 0)
return result;
if(path_starts_with(dst, cfg.trash_dir))
add_to_trash(src, strrchr(dst, '/') + 1);
else if(path_starts_with(src, cfg.trash_dir))
remove_from_trash(strrchr(src, '/') + 1);
return 0;
#else
BOOL ret = MoveFile(src, dst);
if(!ret && GetLastError() == 5)
{
int r = op_cp(data, src, dst, overwrite);
if(r != 0)
return r;
return op_removesl(data, src, NULL);
}
return ret == 0;
#endif
}
static int
op_mkdir(void *data, const char *src, const char *dst)
{
#ifndef _WIN32
char cmd[128 + PATH_MAX];
char *escaped;
escaped = escape_filename(src, 0);
snprintf(cmd, sizeof(cmd), "mkdir %s %s", (data == NULL) ? "" : "-p",
escaped);
free(escaped);
LOG_INFO_MSG("Running mkdir command: \"%s\"", cmd);
return background_and_wait_for_errors(cmd);
#else
if(data == NULL)
{
return CreateDirectory(src, NULL) == 0;
}
else
{
char *p;
char t;
p = strchr(src + 2, '/');
do
{
t = *p;
*p = '\0';
if(!is_dir(src))
{
if(!CreateDirectory(src, NULL))
{
*p = t;
return -1;
}
}
*p = t;
if((p = strchr(p + 1, '/')) == NULL)
p = (char *)src + strlen(src);
}
while(t != '\0');
return 0;
}
#endif
}
static int
op_chgrp(void *data, const char *src, const char *dst)
{
#ifndef _WIN32
char cmd[10 + 32 + PATH_MAX];
char *escaped;
gid_t gid = (gid_t)(long)data;
escaped = escape_filename(src, 0);
snprintf(cmd, sizeof(cmd), "chown -fR :%u %s", gid, escaped);
free(escaped);
LOG_INFO_MSG("Running chgrp command: \"%s\"", cmd);
return background_and_wait_for_errors(cmd);
#else
return -1;
#endif
}
static void
try_become_a_server(void)
{
struct sockaddr_in addr;
#ifdef _WIN32
BOOL yes = TRUE;
#else
int yes = 1;
#endif
if(server)
return;
/* FIXME: with SO_REUSEADDR this operation always succeeds... Which breaks
* client/server relationships. */
#ifdef _WIN32
if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&yes,
sizeof(yes)) != 0)
#else
if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) != 0)
#endif
{
LOG_SERROR_MSG(errno, "Can't set reusable option on a socket");
}
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr("127.0.0.1");
addr.sin_port = htons(PORT);
server = bind(sock, (struct sockaddr *)&addr, sizeof(addr)) != -1;
if(!server)
{
if(curr_stats.load_stage < 3)
{
LOG_SERROR_MSG(errno, "Can't become an IPC server");
}
}
else
{
LOG_INFO_MSG("Successfully became an IPC server");
}
}
static int
op_symlink(void *data, const char *src, const char *dst)
{
char *escaped_src, *escaped_dst;
char cmd[6 + PATH_MAX*2 + 1];
int result;
#ifdef _WIN32
char buf[PATH_MAX + 2];
#endif
escaped_src = escape_filename(src, 0);
escaped_dst = escape_filename(dst, 0);
if(escaped_src == NULL || escaped_dst == NULL)
{
free(escaped_dst);
free(escaped_src);
return -1;
}
#ifndef _WIN32
snprintf(cmd, sizeof(cmd), "ln -s %s %s", escaped_src, escaped_dst);
LOG_INFO_MSG("Running ln command: \"%s\"", cmd);
result = background_and_wait_for_errors(cmd);
#else
if(GetModuleFileNameA(NULL, buf, ARRAY_LEN(buf)) == 0)
{
free(escaped_dst);
free(escaped_src);
return -1;
}
*strrchr(buf, '\\') = '\0';
snprintf(cmd, sizeof(cmd), "%s\\win_helper -s %s %s", buf, escaped_src,
escaped_dst);
result = system(cmd);
#endif
free(escaped_dst);
free(escaped_src);
return result;
}
static int
op_mkfile(void *data, const char *src, const char *dst)
{
#ifndef _WIN32
char cmd[128 + PATH_MAX];
char *escaped;
escaped = escape_filename(src, 0);
snprintf(cmd, sizeof(cmd), "touch %s", escaped);
free(escaped);
LOG_INFO_MSG("Running touch command: \"%s\"", cmd);
return background_and_wait_for_errors(cmd);
#else
HANDLE hfile;
hfile = CreateFileA(src, 0, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
if(hfile == INVALID_HANDLE_VALUE)
return -1;
CloseHandle(hfile);
return 0;
#endif
}
/*
* mount_point should be an array of at least PATH_MAX characters
* Returns non-zero on error.
*/
static int
fuse_mount(FileView *view, char *file_full_path, const char *param,
const char *program, char *mount_point)
{
/* TODO: refactor this function fuse_mount() */
fuse_mount_t *runner = NULL;
int mount_point_id = 0;
fuse_mount_t *fuse_item = NULL;
char buf[2*PATH_MAX];
char *escaped_filename;
int clear_before_mount = 0;
char errors_file[PATH_MAX];
int status;
escaped_filename = escape_filename(get_current_file_name(view), 0);
/* get mount_point_id + mount_point and set runner pointing to the list's
* tail */
if(fuse_mounts != NULL)
{
runner = fuse_mounts;
while(runner->next != NULL)
runner = runner->next;
mount_point_id = runner->mount_point_id;
}
do
{
snprintf(mount_point, PATH_MAX, "%s/%03d_%s", cfg.fuse_home,
++mount_point_id, get_current_file_name(view));
}
while(path_exists(mount_point));
if(make_dir(mount_point, S_IRWXU) != 0)
{
free(escaped_filename);
show_error_msg("Unable to create FUSE mount directory", mount_point);
return -1;
}
free(escaped_filename);
/* Just before running the mount,
I need to chdir out temporarily from any FUSE mounted
paths, Otherwise the fuse-zip command fails with
"fusermount: failed to open current directory: permission denied"
(this happens when mounting JARs from mounted JARs) */
if(vifm_chdir(cfg.fuse_home) != 0)
{
show_error_msg("FUSE MOUNT ERROR", "Can't chdir() to FUSE home");
return -1;
}
clear_before_mount = format_mount_command(mount_point, file_full_path, param,
program, sizeof(buf), buf);
status_bar_message("FUSE mounting selected file, please stand by..");
if(clear_before_mount)
{
def_prog_mode();
endwin();
}
generate_tmp_file_name("vifm.errors", errors_file, sizeof(errors_file));
strcat(buf, " 2> ");
strcat(buf, errors_file);
LOG_INFO_MSG("FUSE mount command: `%s`", buf);
status = background_and_wait_for_status(buf);
clean_status_bar();
/* check child status */
if(!WIFEXITED(status) || (WIFEXITED(status) && WEXITSTATUS(status)))
{
FILE *ef = fopen(errors_file, "r");
print_errors(ef);
unlink(errors_file);
werase(status_bar);
/* remove the directory we created for the mount */
if(path_exists(mount_point))
rmdir(mount_point);
show_error_msg("FUSE MOUNT ERROR", file_full_path);
(void)vifm_chdir(view->curr_dir);
return -1;
}
unlink(errors_file);
status_bar_message("FUSE mount success");
fuse_item = malloc(sizeof(*fuse_item));
copy_str(fuse_item->source_file_name, sizeof(fuse_item->source_file_name),
file_full_path);
strcpy(fuse_item->source_file_dir, view->curr_dir);
canonicalize_path(mount_point, fuse_item->mount_point,
sizeof(fuse_item->mount_point));
fuse_item->mount_point_id = mount_point_id;
fuse_item->next = NULL;
if(fuse_mounts == NULL)
fuse_mounts = fuse_item;
else
runner->next = fuse_item;
return 0;
}
/* Expands macros in the *format string advancing the pointer as it goes. The
* opt represents conditional expression state, should be zero for non-recursive
* calls. Returns newly allocated string, which should be freed by the
* caller. */
static LineWithAttrs
parse_view_macros(view_t *view, const char **format, const char macros[],
int opt)
{
const dir_entry_t *const curr = get_current_entry(view);
LineWithAttrs result = { .line = strdup(""), .attrs = strdup("") };
char c;
int nexpansions = 0;
int has_expander = 0;
if(curr == NULL)
{
return result;
}
while((c = **format) != '\0')
{
size_t width = 0;
int left_align = 0;
char buf[PATH_MAX + 1];
const char *const next = ++*format;
int skip, ok;
if(c != '%' ||
(!char_is_one_of(macros, *next) && !isdigit(*next) &&
(*next != '=' || has_expander)))
{
if(strappendch(&result.line, &result.line_len, c) != 0)
{
break;
}
continue;
}
if(*next == '=')
{
(void)sync_attrs(&result, 0);
if(strappend(&result.line, &result.line_len, "%=") != 0 ||
strappendch(&result.attrs, &result.attrs_len, '=') != 0)
{
break;
}
++*format;
has_expander = 1;
continue;
}
if(*next == '-')
{
left_align = 1;
++*format;
}
while(isdigit(**format))
{
width = width*10 + *(*format)++ - '0';
}
c = *(*format)++;
skip = 0;
ok = 1;
buf[0] = '\0';
switch(c)
{
case 'a':
friendly_size_notation(get_free_space(curr_view->curr_dir), sizeof(buf),
buf);
break;
case 't':
format_entry_name(curr, NF_FULL, sizeof(buf), buf);
break;
case 'T':
if(curr->type == FT_LINK)
{
char full_path[PATH_MAX + 1];
char link_path[PATH_MAX + 1]; //add by sim1
get_full_path_of(curr, sizeof(full_path), full_path);
//mod by sim1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
if(get_link_target(full_path, link_path, sizeof(link_path)) != 0)
{
copy_str(buf, sizeof(buf), "Failed to resolve link");
}
else
{
snprintf(buf, sizeof(buf), " -> %s", link_path);
}
//mod by sim1 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
}
break;
case 'f':
get_short_path_of(view, curr, NF_FULL, 0, sizeof(buf), buf);
break;
case 'A':
#ifndef _WIN32
get_perm_string(buf, sizeof(buf), curr->mode);
#else
copy_str(buf, sizeof(buf), attr_str_long(curr->attrs));
#endif
break;
case 'u':
get_uid_string(curr, 0, sizeof(buf), buf);
break;
case 'g':
get_gid_string(curr, 0, sizeof(buf), buf);
break;
case 's':
friendly_size_notation(fentry_get_size(view, curr), sizeof(buf), buf);
break;
//add by sim1 ************************************************
case 'r':
{
char path[PATH_MAX] = {0};
get_full_path_at(view, view->list_pos, sizeof(path), path);
(void)get_rating_string(buf, sizeof(buf), path);
}
break;
case 'n':
{
int nitems = !fentry_is_dir(curr) ? 0 : (int)fentry_get_nitems(view, curr);
snprintf(buf, sizeof(buf), "%d", nitems);
}
break;
//add by sim1 ************************************************
case 'E':
{
uint64_t size = 0U;
typedef int (*iter_f)(view_t *view, dir_entry_t **entry);
/* No current element for visual mode, since it can contain truly
* empty selection when cursor is on ../ directory. */
iter_f iter = vle_mode_is(VISUAL_MODE) ? &iter_selected_entries
: &iter_selection_or_current;
dir_entry_t *entry = NULL;
while(iter(view, &entry))
{
size += fentry_get_size(view, entry);
}
friendly_size_notation(size, sizeof(buf), buf);
}
break;
case 'd':
{
struct tm *tm_ptr = localtime(&curr->mtime);
strftime(buf, sizeof(buf), cfg.time_format, tm_ptr);
}
break;
case '-':
case 'x':
skip = expand_num(buf, sizeof(buf), view->filtered);
break;
case 'l':
skip = expand_num(buf, sizeof(buf), view->list_pos + 1);
break;
case 'L':
skip = expand_num(buf, sizeof(buf), view->list_rows + view->filtered);
break;
case 'S':
skip = expand_num(buf, sizeof(buf), view->list_rows);
break;
case '%':
copy_str(buf, sizeof(buf), "%");
break;
case 'z':
copy_str(buf, sizeof(buf), get_tip());
break;
case 'D':
if(curr_stats.number_of_windows == 1)
{
view_t *const other = (view == curr_view) ? other_view : curr_view;
//mod by sim1
//copy_str(buf, sizeof(buf), replace_home_part(other->curr_dir));
snprintf(buf, sizeof(buf), " ‖ %s", replace_home_part(other->curr_dir));
}
break;
case '[':
{
LineWithAttrs opt = parse_view_macros(view, format, macros, 1);
copy_str(buf, sizeof(buf), opt.line);
free(opt.line);
char *attrs = opt.attrs;
if(sync_attrs(&result, 0) && opt.attrs_len > 0U)
{
if(*attrs != ' ')
{
result.attrs[result.attrs_len - 1U] = *attrs;
}
++attrs;
}
strappend(&result.attrs, &result.attrs_len, attrs);
free(opt.attrs);
break;
}
case ']':
if(opt)
{
if(nexpansions == 0)
{
replace_string(&result.line, "");
replace_string(&result.attrs, "");
result.line_len = 0U;
result.attrs_len = 0U;
}
if(sync_attrs(&result, 0))
{
result.attrs[--result.attrs_len] = '\0';
}
return result;
}
LOG_INFO_MSG("Unmatched %%]");
ok = 0;
break;
case '{':
{
/* Try to find matching closing bracket
* TODO: implement the way to escape it, so that the expr may contain
* closing brackets */
const char *e = strchr(*format, '}');
char *expr = NULL, *resstr = NULL;
var_t res = var_false();
ParsingErrors parsing_error;
/* If there's no matching closing bracket, just add the opening one
* literally */
if(e == NULL)
{
ok = 0;
break;
}
/* Create a NULL-terminated copy of the given expr.
* TODO: we could temporarily use buf for that, to avoid extra
* allocation, but explicitly named variable reads better. */
expr = calloc(e - (*format) + 1 /* NUL-term */, 1);
memcpy(expr, *format, e - (*format));
/* Try to parse expr, and convert the res to string if succeed. */
parsing_error = parse(expr, 0, &res);
if(parsing_error == PE_NO_ERROR)
{
resstr = var_to_str(res);
}
if(resstr != NULL)
{
copy_str(buf, sizeof(buf), resstr);
}
else
{
copy_str(buf, sizeof(buf), "<Invalid expr>");
}
var_free(res);
free(resstr);
free(expr);
*format = e + 1 /* closing bracket */;
}
break;
case '*':
if(width > 9)
{
snprintf(buf, sizeof(buf), "%%%d*", (int)width);
width = 0;
break;
}
(void)sync_attrs(&result, 1);
result.attrs[result.attrs_len - 1] = '0' + width;
width = 0;
break;
default:
LOG_INFO_MSG("Unexpected %%-sequence: %%%c", c);
ok = 0;
break;
}
if(char_is_one_of("tTAugsEd", c) && fentry_is_fake(curr))
{
buf[0] = '\0';
}
if(!ok)
{
*format = next;
if(strappendch(&result.line, &result.line_len, '%') != 0)
{
break;
}
continue;
}
check_expanded_str(buf, skip, &nexpansions);
stralign(buf, width, ' ', left_align);
if(strappend(&result.line, &result.line_len, buf) != 0)
{
break;
}
}
/* Unmatched %[. */
if(opt)
{
(void)strprepend(&result.line, &result.line_len, "%[");
}
if(sync_attrs(&result, 0))
{
result.attrs[--result.attrs_len] = '\0';
}
return result;
}
/* Makes sure that result->attrs has at least as many elements as result->line
* contains characters + extra_width. Returns non-zero if result->attrs has
* extra characters compared to result->line. */
static int
sync_attrs(LineWithAttrs *result, int extra_width)
{
const size_t nchars = utf8_strsw(result->line) + extra_width;
if(result->attrs_len < nchars)
{
char *const new_attrs = format_str("%s%*s", result->attrs,
(int)(nchars - result->attrs_len), "");
free(result->attrs);
result->attrs = new_attrs;
result->attrs_len = nchars;
}
return (result->attrs_len > nchars);
}
/* Prints number into the buffer. Returns non-zero if numeric value is
* "empty" (zero). */
static int
expand_num(char buf[], size_t buf_len, int val)
{
snprintf(buf, buf_len, "%d", val);
return (val == 0);
}
static int
op_removesl(ops_t *ops, void *data, const char *src, const char *dst)
{
if(cfg.delete_prg[0] != '\0')
{
#ifndef _WIN32
char *escaped;
char cmd[2*PATH_MAX + 1];
const int cancellable = (data == NULL);
escaped = shell_like_escape(src, 0);
if(escaped == NULL)
{
return -1;
}
snprintf(cmd, sizeof(cmd), "%s %s", cfg.delete_prg, escaped);
free(escaped);
LOG_INFO_MSG("Running trash command: \"%s\"", cmd);
return background_and_wait_for_errors(cmd, cancellable);
#else
char cmd[PATH_MAX*2 + 1];
snprintf(cmd, sizeof(cmd), "%s \"%s\"", cfg.delete_prg, src);
to_back_slash(cmd);
return os_system(cmd);
#endif
}
if(!cfg.use_system_calls)
{
#ifndef _WIN32
char *escaped;
char cmd[16 + PATH_MAX];
int result;
const int cancellable = data == NULL;
escaped = shell_like_escape(src, 0);
if(escaped == NULL)
return -1;
snprintf(cmd, sizeof(cmd), "rm -rf %s", escaped);
LOG_INFO_MSG("Running rm command: \"%s\"", cmd);
result = background_and_wait_for_errors(cmd, cancellable);
free(escaped);
return result;
#else
if(is_dir(src))
{
char path[PATH_MAX];
int err;
copy_str(path, sizeof(path), src);
to_back_slash(path);
wchar_t *const utf16_path = utf8_to_utf16(path);
SHFILEOPSTRUCTW fo = {
.hwnd = NULL,
.wFunc = FO_DELETE,
.pFrom = utf16_path,
.pTo = NULL,
.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI,
};
err = SHFileOperationW(&fo);
log_msg("Error: %d", err);
free(utf16_path);
return err;
}
else
{
int ok;
wchar_t *const utf16_path = utf8_to_utf16(src);
DWORD attributes = GetFileAttributesW(utf16_path);
if(attributes & FILE_ATTRIBUTE_READONLY)
{
SetFileAttributesW(utf16_path, attributes & ~FILE_ATTRIBUTE_READONLY);
}
ok = DeleteFileW(utf16_path);
if(!ok)
{
LOG_WERROR(GetLastError());
}
free(utf16_path);
return !ok;
}
#endif
}
/* Expands macros in the *format string advancing the pointer as it goes. The
* opt represents conditional expression state, should be zero for non-recursive
* calls. Returns newly allocated string, which should be freed by the
* caller. */
static char *
parse_view_macros(FileView *view, const char **format, const char macros[],
int opt)
{
const dir_entry_t *const entry = &view->dir_entry[view->list_pos];
char *result = strdup("");
size_t len = 0;
char c;
int nexpansions = 0;
while((c = **format) != '\0')
{
size_t width = 0;
int left_align = 0;
char buf[PATH_MAX];
const char *const next = ++*format;
int skip, ok;
if(c != '%' || (!char_is_one_of(macros, *next) && !isdigit(*next)))
{
if(strappendch(&result, &len, c) != 0)
{
break;
}
continue;
}
if(*next == '-')
{
left_align = 1;
++*format;
}
while(isdigit(**format))
{
width = width*10 + *(*format)++ - '0';
}
c = *(*format)++;
skip = 0;
ok = 1;
switch(c)
{
case 't':
format_entry_name(entry, sizeof(buf), buf);
break;
case 'A':
#ifndef _WIN32
get_perm_string(buf, sizeof(buf), entry->mode);
#else
snprintf(buf, sizeof(buf), "%s", attr_str_long(entry->attrs));
#endif
break;
case 'u':
get_uid_string(entry, 0, sizeof(buf), buf);
break;
case 'g':
get_gid_string(entry, 0, sizeof(buf), buf);
break;
case 's':
friendly_size_notation(entry->size, sizeof(buf), buf);
break;
case 'E':
{
uint64_t size = 0;
if(view->selected_files > 0)
{
int i;
for(i = 0; i < view->list_rows; i++)
{
if(view->dir_entry[i].selected)
{
size += get_file_size_by_entry(view, i);
}
}
}
/* Make exception for VISUAL_MODE, since it can contain empty
* selection when cursor is on ../ directory. */
else if(!vle_mode_is(VISUAL_MODE))
{
size = get_file_size_by_entry(view, view->list_pos);
}
friendly_size_notation(size, sizeof(buf), buf);
}
break;
case 'd':
{
struct tm *tm_ptr = localtime(&entry->mtime);
strftime(buf, sizeof(buf), cfg.time_format, tm_ptr);
}
break;
case '-':
skip = expand_num(buf, sizeof(buf), view->filtered);
break;
case 'l':
skip = expand_num(buf, sizeof(buf), view->list_pos + 1);
break;
case 'L':
skip = expand_num(buf, sizeof(buf), view->list_rows + view->filtered);
break;
case 'S':
skip = expand_num(buf, sizeof(buf), view->list_rows);
break;
case '%':
snprintf(buf, sizeof(buf), "%%");
break;
case '[':
{
char *const opt_str = parse_view_macros(view, format, macros, 1);
copy_str(buf, sizeof(buf), opt_str);
free(opt_str);
break;
}
case ']':
if(opt)
{
if(nexpansions == 0)
{
replace_string(&result, "");
}
return result;
}
else
{
LOG_INFO_MSG("Unmatched %]", c);
ok = 0;
}
break;
default:
LOG_INFO_MSG("Unexpected %%-sequence: %%%c", c);
ok = 0;
break;
}
if(!ok)
{
*format = next;
if(strappendch(&result, &len, '%') != 0)
{
break;
}
continue;
}
check_expanded_str(buf, skip, &nexpansions);
stralign(buf, width, ' ', left_align);
if(strappend(&result, &len, buf) != 0)
{
break;
}
}
/* Unmatched %[. */
if(opt)
{
(void)strprepend(&result, &len, "%[");
}
return result;
}
/* mount_point should be an array of at least PATH_MAX characters
* Returns non-zero on error. */
static int
fuse_mount(FileView *view, char file_full_path[], const char param[],
const char program[], char mount_point[])
{
/* TODO: refactor this function fuse_mount(). */
int mount_point_id;
char buf[2*PATH_MAX];
char *escaped_filename;
int foreground;
char errors_file[PATH_MAX];
int status;
int cancelled;
escaped_filename = escape_filename(get_current_file_name(view), 0);
mount_point_id = get_last_mount_point_id(fuse_mounts);
do
{
snprintf(mount_point, PATH_MAX, "%s/%03d_%s", cfg.fuse_home,
++mount_point_id, get_current_file_name(view));
}
while(path_exists(mount_point, DEREF));
if(os_mkdir(mount_point, S_IRWXU) != 0)
{
free(escaped_filename);
show_error_msg("Unable to create FUSE mount directory", mount_point);
return -1;
}
free(escaped_filename);
/* Just before running the mount,
I need to chdir out temporarily from any FUSE mounted
paths, Otherwise the fuse-zip command fails with
"fusermount: failed to open current directory: permission denied"
(this happens when mounting JARs from mounted JARs) */
if(vifm_chdir(cfg.fuse_home) != 0)
{
show_error_msg("FUSE MOUNT ERROR", "Can't chdir() to FUSE home");
return -1;
}
format_mount_command(mount_point, file_full_path, param, program, sizeof(buf),
buf, &foreground);
status_bar_message("FUSE mounting selected file, please stand by..");
if(foreground)
{
def_prog_mode();
endwin();
}
generate_tmp_file_name("vifm.errors", errors_file, sizeof(errors_file));
strcat(buf, " 2> ");
strcat(buf, errors_file);
LOG_INFO_MSG("FUSE mount command: `%s`", buf);
status = background_and_wait_for_status(buf, !foreground, &cancelled);
clean_status_bar();
/* Check child process exit status. */
if(!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS)
{
FILE *ef;
if(!WIFEXITED(status))
{
LOG_ERROR_MSG("FUSE mounter didn't exit!");
}
else
{
LOG_ERROR_MSG("FUSE mount command exit status: %d", WEXITSTATUS(status));
}
ef = os_fopen(errors_file, "r");
if(ef == NULL)
{
LOG_SERROR_MSG(errno, "Failed to open temporary stderr file: %s",
errors_file);
}
show_errors_from_file(ef, "FUSE mounter error");
werase(status_bar);
if(cancelled)
{
status_bar_message("FUSE mount cancelled");
curr_stats.save_msg = 1;
}
else
{
show_error_msg("FUSE MOUNT ERROR", file_full_path);
}
if(unlink(errors_file) != 0)
{
LOG_SERROR_MSG(errno, "Error file deletion failure: %d", errors_file);
}
/* Remove the directory we created for the mount. */
(void)rmdir(mount_point);
(void)vifm_chdir(flist_get_dir(view));
return -1;
}
unlink(errors_file);
status_bar_message("FUSE mount success");
register_mount(&fuse_mounts, file_full_path, mount_point, mount_point_id);
return 0;
}
int
fuse_try_unmount(FileView *view)
{
char buf[14 + PATH_MAX + 1];
fuse_mount_t *runner, *trailer;
int status;
fuse_mount_t *sniffer;
char *escaped_mount_point;
runner = fuse_mounts;
trailer = NULL;
while(runner)
{
if(paths_are_equal(runner->mount_point, view->curr_dir))
{
break;
}
trailer = runner;
runner = runner->next;
}
if(runner == NULL)
{
return 0;
}
/* we are exiting a top level dir */
escaped_mount_point = escape_filename(runner->mount_point, 0);
snprintf(buf, sizeof(buf), "%s %s 2> /dev/null", curr_stats.fuse_umount_cmd,
escaped_mount_point);
LOG_INFO_MSG("FUSE unmount command: `%s`", buf);
free(escaped_mount_point);
/* Have to chdir to parent temporarily, so that this DIR can be unmounted. */
if(vifm_chdir(cfg.fuse_home) != 0)
{
show_error_msg("FUSE UMOUNT ERROR", "Can't chdir to FUSE home");
return -1;
}
status_bar_message("FUSE unmounting selected file, please stand by..");
status = background_and_wait_for_status(buf, 0, NULL);
clean_status_bar();
/* check child status */
if(!WIFEXITED(status) || WEXITSTATUS(status))
{
werase(status_bar);
show_error_msgf("FUSE UMOUNT ERROR", "Can't unmount %s. It may be busy.",
runner->source_file_name);
(void)vifm_chdir(flist_get_dir(view));
return -1;
}
/* remove the directory we created for the mount */
if(path_exists(runner->mount_point, DEREF))
rmdir(runner->mount_point);
/* remove mount point from fuse_mount_t */
sniffer = runner->next;
if(trailer)
trailer->next = sniffer ? sniffer : NULL;
else
fuse_mounts = sniffer;
updir_from_mount(view, runner);
free(runner);
return 1;
}
static int
op_removesl(ops_t *ops, void *data, const char *src, const char *dst)
{
const char *const delete_prg = (ops == NULL)
? cfg.delete_prg
: ops->delete_prg;
if(delete_prg[0] != '\0')
{
#ifndef _WIN32
char *escaped;
char cmd[2*PATH_MAX + 1];
const int cancellable = (data == NULL);
escaped = shell_like_escape(src, 0);
if(escaped == NULL)
{
return -1;
}
snprintf(cmd, sizeof(cmd), "%s %s", delete_prg, escaped);
free(escaped);
LOG_INFO_MSG("Running trash command: \"%s\"", cmd);
return run_operation_command(ops, cmd, cancellable);
#else
char cmd[PATH_MAX*2 + 1];
snprintf(cmd, sizeof(cmd), "%s \"%s\"", delete_prg, src);
to_back_slash(cmd);
return os_system(cmd);
#endif
}
if(!ops_uses_syscalls(ops))
{
#ifndef _WIN32
char *escaped;
char cmd[16 + PATH_MAX];
int result;
const int cancellable = data == NULL;
escaped = shell_like_escape(src, 0);
if(escaped == NULL)
return -1;
snprintf(cmd, sizeof(cmd), "rm -rf %s", escaped);
LOG_INFO_MSG("Running rm command: \"%s\"", cmd);
result = run_operation_command(ops, cmd, cancellable);
free(escaped);
return result;
#else
if(is_dir(src))
{
char path[PATH_MAX];
int err;
copy_str(path, sizeof(path), src);
to_back_slash(path);
wchar_t *utf16_path = utf8_to_utf16(path);
/* SHFileOperationW requires pFrom to be double-nul terminated. */
const size_t len = wcslen(utf16_path);
utf16_path = reallocarray(utf16_path, len + 1U + 1U, sizeof(*utf16_path));
utf16_path[len + 1U] = L'\0';
SHFILEOPSTRUCTW fo = {
.hwnd = NULL,
.wFunc = FO_DELETE,
.pFrom = utf16_path,
.pTo = NULL,
.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI,
};
err = SHFileOperationW(&fo);
log_msg("Error: %d", err);
free(utf16_path);
return err;
}
else
{
int ok;
wchar_t *const utf16_path = utf8_to_utf16(src);
DWORD attributes = GetFileAttributesW(utf16_path);
if(attributes & FILE_ATTRIBUTE_READONLY)
{
SetFileAttributesW(utf16_path, attributes & ~FILE_ATTRIBUTE_READONLY);
}
ok = DeleteFileW(utf16_path);
if(!ok)
{
LOG_WERROR(GetLastError());
}
free(utf16_path);
return !ok;
}
#endif
}
