int
iop_mkdir(io_args_t *const args)
{
const char *const path = args->arg1.path;
const int create_parent = args->arg2.process_parents;
const mode_t mode = args->arg3.mode;
#ifndef _WIN32
enum { PATH_PREFIX_LEN = 0 };
#else
enum { PATH_PREFIX_LEN = 2 };
#endif
if(create_parent)
{
char *const partial_path = strdup(path);
char *part = partial_path + PATH_PREFIX_LEN, *state = NULL;
while((part = split_and_get(part, '/', &state)) != NULL)
{
if(is_dir(partial_path))
{
continue;
}
/* Create intermediate directories with 0700 permissions. */
if(os_mkdir(partial_path, S_IRWXU) != 0)
{
(void)ioe_errlst_append(&args->result.errors, partial_path, errno,
strerror(errno));
free(partial_path);
return -1;
}
}
#ifndef _WIN32
if(os_chmod(path, mode) != 0)
{
(void)ioe_errlst_append(&args->result.errors, partial_path, errno,
strerror(errno));
free(partial_path);
return 1;
}
#endif
free(partial_path);
return 0;
}
if(os_mkdir(path, mode) != 0)
{
(void)ioe_errlst_append(&args->result.errors, path, errno, strerror(errno));
return 1;
}
return 0;
}
/*
* ut_chmod -- a chmod that cannot return -1
*/
int
ut_chmod(const char *file, int line, const char *func, const char *path,
mode_t mode)
{
int retval = os_chmod(path, mode);
if (retval < 0)
ut_fatal(file, line, func, "!mode: %s %o", path, mode);
return retval;
}
/*
* grant_created_parts_perm -- (internal) set RW permission rights to all
* the parts created in place of the broken ones
*/
static int
grant_created_parts_perm(struct pool_set *set, unsigned src_repn,
struct poolset_health_status *set_hs)
{
LOG(3, "set %p, src_repn %u, set_hs %p", set, src_repn, set_hs);
/* choose the default permissions */
mode_t def_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
/* get permissions of the first part of the source replica */
mode_t src_mode;
os_stat_t sb;
if (os_stat(PART(REP(set, src_repn), 0).path, &sb) != 0) {
ERR("cannot check file permissions of %s (replica %u, part %u)",
PART(REP(set, src_repn), 0).path, src_repn, 0);
src_mode = def_mode;
} else {
src_mode = sb.st_mode;
}
/* set permissions to all recreated parts */
for (unsigned r = 0; r < set_hs->nreplicas; ++r) {
/* skip unbroken replicas */
if (!replica_is_replica_broken(r, set_hs))
continue;
if (set->replica[r]->remote)
continue;
for (unsigned p = 0; p < set_hs->replica[r]->nparts; p++) {
/* skip parts which were not created */
if (!PART(REP(set, r), p).created)
continue;
LOG(4, "setting permissions for part %u, replica %u",
p, r);
/* set rights to those of existing part files */
if (os_chmod(PART(REP(set, r), p).path, src_mode)) {
ERR("cannot set permission rights for created"
" parts: replica %u, part %u", r, p);
errno = EPERM;
return -1;
}
}
}
return 0;
}
void HTMLOutput( void )
{
#define HTMLREADBUFSIZE 512
static char buf[HTMLREADBUFSIZE];
FILE *tpl;
char *buftemp;
char *bufptr;
htmlfunc* htmlfuncptr;
tpl = os_fopen( html_template, "rt" );
if( !tpl ) {
nlog( LOG_WARNING, "Failed to open StatServ HTML template %s.", html_template );
irc_chanalert( statbot, "Failed to open StatServ HTML template %s.", html_template );
return;
}
opf = os_fopen( StatServ.htmlpath, "wt" );
if( !opf ) {
nlog( LOG_WARNING, "Failed to open HTML output file %s. Check file permissions.", StatServ.htmlpath );
irc_chanalert( statbot, "Failed to open HTML output file %s. Check file permissions.", StatServ.htmlpath );
return;
}
while( os_fgets( buf, HTMLREADBUFSIZE, tpl ) != NULL )
{
bufptr = buf;
htmlfuncptr = htmlfuncs;
while( htmlfuncptr->directive != NULL )
{
buftemp = strstr( bufptr, htmlfuncptr->directive );
if( buftemp ) {
os_fwrite( bufptr, ( int )buftemp -( int )bufptr, 1, opf );
htmlfuncptr->handler();
bufptr = buftemp + strlen( htmlfuncptr->directive );
}
htmlfuncptr++;
}
os_fputs( bufptr, opf );
}
os_fclose( tpl );
os_fclose( opf );
/* update the umode so others can read it and owner can overwrite it */
os_chmod( StatServ.htmlpath, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH );
}
/*
* util_unlink -- unlinks a file or zeroes a device dax
*/
int
util_unlink(const char *path)
{
LOG(3, "path \"%s\"", path);
enum file_type type = util_file_get_type(path);
if (type < 0)
return -1;
if (type == TYPE_DEVDAX) {
return util_file_zero(path, 0, DEVICE_DAX_ZERO_LEN);
} else {
#ifdef _WIN32
/* on Windows we can not unlink Read-Only files */
if (os_chmod(path, S_IREAD | S_IWRITE) == -1) {
ERR("!chmod \"%s\"", path);
return -1;
}
#endif
return os_unlink(path);
}
}
/* Implementation of traverse() visitor for subtree removal. Returns 0 on
* success, otherwise non-zero is returned. */
static VisitResult
rm_visitor(const char full_path[], VisitAction action, void *param)
{
io_args_t *const rm_args = param;
VisitResult result = VR_OK;
if(rm_args->cancellable && ui_cancellation_requested())
{
return VR_CANCELLED;
}
switch(action)
{
case VA_DIR_ENTER:
/* Do nothing, directories are removed on leaving them. */
result = VR_OK;
break;
case VA_FILE:
{
io_args_t args = {
.arg1.path = full_path,
.cancellable = rm_args->cancellable,
.estim = rm_args->estim,
.result = rm_args->result,
};
result = (iop_rmfile(&args) == 0) ? VR_OK : VR_ERROR;
rm_args->result = args.result;
break;
}
case VA_DIR_LEAVE:
{
io_args_t args = {
.arg1.path = full_path,
.cancellable = rm_args->cancellable,
.estim = rm_args->estim,
.result = rm_args->result,
};
result = (iop_rmdir(&args) == 0) ? VR_OK : VR_ERROR;
rm_args->result = args.result;
break;
}
}
return result;
}
int
ior_cp(io_args_t *const args)
{
const char *const src = args->arg1.src;
const char *const dst = args->arg2.dst;
if(is_in_subtree(dst, src))
{
(void)ioe_errlst_append(&args->result.errors, src, IO_ERR_UNKNOWN,
"Can't copy parent path into subpath");
return 1;
}
if(args->arg3.crs == IO_CRS_REPLACE_ALL)
{
io_args_t rm_args = {
.arg1.path = dst,
.cancellable = args->cancellable,
.estim = args->estim,
.result = args->result,
};
const int result = ior_rm(&rm_args);
args->result = rm_args.result;
if(result != 0)
{
if(!args->cancellable || !ui_cancellation_requested())
{
(void)ioe_errlst_append(&args->result.errors, dst, IO_ERR_UNKNOWN,
"Failed to remove");
}
return result;
}
}
return traverse(src, &cp_visitor, args);
}
/* Implementation of traverse() visitor for subtree copying. Returns 0 on
* success, otherwise non-zero is returned. */
static VisitResult
cp_visitor(const char full_path[], VisitAction action, void *param)
{
return cp_mv_visitor(full_path, action, param, 1);
}
int
ior_mv(io_args_t *const args)
{
const char *const src = args->arg1.src;
const char *const dst = args->arg2.dst;
const IoCrs crs = args->arg3.crs;
const io_confirm confirm = args->confirm;
if(crs == IO_CRS_FAIL && path_exists(dst, DEREF) && !is_case_change(src, dst))
{
(void)ioe_errlst_append(&args->result.errors, dst, EEXIST,
strerror(EEXIST));
return 1;
}
if(crs == IO_CRS_APPEND_TO_FILES)
{
if(!is_file(src))
{
(void)ioe_errlst_append(&args->result.errors, src, EISDIR,
strerror(EISDIR));
return 1;
}
if(!is_file(dst))
{
(void)ioe_errlst_append(&args->result.errors, dst, EISDIR,
strerror(EISDIR));
return 1;
}
}
else if(crs == IO_CRS_REPLACE_FILES && path_exists(dst, DEREF))
{
/* Ask user whether to overwrite destination file. */
if(confirm != NULL && !confirm(args, src, dst))
{
return 0;
}
}
if(os_rename(src, dst) == 0)
{
ioeta_update(args->estim, src, dst, 1, 0);
return 0;
}
switch(errno)
{
case EXDEV:
{
int result = ior_cp(args);
if(result == 0)
{
io_args_t rm_args = {
.arg1.path = src,
.cancellable = args->cancellable,
.estim = args->estim,
.result = args->result,
};
/* Disable progress reporting for this "secondary" operation. */
const int silent = ioeta_silent_on(rm_args.estim);
result = ior_rm(&rm_args);
args->result = rm_args.result;
ioeta_silent_set(rm_args.estim, silent);
}
return result;
}
case EISDIR:
case ENOTEMPTY:
case EEXIST:
#ifdef _WIN32
/* For MXE builds running in Wine. */
case EPERM:
case EACCES:
#endif
if(crs == IO_CRS_REPLACE_ALL)
{
int error;
io_args_t rm_args = {
.arg1.path = dst,
.cancellable = args->cancellable,
.estim = args->estim,
.result = args->result,
};
/* Ask user whether to overwrite destination file. */
if(confirm != NULL && !confirm(args, src, dst))
{
return 0;
}
error = ior_rm(&rm_args);
args->result = rm_args.result;
if(error != 0)
{
if(!args->cancellable || !ui_cancellation_requested())
{
(void)ioe_errlst_append(&args->result.errors, dst, IO_ERR_UNKNOWN,
"Failed to remove");
}
return error;
}
if(os_rename(src, dst) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
return 1;
}
return 0;
}
else if(crs == IO_CRS_REPLACE_FILES ||
(!has_atomic_file_replace() && crs == IO_CRS_APPEND_TO_FILES))
{
if(!has_atomic_file_replace() && is_file(dst))
{
io_args_t rm_args = {
.arg1.path = dst,
.cancellable = args->cancellable,
.estim = args->estim,
.result = args->result,
};
const int error = iop_rmfile(&rm_args);
args->result = rm_args.result;
if(error != 0)
{
if(!args->cancellable || !ui_cancellation_requested())
{
(void)ioe_errlst_append(&args->result.errors, dst, IO_ERR_UNKNOWN,
"Failed to remove");
}
return error;
}
}
return traverse(src, &mv_visitor, args);
}
/* Break is intentionally omitted. */
default:
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
return errno;
}
}
/* Checks that path points to a file or symbolic link. Returns non-zero if so,
* otherwise zero is returned. */
static int
is_file(const char path[])
{
return !is_dir(path)
|| (is_symlink(path) && get_symlink_type(path) != SLT_UNKNOWN);
}
/* Implementation of traverse() visitor for subtree moving. Returns 0 on
* success, otherwise non-zero is returned. */
static VisitResult
mv_visitor(const char full_path[], VisitAction action, void *param)
{
return cp_mv_visitor(full_path, action, param, 0);
}
/* Generic implementation of traverse() visitor for subtree copying/moving.
* Returns 0 on success, otherwise non-zero is returned. */
static VisitResult
cp_mv_visitor(const char full_path[], VisitAction action, void *param, int cp)
{
io_args_t *const cp_args = param;
const char *dst_full_path;
char *free_me = NULL;
VisitResult result = VR_OK;
const char *rel_part;
if(cp_args->cancellable && ui_cancellation_requested())
{
return VR_CANCELLED;
}
/* TODO: come up with something better than this. */
rel_part = full_path + strlen(cp_args->arg1.src);
dst_full_path = (rel_part[0] == '\0')
? cp_args->arg2.dst
: (free_me = format_str("%s/%s", cp_args->arg2.dst, rel_part));
switch(action)
{
case VA_DIR_ENTER:
if(cp_args->arg3.crs != IO_CRS_REPLACE_FILES || !is_dir(dst_full_path))
{
io_args_t args = {
.arg1.path = dst_full_path,
/* Temporary fake rights so we can add files to the directory. */
.arg3.mode = 0700,
.cancellable = cp_args->cancellable,
.estim = cp_args->estim,
.result = cp_args->result,
};
result = (iop_mkdir(&args) == 0) ? VR_OK : VR_ERROR;
cp_args->result = args.result;
}
break;
case VA_FILE:
{
io_args_t args = {
.arg1.src = full_path,
.arg2.dst = dst_full_path,
.arg3.crs = cp_args->arg3.crs,
/* It's safe to always use fast file cloning on moving files. */
.arg4.fast_file_cloning = cp ? cp_args->arg4.fast_file_cloning : 1,
.cancellable = cp_args->cancellable,
.confirm = cp_args->confirm,
.estim = cp_args->estim,
.result = cp_args->result,
};
result = ((cp ? iop_cp(&args) : ior_mv(&args)) == 0) ? VR_OK : VR_ERROR;
cp_args->result = args.result;
break;
}
case VA_DIR_LEAVE:
{
struct stat st;
if(cp_args->arg3.crs == IO_CRS_REPLACE_FILES && !cp)
{
io_args_t rm_args = {
.arg1.path = full_path,
.cancellable = cp_args->cancellable,
.estim = cp_args->estim,
.result = cp_args->result,
};
result = (iop_rmdir(&rm_args) == 0) ? VR_OK : VR_ERROR;
}
else if(os_stat(full_path, &st) == 0)
{
result = (os_chmod(dst_full_path, st.st_mode & 07777) == 0)
? VR_OK
: VR_ERROR;
if(result == VR_ERROR)
{
(void)ioe_errlst_append(&cp_args->result.errors, dst_full_path,
errno, strerror(errno));
}
clone_timestamps(dst_full_path, full_path, &st);
}
else
{
(void)ioe_errlst_append(&cp_args->result.errors, full_path, errno,
strerror(errno));
result = VR_ERROR;
}
break;
}
}
free(free_me);
return result;
}
int
iop_cp(io_args_t *const args)
{
const char *const src = args->arg1.src;
const char *const dst = args->arg2.dst;
const IoCrs crs = args->arg3.crs;
const io_confirm confirm = args->confirm;
const int cancellable = args->cancellable;
struct stat st;
char block[BLOCK_SIZE];
FILE *in, *out;
size_t nread;
int error;
struct stat src_st;
const char *open_mode = "wb";
ioeta_update(args->estim, src, dst, 0, 0);
#ifdef _WIN32
if(is_symlink(src) || crs != IO_CRS_APPEND_TO_FILES)
{
DWORD flags;
int error;
wchar_t *utf16_src, *utf16_dst;
flags = COPY_FILE_COPY_SYMLINK;
if(crs == IO_CRS_FAIL)
{
flags |= COPY_FILE_FAIL_IF_EXISTS;
}
else if(path_exists(dst, DEREF))
{
/* Ask user whether to overwrite destination file. */
if(confirm != NULL && !confirm(args, src, dst))
{
return 0;
}
}
utf16_src = utf8_to_utf16(src);
utf16_dst = utf8_to_utf16(dst);
error = CopyFileExW(utf16_src, utf16_dst, &win_progress_cb, args, NULL,
flags) == 0;
if(error)
{
/* FIXME: use real system error message here. */
(void)ioe_errlst_append(&args->result.errors, dst, IO_ERR_UNKNOWN,
"Copy file failed");
}
free(utf16_src);
free(utf16_dst);
ioeta_update(args->estim, NULL, NULL, 1, 0);
return error;
}
#endif
/* Create symbolic link rather than copying file it points to. This check
* should go before directory check as is_dir() resolves symbolic links. */
if(is_symlink(src))
{
char link_target[PATH_MAX];
int error;
io_args_t ln_args = {
.arg1.path = link_target,
.arg2.target = dst,
.arg3.crs = crs,
.cancellable = cancellable,
.result = args->result,
};
if(get_link_target(src, link_target, sizeof(link_target)) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, IO_ERR_UNKNOWN,
"Failed to get symbolic link target");
return 1;
}
error = iop_ln(&ln_args);
args->result = ln_args.result;
if(error != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, IO_ERR_UNKNOWN,
"Failed to make symbolic link");
return 1;
}
return 0;
}
if(is_dir(src))
{
(void)ioe_errlst_append(&args->result.errors, src, EISDIR,
strerror(EISDIR));
return 1;
}
if(os_stat(src, &st) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno, strerror(errno));
return 1;
}
#ifndef _WIN32
/* Fifo/socket/device files don't need to be opened, their content is not
* accessed. */
if(S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode) || S_ISBLK(st.st_mode) ||
S_ISCHR(st.st_mode))
{
in = NULL;
}
else
#endif
{
in = os_fopen(src, "rb");
if(in == NULL)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
return 1;
}
}
if(crs == IO_CRS_APPEND_TO_FILES)
{
open_mode = "ab";
}
else if(crs != IO_CRS_FAIL)
{
int ec;
if(path_exists(dst, DEREF))
{
/* Ask user whether to overwrite destination file. */
if(confirm != NULL && !confirm(args, src, dst))
{
if(in != NULL && fclose(in) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
}
return 0;
}
}
ec = unlink(dst);
if(ec != 0 && errno != ENOENT)
{
(void)ioe_errlst_append(&args->result.errors, dst, errno,
strerror(errno));
if(in != NULL && fclose(in) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
}
return ec;
}
/* XXX: possible improvement would be to generate temporary file name in the
* destination directory, write to it and then overwrite destination file,
* but this approach has disadvantage of requiring more free space on
* destination file system. */
}
else if(path_exists(dst, DEREF))
{
(void)ioe_errlst_append(&args->result.errors, src, EEXIST,
strerror(EEXIST));
if(in != NULL && fclose(in) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
}
return 1;
}
#ifndef _WIN32
/* Replicate fifo without even opening it. */
if(S_ISFIFO(st.st_mode))
{
if(mkfifo(dst, st.st_mode & 07777) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
return 1;
}
return 0;
}
/* Replicate socket or device file without even opening it. */
if(S_ISSOCK(st.st_mode) || S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode))
{
if(mknod(dst, st.st_mode & (S_IFMT | 07777), st.st_rdev) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
return 1;
}
return 0;
}
#endif
out = os_fopen(dst, open_mode);
if(out == NULL)
{
(void)ioe_errlst_append(&args->result.errors, dst, errno, strerror(errno));
if(fclose(in) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
}
return 1;
}
error = 0;
if(crs == IO_CRS_APPEND_TO_FILES)
{
fpos_t pos;
/* The following line is required for stupid Windows sometimes. Why?
* Probably because it's stupid... Won't harm other systems. */
fseek(out, 0, SEEK_END);
error = fgetpos(out, &pos) != 0 || fsetpos(in, &pos) != 0;
if(!error)
{
ioeta_update(args->estim, NULL, NULL, 0, get_file_size(dst));
}
}
/* TODO: use sendfile() if platform supports it. */
while((nread = fread(&block, 1, sizeof(block), in)) != 0U)
{
if(cancellable && ui_cancellation_requested())
{
error = 1;
break;
}
if(fwrite(&block, 1, nread, out) != nread)
{
(void)ioe_errlst_append(&args->result.errors, dst, errno,
strerror(errno));
error = 1;
break;
}
ioeta_update(args->estim, NULL, NULL, 0, nread);
}
if(nread == 0U && !feof(in) && ferror(in))
{
(void)ioe_errlst_append(&args->result.errors, src, errno, strerror(errno));
}
if(fclose(in) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno, strerror(errno));
}
if(fclose(out) != 0)
{
(void)ioe_errlst_append(&args->result.errors, dst, errno, strerror(errno));
}
if(error == 0 && os_lstat(src, &src_st) == 0)
{
error = os_chmod(dst, src_st.st_mode & 07777);
if(error != 0)
{
(void)ioe_errlst_append(&args->result.errors, dst, errno,
strerror(errno));
}
}
ioeta_update(args->estim, NULL, NULL, 1, 0);
return error;
}
#ifdef _WIN32
static DWORD CALLBACK win_progress_cb(LARGE_INTEGER total,
LARGE_INTEGER transferred, LARGE_INTEGER stream_size,
LARGE_INTEGER stream_transfered, DWORD stream_num, DWORD reason,
HANDLE src_file, HANDLE dst_file, LPVOID param)
{
static LONGLONG last_size;
io_args_t *const args = param;
const char *const src = args->arg1.src;
const char *const dst = args->arg2.dst;
ioeta_estim_t *const estim = args->estim;
if(transferred.QuadPart < last_size)
{
last_size = 0;
}
ioeta_update(estim, src, dst, 0, transferred.QuadPart - last_size);
last_size = transferred.QuadPart;
if(args->cancellable && ui_cancellation_requested())
{
return PROGRESS_CANCEL;
}
return PROGRESS_CONTINUE;
}
#endif
/* TODO: implement iop_chown(). */
int iop_chown(io_args_t *const args);
/* TODO: implement iop_chgrp(). */
int iop_chgrp(io_args_t *const args);
/* TODO: implement iop_chmod(). */
int iop_chmod(io_args_t *const args);
int
iop_ln(io_args_t *const args)
{
const char *const path = args->arg1.path;
const char *const target = args->arg2.target;
const int overwrite = args->arg3.crs != IO_CRS_FAIL;
int result;
#ifdef _WIN32
char cmd[6 + PATH_MAX*2 + 1];
char *escaped_path, *escaped_target;
char base_dir[PATH_MAX + 2];
#endif
#ifndef _WIN32
result = symlink(path, target);
if(result != 0 && errno == EEXIST && overwrite && is_symlink(target))
{
result = remove(target);
if(result == 0)
{
result = symlink(path, target);
if(result != 0)
{
(void)ioe_errlst_append(&args->result.errors, path, errno,
strerror(errno));
}
}
else
{
(void)ioe_errlst_append(&args->result.errors, target, errno,
strerror(errno));
}
}
else if(result != 0 && errno != 0)
{
(void)ioe_errlst_append(&args->result.errors, target, errno,
strerror(errno));
}
#else
if(!overwrite && path_exists(target, DEREF))
{
(void)ioe_errlst_append(&args->result.errors, target, EEXIST,
strerror(EEXIST));
return -1;
}
if(overwrite && !is_symlink(target))
{
(void)ioe_errlst_append(&args->result.errors, target, IO_ERR_UNKNOWN,
"Target is not a symbolic link");
return -1;
}
escaped_path = shell_like_escape(path, 0);
escaped_target = shell_like_escape(target, 0);
if(escaped_path == NULL || escaped_target == NULL)
{
(void)ioe_errlst_append(&args->result.errors, target, IO_ERR_UNKNOWN,
"Not enough memory");
free(escaped_target);
free(escaped_path);
return -1;
}
if(GetModuleFileNameA(NULL, base_dir, ARRAY_LEN(base_dir)) == 0)
{
(void)ioe_errlst_append(&args->result.errors, target, IO_ERR_UNKNOWN,
"Failed to find win_helper");
free(escaped_target);
free(escaped_path);
return -1;
}
break_atr(base_dir, '\\');
snprintf(cmd, sizeof(cmd), "%s\\win_helper -s %s %s", base_dir, escaped_path,
escaped_target);
result = os_system(cmd);
if(result != 0)
{
(void)ioe_errlst_append(&args->result.errors, target, IO_ERR_UNKNOWN,
"Running win_helper has failed");
}
free(escaped_target);
free(escaped_path);
#endif
return result;
}
