char *makepath(char *buf, int buf_size, const char *path,
const char *filename)
{
pstrcpy(buf, buf_size, path);
append_slash(buf, buf_size);
return pstrcat(buf, buf_size, filename);
}
int
local_filter_matches(view_t *view, const dir_entry_t *entry)
{
/* FIXME: some very long file names won't be matched against some regexps. */
char name_with_slash[NAME_MAX + 1 + 1];
const char *filename = entry->name;
if(fentry_is_dir(entry))
{
append_slash(filename, name_with_slash, sizeof(name_with_slash));
filename = name_with_slash;
}
return filter_matches(&view->local_filter.filter, filename) != 0;
}
char *append_path(char *environ, char *av)
{
char **path_env;
char *ret;
if (!environ)
return (av);
ret = NULL;
path_env = ft_strsplit(environ, ':');
path_env = append_slash(path_env, &environ);
ret = check_path(path_env, av);
if (ret)
av = ft_strdup(ret);
free_double_array(path_env);
ft_memdel((void**)&ret);
return (av);
}
/* zap_entries() filter to filter-out files that match filter passed in the
* arg. */
static int
is_newly_filtered(view_t *view, const dir_entry_t *entry, void *arg)
{
filter_t *const filter = arg;
/* FIXME: some very long file names won't be matched against some regexps. */
char name_with_slash[NAME_MAX + 1 + 1];
const char *filename = entry->name;
if(fentry_is_dir(entry))
{
append_slash(filename, name_with_slash, sizeof(name_with_slash));
filename = name_with_slash;
}
return filter_matches(filter, filename) == 0;
}
int
filters_file_is_visible(view_t *view, const char dir[], const char name[],
int is_dir, int apply_local_filter)
{
/* FIXME: some very long file names won't be matched against some regexps. */
char name_with_slash[NAME_MAX + 1 + 1];
char path[PATH_MAX + sizeof(name_with_slash)];
if(is_dir)
{
append_slash(name, name_with_slash, sizeof(name_with_slash));
name = name_with_slash;
}
if(filter_matches(&view->auto_filter, name) > 0)
{
return 0;
}
if(apply_local_filter &&
filter_matches(&view->local_filter.filter, name) == 0)
{
return 0;
}
if(matcher_is_empty(view->manual_filter))
{
return 1;
}
if(matcher_is_full_path(view->manual_filter))
{
const size_t nchars = copy_str(path, sizeof(path) - 1, dir);
path[nchars - 1U] = '/';
copy_str(path + nchars, sizeof(path) - nchars, name);
name = path;
}
return matcher_matches(view->manual_filter, name)
? !view->invert
: view->invert;
}
/* Copies/moves elements of the unfiltered list into dir_entry list. add
* parameter controls whether entries matching filter are copied into dir_entry
* list. clear parameter controls whether entries not matching filter are
* cleared in unfiltered list. Returns zero unless addition is performed in
* which case can return non-zero when all files got filtered out. */
static int
update_filtering_lists(view_t *view, int add, int clear)
{
/* filters_drop_temporaries() is a similar function. */
size_t i;
size_t list_size = 0U;
dir_entry_t *parent_entry = NULL;
int parent_added = 0;
for(i = 0; i < view->local_filter.unfiltered_count; ++i)
{
/* FIXME: some very long file names won't be matched against some
* regexps. */
char name_with_slash[NAME_MAX + 1 + 1];
dir_entry_t *const entry = &view->local_filter.unfiltered[i];
const char *name = entry->name;
if(is_parent_dir(name))
{
if(entry->child_pos == 0)
{
parent_entry = entry;
if(add && cfg_parent_dir_is_visible(is_root_dir(view->curr_dir)))
{
(void)add_dir_entry(&view->dir_entry, &list_size, entry);
parent_added = 1;
}
continue;
}
else if(!filter_is_empty(&view->local_filter.filter))
{
if(clear)
{
fentry_free(view, entry);
}
continue;
}
}
if(fentry_is_dir(entry))
{
append_slash(name, name_with_slash, sizeof(name_with_slash));
name = name_with_slash;
}
/* tag links to position of nodes passed through filter in list of visible
* files. Nodes that didn't pass have -1. */
entry->tag = -1;
if(filter_matches(&view->local_filter.filter, name) != 0)
{
if(add)
{
dir_entry_t *e = add_dir_entry(&view->dir_entry, &list_size, entry);
if(e != NULL)
{
entry->tag = list_size - 1U;
/* We basically grow the tree node by node while performing
* reparenting. */
reparent_tree_node(entry, e);
}
}
}
else
{
if(clear)
{
fentry_free(view, entry);
}
}
}
if(clear)
{
/* XXX: the check of name pointer is horrible, but is needed to prevent
* freeing of entry in use. */
if(!parent_added && parent_entry != NULL && list_size != 0U &&
view->dir_entry[0].name != parent_entry->name)
{
fentry_free(view, parent_entry);
}
}
if(add)
{
view->list_rows = list_size;
view->filtered = view->local_filter.prefiltered_count
+ view->local_filter.unfiltered_count - list_size;
ensure_filtered_list_not_empty(view, parent_entry);
return list_size == 0U
|| (list_size == 1U && parent_added &&
(filter_matches(&view->local_filter.filter, "../") == 0));
}
return 0;
}
void
name_filters_add_selection(view_t *view)
{
dir_entry_t *entry;
filter_t filter;
int filtered;
(void)filter_init(&filter, FILTER_DEF_CASE_SENSITIVITY);
/* Traverse items and update/create filter values. */
entry = NULL;
while(iter_selection_or_current(view, &entry))
{
const char *name = entry->name;
char name_with_slash[NAME_MAX + 1 + 1];
if(fentry_is_dir(entry))
{
append_slash(entry->name, name_with_slash, sizeof(name_with_slash));
name = name_with_slash;
}
(void)filter_append(&view->auto_filter, name);
(void)filter_append(&filter, name);
}
/* Even current file might be unavailable for filtering. In this case, just
* do nothing. */
if(filter_is_empty(&filter))
{
filter_dispose(&filter);
return;
}
if(view->custom.type == CV_DIFF)
{
(void)filter_in_compare(view, &filter, &is_newly_filtered);
ui_view_schedule_redraw(view);
filter_dispose(&filter);
return;
}
/* Update entry lists to remove entries that must be filtered out now. No
* view reload is needed. */
filtered = zap_entries(view, view->dir_entry, &view->list_rows,
&is_newly_filtered, &filter, 0, 1);
if(flist_custom_active(view))
{
(void)zap_entries(view, view->local_filter.entries,
&view->local_filter.entry_count, &is_newly_filtered, &filter, 1, 1);
}
else
{
view->filtered += filtered;
}
filter_dispose(&filter);
fpos_ensure_valid_pos(view);
ui_view_schedule_redraw(view);
}
int main(int argc,char** argv)
{
char _path[260];
char _root[260];
FiEvent evnt;
INIT_G();
G.logFileSize = _M(100);
G.logFile.fd = STDOUT_FILENO;
FiGetCurDir(sizeof(_path),_path);
strcpy(_root, _path);
std::string str(_path);
dirname(_root);
append_slash(_root);
G.exe = _path;
G.root = _root;
str+="FiUpdateMgr.log";
freopen(str.c_str(),"a",stdout);
#if 1
if (0 == chdir(G.exe))
{
ut_dbg("change cur dir success\n");
}
else
{
ut_err("change cur dir fail\n");
}
#endif
#ifndef WIN32
FiEnableCoreDumps();
pthread_t tid[3];
pthread_attr_t attr[3];
struct stat st;
umparams.type = SERVER;//default type
umparams.master == false;
FiUpdateAssistant::getinstance()->set(&evnt);
if (init_param(argc, argv) < 0)
{
print_usage(stderr, 1);
return -1;
}
if (stat("../download", &st) == -1)
{
ut_err("stat error num :%d\n", errno);
}
else
{
if (!S_ISDIR(st.st_mode))
{
system("rm ../download -rf");
}
}
system("mkdir -p ../download");
if (pthread_attr_init(&attr[0]) < 0)
{
ut_err("set attr fail\n");
}
if (pthread_attr_init(&attr[1]) < 0)
{
ut_err("set attr fail\n");
}
if (pthread_attr_init(&attr[2]) < 0)
{
ut_err("set attr fail\n");
}
pthread_attr_setdetachstate(&attr[0], PTHREAD_CREATE_DETACHED);
pthread_attr_setdetachstate(&attr[1], PTHREAD_CREATE_DETACHED);
pthread_attr_setdetachstate(&attr[2], PTHREAD_CREATE_DETACHED);
if (sendHello()<0)
{
ut_err("send hello fail\n");
}
pthread_create(&tid[0], &attr[0], selfUpdate, NULL);
if (umparams.master == false)
{
pthread_create(&tid[1], &attr[1], recvHelloHandler, NULL);
}
else
{
pthread_create(&tid[2], &attr[2], heartHandler, NULL);
}
#endif
UpdateSrv = new FiRpcSrv<FiUpdateMgrImpl>(RPC_PORT, RPC_SERVER_NAME, (char*)(NULL));
UpdateSrv->run();
#if 0
evnt.wait();
#else
do
{
#ifdef WIN32
Sleep(1000);
#else
sleep(1);
#endif
}while(true);
#endif
return 0;
}
