static void _activate_file(madshelf_state_t* state, int item_num) { _loc_t* _loc = (_loc_t*)state->loc; char* filename = eina_array_data_get(_loc->files, item_num); if(!ecore_file_exists(filename)) return; if(ecore_file_is_dir(filename)) { go_to_directory(state, filename); return; } run_default_handler(state, filename); }
static char * _check_icon(const char *icon, const char *dir, const char *ext) { char tmp[PATH_MAX]; char *format; if (ext) format = "%s/%s.%s"; else format = "%s/%s"; snprintf(tmp, sizeof (tmp), format, dir, icon, ext); if (!ecore_file_is_dir(tmp) && ecore_file_can_read(tmp)) return strdup(tmp); else return NULL; }
static void bs_gocomics_show (Evas_Object *layout) { char dst[1024] = { 0 }; mod = calloc (1, sizeof(Bookstore_Service_GoComics)); /* create comic strips download destination path */ snprintf(dst, sizeof(dst), "~/.enna/%s", GOCOMICS_PATH); if (!ecore_file_is_dir(dst)) if(ecore_file_mkpath(dst)) printf("mkpath true\n"); mod->path = strdup (dst); mod->url = url_new(); mod->layout = layout; gocomics_set_comic_name(); gocomics_create_menu(); }
E_API int e_util_dir_check(const char *dir) { if (!ecore_file_exists(dir)) { if (!ecore_file_mkpath(dir)) { e_util_dialog_show(_("Error creating directory"), _("Failed to create directory: %s .<br>Check that you have correct permissions set."), dir); return 0; } } else { if (!ecore_file_is_dir(dir)) { e_util_dialog_show(_("Error creating directory"), _("Failed to create directory: %s .<br>A file of that name already exists."), dir); return 0; } } return 1; }
ActivityWidgetsView::ActivityWidgetsView(Evas *_e, Evas_Object *_parent): ActivityView(_e, _parent, "calaos/page/widgets") { clipper = evas_object_rectangle_add(evas); evas_object_color_set(clipper, 0, 0, 0, 0); evas_object_show(clipper); Swallow(clipper, "widgets.swallow", true); //Create a temporary dir for modules if (ecore_file_is_dir("/tmp/calaos_widgets")) ecore_file_recursive_rm("/tmp/calaos_widgets"); ecore_file_mkpath("/tmp/calaos_widgets"); //add search paths for modules ModuleManager::Instance().addPath(PACKAGE_LIB_DIR "/calaos/widgets"); ModuleManager::Instance().addPath("/usr/lib/calaos/widgets"); ModuleManager::Instance().SearchModules(); LoadWidgets(); }
static void _walle_wall_populate(Walle *walle, const char *directory, const char *theme) { Evas_Object *o; Evas_Coord ow, oh, w, h; Eina_List *files = NULL; char *file = NULL; char filename[4096]; if (!ecore_file_is_dir(directory) && ecore_file_dir_is_empty(directory)) return; files = ecore_file_ls(directory); if (!files) return; EINA_LIST_FREE(files, file) { sprintf(filename, "%s/%s", directory, file); o = evas_object_image_add(walle->evas); evas_object_image_file_set(o, filename, NULL); switch(evas_object_image_load_error_get(o)) { case EVAS_LOAD_ERROR_NONE: { evas_object_event_callback_add(o, EVAS_CALLBACK_RESIZE, _walle_picture_cb_resize, o); evas_object_image_size_get(o, &w, &h); oh = 200; ow = oh * (float)w/(float)h; evas_object_image_load_size_set(o, ow, oh); evas_object_image_fill_set(o, 0, 0, ow, oh); evas_object_resize(o, ow, oh); evas_object_size_hint_min_set(o, ow, oh); walle_wall_append(walle->o_wall, o); walle->pictures = eina_list_append(walle->pictures, o); } break; default: evas_object_del(o); break; } }
static Ems_Config * _config_get(Eet_Data_Descriptor *edd) { Ems_Config *config = NULL; Eet_File *file; if (!ecore_file_is_dir(ems_config_tmp_dirname_get())) ecore_file_mkdir(ems_config_tmp_dirname_get()); file = eet_open(ems_config_tmp_filename_get(), EET_FILE_MODE_READ_WRITE); config = eet_data_read(file, edd, "config"); if (!config) { WRN("Warning no configuration found! This must not happen, we will go back to a void configuration"); return NULL; } eet_close(file); return config; }
static Eina_List * efreet_util_menus_find_helper(Eina_List *menus, const char *config_dir) { DIR *files = NULL; struct dirent *file = NULL; char dbuf[PATH_MAX], fbuf[PATH_MAX]; snprintf(dbuf, sizeof(dbuf), "%s/menus", config_dir); files = opendir(dbuf); if (!files) return menus; while ((file = readdir(files))) { const char *exten; exten = strrchr(file->d_name, '.'); if (!exten) continue; if (strcmp(".menu", exten)) continue; snprintf(fbuf, sizeof(fbuf), "%s/%s", dbuf, file->d_name); if (ecore_file_is_dir(fbuf)) continue; menus = eina_list_append(menus, strdup(fbuf)); } closedir(files); return menus; }
static void _fill_list (Evasxx::Object *obj) { DIR *d; struct dirent *de; Eina_List *dirs = NULL, *l; char *real; if (!(d = opendir(getenv("HOME")))) return; while ((de = readdir(d)) != NULL) { char buff[PATH_MAX]; if (de->d_name[0] == '.') continue; snprintf(buff, sizeof(buff), "%s/%s", getenv("HOME"), de->d_name); if (!ecore_file_is_dir(buff)) continue; real = ecore_file_realpath(buff); dirs = eina_list_append(dirs, real); } closedir(d); dirs = eina_list_sort(dirs, eina_list_count(dirs), EINA_COMPARE_CB(strcoll)); #if 0 EINA_LIST_FOREACH(dirs, l, real) { Eina_Bool result = EINA_FALSE; result = _dir_has_subs(real); if (!result) elm_genlist_item_append(obj, &itc, eina_stringshare_add(real), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); else elm_genlist_item_append(obj, &itc, eina_stringshare_add(real), NULL, ELM_GENLIST_ITEM_TREE, NULL, NULL); free(real); }
/* Sets the folder displayed in the iconbox */ static void _etk_test_iconbox_folder_set(Etk_Iconbox *iconbox, const char *folder) { Eina_List *files; Eina_List *l; char *filename; char file_path[PATH_MAX]; Etk_Iconbox_Icon *iicon; if (!iconbox) return; if (!folder && !(folder = getenv("HOME"))) return; if (!(files = ecore_file_ls(folder))) return; etk_iconbox_clear(iconbox); etk_iconbox_append(iconbox, etk_theme_icon_path_get(), "actions/go-up_48", ".."); /* First, add the folders */ EINA_LIST_FOREACH(files, l, filename) { if (filename[0] == '.') continue; snprintf(file_path, PATH_MAX, "%s/%s", folder, filename); if (!ecore_file_is_dir(file_path)) continue; iicon = etk_iconbox_append(iconbox, etk_theme_icon_path_get(), "places/folder_48", filename); if (!ecore_file_can_read(file_path)) etk_iconbox_icon_emblem_set_from_stock(iicon, "unreadable"); else if (!ecore_file_can_write(file_path)) etk_iconbox_icon_emblem_set_from_stock(iicon, "readonly"); } /* Then the files */ EINA_LIST_FOREACH(files, l, filename) { const char *ext; char *icon = NULL; int i; if (filename[0] == '.') continue; snprintf(file_path, PATH_MAX, "%s/%s", folder, filename); if (ecore_file_is_dir(file_path)) continue; if ((ext = strrchr(filename, '.')) && (ext = ext + 1)) { for (i = 0; i < _etk_test_iconbox_num_types; i++) { if (strcasecmp(ext, _etk_test_iconbox_types[i].extension) == 0) { icon = _etk_test_iconbox_types[i].icon; break; } } } iicon = etk_iconbox_append(iconbox, etk_theme_icon_path_get(), icon ? icon : "mimetypes/text-x-generic_48", filename); if (!ecore_file_can_read(file_path)) etk_iconbox_icon_emblem_set_from_stock(iicon, "unreadable"); else if (!ecore_file_can_write(file_path)) etk_iconbox_icon_emblem_set_from_stock(iicon, "readonly"); else if (ecore_file_can_exec(file_path)) etk_iconbox_icon_emblem_set_from_stock(iicon, "system"); } EINA_LIST_FREE(files, filename) free(filename); if (!_etk_test_iconbox_current_folder) _etk_test_iconbox_current_folder = etk_string_new(NULL); etk_string_set(_etk_test_iconbox_current_folder, folder); etk_window_title_set(ETK_WINDOW(win), folder); }
/* * List depends on: * - state->sort * - state->tags * - state->filter * - dir contents on FS */ static Eina_Array * _fill_files(const madshelf_state_t *state, const char *dir, int *old_pos) { char *old_file = curdir_get(dir); if(old_pos) *old_pos = -1; Eina_Array *files = eina_array_new(10); /* HACK: using global variable to pas state into sort function */ cur_dir = !strcmp(dir, "/") ? "" : dir; Eina_List *ls = ecore_file_ls(dir); ls = eina_list_sort(ls, eina_list_count(ls), state->sort == MADSHELF_SORT_NAME ? &_name : (state->sort == MADSHELF_SORT_NAMEREV ? &_namerev : &_daterev)); /* First select directories */ for (Eina_List *i = ls; i; i = eina_list_next(i)) { const char *file = eina_list_data_get(i); char *filename = xasprintf("%s/%s", !strcmp(dir, "/") ? "" : dir, file); if (!ecore_file_is_dir(filename)) { free(filename); continue; } if (!state->show_hidden && is_hidden(state, filename)) { free(filename); continue; } if (old_file && old_pos) if (!strcmp(old_file, file)) *old_pos = eina_array_count_get(files); eina_array_push(files, filename); } /* Then files */ for (Eina_List *i = ls; i; i = eina_list_next(i)) { const char *file = eina_list_data_get(i); char *filename = xasprintf("%s/%s", !strcmp(dir, "/") ? "" : dir, file); if (ecore_file_is_dir(filename)) { free(filename); continue; } if (!state->show_hidden && is_hidden(state, filename)) { free(filename); continue; } if (old_file && old_pos) if (!strcmp(old_file, file)) *old_pos = eina_array_count_get(files); eina_array_push(files, filename); } char* s; EINA_LIST_FREE(ls, s) free(s); free(old_file); return files; }
/** * @brief Download the given url to the given destination. * * @param url The complete url to download. * @param dst The local file to save the downloaded to. * @param completion_cb A callback called on download complete. * @param progress_cb A callback called during the download operation. * @param data User data passed to both callbacks. * @param job_ret Job used to abort the download. * @return EINA_TRUE if the download start or EINA_FALSE on failure * * This function starts the download of the URL @p url and saves it to * @p dst. @p url must provide the protocol, including 'http://', * 'ftp://' or 'file://'. Ecore_File must be compiled with CURL to * download using http and ftp protocols. If @p dst is ill-formed, or * if it already exists, the function returns EINA_FALSE. When the * download is complete, the callback @p completion_cb is called and * @p data is passed to it. The @p status parameter of @p completion_cb * will be filled with the status of the download (200, 404,...). The * @p progress_cb is called during the download operation, each time a * packet is received or when CURL wants. It can be used to display the * percentage of the downloaded file. Return 0 from this callback, if provided, * to continue the operation or anything else to abort the download. The only * operations that can be aborted are those with protocol 'http' or 'ftp'. In * that case @p job_ret can be filled. It can be used with * ecore_file_download_abort() or ecore_file_download_abort_all() to * respectively abort one or all download operations. This function returns * EINA_TRUE if the download starts, EINA_FALSE otherwise. */ EAPI Eina_Bool ecore_file_download(const char *url, const char *dst, Ecore_File_Download_Completion_Cb completion_cb, Ecore_File_Download_Progress_Cb progress_cb, void *data, Ecore_File_Download_Job **job_ret) { #ifdef BUILD_ECORE_CON char *dir = ecore_file_dir_get(dst); if (!ecore_file_is_dir(dir)) { EINA_LOG_ERR("%s is not a directory", dir); free(dir); return EINA_FALSE; } free(dir); if (ecore_file_exists(dst)) { EINA_LOG_ERR("%s already exists", dst); return EINA_FALSE; } if (!strncmp(url, "file://", 7)) { /* FIXME: Maybe fork? Might take a while to copy. * Check filesize? */ /* Just copy it */ url += 7; /* skip hostname */ url = strchr(url, '/'); return ecore_file_cp(url, dst); } # ifdef HAVE_CURL else if ((!strncmp(url, "http://", 7)) || (!strncmp(url, "https://", 8)) || (!strncmp(url, "ftp://", 6))) { /* download */ Ecore_File_Download_Job *job; job = _ecore_file_download_curl(url, dst, completion_cb, progress_cb, data); if(job_ret) *job_ret = job; if(job) return EINA_TRUE; else { EINA_LOG_ERR("no job returned\n"); return EINA_FALSE; } return job ? EINA_TRUE : EINA_FALSE; } # else else if ((!strncmp(url, "http://", 7)) || (!strncmp(url, "https://", 8)) || (!strncmp(url, "ftp://", 6))) { (void)completion_cb; (void)progress_cb; (void)data; (void)job_ret; return EINA_FALSE; } # endif else { return EINA_FALSE; } #else completion_cb = NULL; progress_cb = NULL; data = NULL; return EINA_FALSE; #endif /* BUILD_ECORE_CON */ }
static void _make_config(const char *config_file) { Eet_File *ef; FILE *f; int textlen; char *text; /* Create default config path and file */ if (!config_file) { conf_filename = eina_stringshare_add(ems_config_filename_default_get()); if (!ecore_file_is_dir(ems_config_dirname_get())) ecore_file_mkpath(ems_config_dirname_get()); } else if (!ecore_file_exists(config_file)) { conf_filename = eina_stringshare_add(config_file); ecore_file_mkpath(ecore_file_dir_get(config_file)); } else { conf_filename = eina_stringshare_add(config_file); } INF("Config file : %s", conf_filename); if (!ecore_file_is_dir(ems_config_tmp_dirname_get())) ecore_file_mkdir(ems_config_tmp_dirname_get()); ef = eet_open(ems_config_tmp_filename_get(), EET_FILE_MODE_READ_WRITE); if (!ef) ef = eet_open(ems_config_tmp_filename_get(), EET_FILE_MODE_WRITE); f = fopen(conf_filename, "rb"); if (!f) { WRN("Could not open '%s', setup default config.", ems_config_filename_get()); if (ecore_file_exists(ems_config_default_filename_get())) { ecore_file_cp(ems_config_default_filename_get(), ems_config_filename_get()); f = fopen(ems_config_filename_get(), "rb"); if (!f) return; } else return; } fseek(f, 0, SEEK_END); textlen = ftell(f); rewind(f); text = (char *)malloc(textlen); if (!text) { fclose(f); eet_close(ef); return; } if (fread(text, textlen, 1, f) != 1) { free(text); fclose(f); eet_close(ef); return; } fclose(f); if (eet_data_undump(ef, "config", text, textlen, 1)) INF("Updating configuration %s", conf_filename); free(text); eet_close(ef); }
static Eina_Bool volume_idler(void *data) { Scan *s; DIR *dp; struct dirent *de; char buf[4096]; s = data; if (!s->dirstack) { ecore_event_add(VOLUME_SCAN_START, strdup(s->vol), NULL, NULL); snprintf(s->curdir, sizeof(s->curdir), "%s", s->vol); dp = opendir(s->curdir); if (dp) s->dirstack = eina_list_append(s->dirstack, dp); } if (!s->dirstack) { ecore_event_add(VOLUME_SCAN_STOP, strdup(s->vol), NULL, NULL); volume_items_sort(s); s->timer = NULL; return EINA_FALSE; } dp = eina_list_data_get(eina_list_last(s->dirstack)); if (!dp) { ecore_event_add(VOLUME_SCAN_STOP, strdup(s->vol), NULL, NULL); volume_items_sort(s); s->timer = NULL; return EINA_FALSE; } de = readdir(dp); if (de) { if (de->d_name[0] != '.') { char *link; snprintf(buf, sizeof(buf), "%s/%s", s->curdir, de->d_name); link = ecore_file_readlink(buf); if (link) free(link); else { Volume_Item *vi; if (ecore_file_is_dir(buf)) { ecore_event_add(VOLUME_SCAN_GO, strdup(s->vol), NULL, NULL); vi = volume_dir_scan(buf); if (vi) s->items = eina_list_append(s->items, vi); dp = opendir(buf); if (dp) { snprintf(s->curdir, sizeof(s->curdir), "%s", buf); s->dirstack = eina_list_append(s->dirstack, dp); } } else { ecore_event_add(VOLUME_SCAN_GO, strdup(s->vol), NULL, NULL); vi = volume_file_scan(buf); if (vi) { Eina_List *l; int exists; exists = 0; for (l = items; l; l = l->next) { Volume_Item *vi2; vi2 = l->data; if (!strcmp(vi2->rpath, vi->rpath)) { exists = 1; break; } } if (!exists) { for (l = s->items; l; l = l->next) { Volume_Item *vi2; vi2 = l->data; if (!strcmp(vi2->rpath, vi->rpath)) { printf("%s == %s\n", vi2->rpath, vi->rpath); exists = 1; break; } } } if (exists) { if (!strcmp(vi->type, "video")) video_count--; else if (!strcmp(vi->type, "audio")) audio_count--; else if (!strcmp(vi->type, "photo")) photo_count--; ecore_event_add(VOLUME_TYPE_DEL, strdup(vi->path), NULL, NULL); free(vi->path); free(vi->rpath); free(vi->name); if (vi->genre) eina_stringshare_del(vi->genre); free(vi); } else s->items = eina_list_append(s->items, vi); } } } } } else { char *p; closedir(dp); s->dirstack = eina_list_remove(s->dirstack, dp); p = strrchr(s->curdir, '/'); if (p) *p = 0; } if (!s->dirstack) { ecore_event_add(VOLUME_SCAN_STOP, strdup(s->vol), NULL, NULL); volume_items_sort(s); s->timer = NULL; return EINA_FALSE; } s->timer = ecore_timer_add(SCANSPEED, volume_idler, s); return EINA_FALSE; }
Elicit * elicit_new() { Elicit *el; char buf[PATH_MAX]; char *dir; el = calloc(sizeof(Elicit), 1); el->ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 500, 500); if (!el->ee) { fprintf(stderr, "[Elicit] Error creating new ecore evas\n"); free(el); return NULL; } el->evas = ecore_evas_get(el->ee); ecore_evas_title_set(el->ee, "Elicit"); ecore_evas_name_class_set(el->ee, "Elicit", "Elicit"); ecore_evas_borderless_set(el->ee, 1); // XXX get correct screen number if (ecore_x_screen_is_composited(0)) ecore_evas_alpha_set(el->ee, 1); else ecore_evas_shaped_set(el->ee, 1); ecore_evas_data_set(el->ee, "Elicit", el); ecore_evas_callback_resize_set(el->ee, cb_ee_resize); ecore_evas_callback_mouse_in_set(el->ee, cb_ee_mouse_in); ecore_evas_callback_mouse_out_set(el->ee, cb_ee_mouse_out); ecore_event_handler_add(ECORE_X_EVENT_WINDOW_CONFIGURE, cb_x_configure, el); el->obj.main = edje_object_add(el->evas); /* setup paths */ dir = br_find_data_dir(DATADIR); snprintf(buf, sizeof(buf), "%s/%s/", dir, PACKAGE); if (!ecore_file_exists(buf)) { fprintf(stderr, "[Elicit] Warning: falling back to hardcoded data dir.\n"); snprintf(buf, sizeof(buf), "%s/%s/", DATADIR, PACKAGE); } el->path.datadir = strdup(buf); free(dir); if (getenv("HOME")) { snprintf(buf, sizeof(buf), "%s/.e/apps/elicit/", getenv("HOME")); if (!ecore_file_is_dir(buf)) ecore_file_mkpath(buf); el->path.confdir = strdup(buf); snprintf(buf, sizeof(buf), "%s/.e/apps/elicit/elicit.conf", getenv("HOME")); el->path.conffile = strdup(buf); snprintf(buf, sizeof(buf), "%s/.e/apps/elicit/elicit.gpl", getenv("HOME")); el->path.palette = strdup(buf); } /* color */ el->color = color_new(); color_callback_changed_add(el->color, cb_color_changed, el); /* palette */ el->palette = palette_new(); palette_load(el->palette, el->path.palette); return el; }
int ex_config_init() { char *home; char buf[PATH_MAX]; home = getenv("HOME"); if(!home) { ERROR(_("Cant find home directory!")); return 0; } /* make sure ~/.e exists and is a dir */ snprintf(buf, sizeof(buf), "%s/.e", home); if(!ecore_file_is_dir(buf)) { if(ecore_file_exists(buf)) { ERROR(_("Cant create config path!")); return 0; } if(!ecore_file_mkdir(buf)) { ERROR(_("Cant create config path!")); return 0; } } /* make sure ~/.e/extrackt exists and is a dir */ snprintf(buf, sizeof(buf), "%s/.e/extrackt", home); if(!ecore_file_is_dir(buf)) { if(ecore_file_exists(buf)) { ERROR(_("Cant create config path!")); return 0; } if(!ecore_file_mkdir(buf)) { ERROR(_("Cant create config path!")); return 0; } } _ex_config_version_edd = NEWD("Ex_Config_Version", Ex_Config_Version); VER_NEWI("mj", major, EET_T_INT); VER_NEWI("mn", minor, EET_T_INT); VER_NEWI("pa", patch, EET_T_INT); _ex_config_cd_edd = NEWD("Ex_Config_Cd", Ex_Config_Cd); CD_NEWI("cd", cdrom, EET_T_STRING); CD_NEWI("rs", interrupt_playback, EET_T_INT); CD_NEWI("rw", rewind_stopped, EET_T_INT); CD_NEWI("sf", startup_first_track, EET_T_INT); CD_NEWI("ai", autoplay_insert, EET_T_INT); CD_NEWI("rp", reshuffle_playback, EET_T_INT); CD_NEWI("wf", workaround_eject, EET_T_INT); CD_NEWI("pd", poll_drive, EET_T_INT); CD_NEWI("pi", poll_interval, EET_T_INT); _ex_config_cddb_server_edd = NEWD("Ex_Config_Cddb_Server", Ex_Config_Cddb_Server); CDDBS_NEWI("nm", name ,EET_T_STRING); CDDBS_NEWI("cg", cgi_prog, EET_T_STRING); CDDBS_NEWI("pt", port, EET_T_INT); CDDBS_NEWI("up", use_proxy, EET_T_INT); _ex_config_cddb_edd = NEWD("Ex_Config_Cddb", Ex_Config_Cddb); CDDB_NEWI("al", automatic_lookup, EET_T_INT); CDDB_NEWS("pr", primary, _ex_config_cddb_server_edd); CDDB_NEWS("sc", secondary, _ex_config_cddb_server_edd); _ex_config_exe_edd = NEWD("Ex_Config_Exe", Ex_Config_Exe); EXE_NEWI("nm", name, EET_T_STRING); EXE_NEWI("ex", exe, EET_T_STRING); EXE_NEWI("cl", command_line_opts, EET_T_STRING); EXE_NEWI("ff", file_format, EET_T_STRING); EXE_NEWI("df", def, EET_T_INT); EXE_NEWI("ty", type, EET_T_INT); _ex_config_encode_edd = NEWD("Ex_Config_Encode", Ex_Config_Cddb); ENC_NEWL("es", encoders, _ex_config_exe_edd); ENC_NEWI("wd", wav_delete, EET_T_INT); return 1; }
/** * @brief Create complete list of sub-directories in a batch (optimized). * * @param base The base directory to act on. * @param subdirs The list of directories, null terminated. * @return number of successful directories created, -1 on failure. * * This function creates all the directories that are in the null * terminated array @p dirs in the @p base directory. If @p base does * not exist, it will be created. The function loops over the directories * and call ecore_file_mkdir(). The whole path of the directories must * exist. So if base/a/b/c wants to be created, @p subdirs must * contain "a", "a/b" and "a/b/c", in that order. This function * returns -1 if @p dirs or @p base are @c NULL, or if @p base is * empty ("\0"). It returns 0 is @p base is not a directory or * invalid, or if it can't be created. Otherwise if returns the number * of suceesfully created directories. */ EAPI int ecore_file_mksubdirs(const char *base, const char **subdirs) { #ifndef HAVE_ATFILE_SOURCE char buf[PATH_MAX]; int baselen; #else int fd; DIR *dir; #endif int i; if (!subdirs) return -1; if ((!base) || (base[0] == '\0')) return -1; if ((!ecore_file_is_dir(base)) && (!ecore_file_mkpath(base))) return 0; #ifndef HAVE_ATFILE_SOURCE baselen = eina_strlcpy(buf, base, sizeof(buf)); if ((baselen < 1) || (baselen + 1 >= (int)sizeof(buf))) return 0; if (buf[baselen - 1] != '/') { buf[baselen] = '/'; baselen++; } #else dir = opendir(base); if (!dir) return 0; fd = dirfd(dir); #endif i = 0; for (; *subdirs; subdirs++) { struct stat st; #ifndef HAVE_ATFILE_SOURCE eina_strlcpy(buf + baselen, *subdirs, sizeof(buf) - baselen); if (stat(buf, &st) == 0) #else if (fstatat(fd, *subdirs, &st, 0) == 0) #endif { if (S_ISDIR(st.st_mode)) { i++; continue; } } else { if (errno == ENOENT) { #ifndef HAVE_ATFILE_SOURCE if (mkdir(buf, default_mode) == 0) #else if (mkdirat(fd, *subdirs, default_mode) == 0) #endif { i++; continue; } } } } #ifdef HAVE_ATFILE_SOURCE closedir(dir); #endif return i; }
void ModuleManager::SearchModules() { for (uint i = 0; i < search_paths.size(); i++) { cInfoDom("module") << "ModuleManager: searching modules in: " << search_paths[i]; char *fname = NULL; void *data = NULL; Eina_List *subdir = ecore_file_ls(search_paths[i].c_str()); Eina_List *l = NULL; EINA_LIST_FOREACH(subdir, l, data) { fname = (char *)data; string p; p = search_paths[i]; if (fname) { p += "/"; p += fname; } if (p[p.length() - 1] != '/') p += "/"; if (!ecore_file_is_dir(p.c_str())) continue; p += "module.so"; if (!ecore_file_exists(p.c_str())) continue; bool alreadyin = false; for (uint im = 0; im < modules.size() && !alreadyin; im++) { ModuleDef mdef = modules[im]; if (p == mdef.mod_fname) alreadyin = true; } if (alreadyin) continue; //try to load the module void *handle = dlopen(p.c_str(), RTLD_LAZY); if (handle) { //object can be loaded, check version and CalaosModuleApi *api = (CalaosModuleApi *)dlsym(handle, "calaos_modapi"); if (!api) { dlclose(handle); cErrorDom("module") << "ModuleManager: module " << p << ". calaos_modapi export not found: " << dlerror(); continue; } if (api->api_version != CALAOS_MODULE_API_VERSION) { dlclose(handle); cErrorDom("module") << "ModuleManager: module " << p << ". The API version doesn't match"; continue; } string module_name; vector<string> tok; Utils::split(p, tok, "/"); if (tok.size() > 2) module_name = tok[tok.size() - 2]; string themepath = Prefix::Instance().dataDirectoryGet(); themepath += "/widgets/" + module_name; ModuleDef mdef; mdef.mod_name = gettext(api->name); mdef.mod_desc = gettext(api->desc); mdef.mod_version = api->version; mdef.mod_author = api->author; mdef.mod_icon = themepath + "/icon.edj"; mdef.mod_fname = p; mdef.handle = handle; mdef.inst = NULL; mdef.api = api; cInfoDom("module") << "ModuleManager: found module: " << mdef.mod_name; modules.push_back(mdef); } else { cWarningDom("module") << "ModuleManager: file " << p << " : failed to dlopen: " << dlerror(); } } EINA_LIST_FREE(subdir, data) free(data); }