static int lwsws_get_config_d(void *user, const char *d, const char * const *paths, int count_paths, lejp_callback cb) { uv_dirent_t dent; uv_fs_t req; char path[256]; int ret = 0; uv_loop_t loop; uv_loop_init(&loop); if (!uv_fs_scandir(&loop, &req, d, 0, NULL)) { lwsl_err("Scandir on %s failed\n", d); return 2; } while (uv_fs_scandir_next(&req, &dent) != UV_EOF) { snprintf(path, sizeof(path) - 1, "%s/%s", d, dent.name); ret = lwsws_get_config(user, path, paths, count_paths, cb); if (ret) goto bail; } bail: uv_fs_req_cleanup(&req); uv_loop_close(&loop); return ret; }
void remove_realm_files_from_directory(const std::string &dir_path) { FileSystemRequest scandir_req; if (uv_fs_scandir(uv_default_loop(), &scandir_req, dir_path.c_str(), 0, nullptr) < 0) { throw UVException(static_cast<uv_errno_t>(scandir_req.result)); } uv_dirent_t entry; while (uv_fs_scandir_next(&scandir_req, &entry) != UV_EOF) { std::string path(dir_path + '/' + entry.name); if (entry.type == UV_DIRENT_DIR) { static std::string realm_management_extension(".realm.management"); if (ends_with(path, realm_management_extension)) { uv_dirent_t management_entry; FileSystemRequest management_scandir_req; if (uv_fs_scandir(uv_default_loop(), &management_scandir_req, path.c_str(), 0, nullptr) < 0) { throw UVException(static_cast<uv_errno_t>(scandir_req.result)); } while (uv_fs_scandir_next(&management_scandir_req, &management_entry) != UV_EOF) { std::string management_entry_path = path + '/' + management_entry.name; FileSystemRequest delete_req; if (uv_fs_unlink(uv_default_loop(), &delete_req, management_entry_path.c_str(), nullptr) != 0) { throw UVException(static_cast<uv_errno_t>(delete_req.result)); } } FileSystemRequest management_rmdir_req; if (uv_fs_rmdir(uv_default_loop(), &management_rmdir_req, path.c_str(), nullptr)) { throw UVException(static_cast<uv_errno_t>(management_rmdir_req.result)); } } } else { static std::string realm_extension(".realm"); static std::string realm_note_extension(".realm.note"); static std::string realm_lock_extension(".realm.lock"); if (ends_with(path, realm_extension) || ends_with(path, realm_note_extension) || ends_with(path, realm_lock_extension)) { FileSystemRequest delete_req; if (uv_fs_unlink(uv_default_loop(), &delete_req, path.c_str(), nullptr) != 0) { throw UVException(static_cast<uv_errno_t>(delete_req.result)); } } } } }
void directoryList(WrenVM* vm) { const char* path = wrenGetSlotString(vm, 1); uv_fs_t* request = createRequest(wrenGetSlotValue(vm, 2)); // TODO: Check return. uv_fs_scandir(getLoop(), request, path, 0, directoryListCallback); }
void module_load_all_modules() { size_t len; uv_fs_t *req; len = vector_length(ModulePaths); for(size_t i = 0; i < len; i++) { const char **path = vector_get(ModulePaths, i); req = Malloc(sizeof(uv_fs_t)); uv_fs_scandir(serverstate_get_event_loop(), req, *path, 0, module_on_scandir); } }
LWS_VISIBLE int lws_plat_plugins_init(struct lws_context * context, const char * const *d) { struct lws_plugin_capability lcaps; struct lws_plugin *plugin; lws_plugin_init_func initfunc; int m, ret = 0; void *v; uv_dirent_t dent; uv_fs_t req; char path[256]; uv_loop_t loop; uv_lib_t lib; lib.errmsg = NULL; lib.handle = NULL; uv_loop_init(&loop); lwsl_notice(" Plugins:\n"); while (d && *d) { lwsl_notice(" Scanning %s\n", *d); m =uv_fs_scandir(&loop, &req, *d, 0, NULL); if (m < 1) { lwsl_err("Scandir on %s failed\n", *d); return 1; } while (uv_fs_scandir_next(&req, &dent) != UV_EOF) { if (strlen(dent.name) < 7) continue; lwsl_notice(" %s\n", dent.name); lws_snprintf(path, sizeof(path) - 1, "%s/%s", *d, dent.name); if (uv_dlopen(path, &lib)) { uv_dlerror(&lib); lwsl_err("Error loading DSO: %s\n", lib.errmsg); goto bail; } /* we could open it, can we get his init function? */ #if !defined(WIN32) m = lws_snprintf(path, sizeof(path) - 1, "init_%s", dent.name + 3 /* snip lib... */); path[m - 3] = '\0'; /* snip the .so */ #else m = lws_snprintf(path, sizeof(path) - 1, "init_%s", dent.name); path[m - 4] = '\0'; /* snip the .dll */ #endif if (uv_dlsym(&lib, path, &v)) { uv_dlerror(&lib); lwsl_err("Failed to get init on %s: %s", dent.name, lib.errmsg); goto bail; } initfunc = (lws_plugin_init_func)v; lcaps.api_magic = LWS_PLUGIN_API_MAGIC; m = initfunc(context, &lcaps); if (m) { lwsl_err("Initializing %s failed %d\n", dent.name, m); goto skip; } plugin = lws_malloc(sizeof(*plugin)); if (!plugin) { lwsl_err("OOM\n"); goto bail; } plugin->list = context->plugin_list; context->plugin_list = plugin; strncpy(plugin->name, dent.name, sizeof(plugin->name) - 1); plugin->name[sizeof(plugin->name) - 1] = '\0'; plugin->lib = lib; plugin->caps = lcaps; context->plugin_protocol_count += lcaps.count_protocols; context->plugin_extension_count += lcaps.count_extensions; continue; skip: uv_dlclose(&lib); } bail: uv_fs_req_cleanup(&req); d++; } uv_loop_close(&loop); return ret; }
static int scan_dir(struct lws *wsi, struct per_session_data__tbl_dir *pss) { /* uuh travis... */ #if UV_VERSION_MAJOR > 0 uv_loop_t *loop = lws_uv_getloop(lws_get_context(wsi), 0); char *end = &(pss->strings[sizeof(pss->strings) - 1]); struct fobj *prev = &pss->base; char path[512], da[200]; const char *icon; uv_dirent_t dent; struct fobj *f; struct stat st; struct tm *tm; int ret = 0, n; uv_fs_t req; lws_protocol_dir_kill_monitor(pss); lws_snprintf(path, sizeof(path) - 1, "%s/%s", pss->dir, pss->reldir); //lwsl_notice("path = %s\n", path); pss->event_req = malloc(sizeof(*pss->event_req)); if (!pss->event_req) return 2; pss->wsi = wsi; pss->event_req->data = pss; uv_fs_event_init(lws_uv_getloop(lws_get_context(wsi), 0), pss->event_req); // The recursive flag watches subdirectories too. n = uv_fs_event_start(pss->event_req, mon_cb, path, UV_FS_EVENT_RECURSIVE); //lwsl_notice("monitoring %s (%d)\n", path, n); if (!uv_fs_scandir(loop, &req, path, 0, NULL)) { lwsl_err("Scandir on %s failed\n", path); return 2; } pss->p = pss->strings; while (uv_fs_scandir_next(&req, &dent) != UV_EOF) { lws_snprintf(path, sizeof(path) - 1, "%s/%s/%s", pss->dir, pss->reldir, dent.name); if (stat(path, &st)) { lwsl_info("unable to stat %s\n", path); continue; } f = malloc(sizeof(*f)); f->next = NULL; f->name = pss->p; n = lws_snprintf(pss->p, end - pss->p, "%s", dent.name); pss->p += n + 1; f->uri = NULL; if ((S_IFMT & st.st_mode) == S_IFDIR) { n = lws_snprintf(pss->p, end - pss->p, "=%s/%s", pss->reldir, dent.name); f->uri = pss->p; } if (lws_get_mimetype(dent.name, NULL)) { n = lws_snprintf(pss->p, end - pss->p, "./serve/%s/%s", pss->reldir, dent.name); f->uri = pss->p; } if (f->uri) pss->p += n + 1; if (end - pss->p < 100) { free(f); break; } icon = " "; if ((S_IFMT & st.st_mode) == S_IFDIR) icon = "📂"; f->icon = pss->p; n = lws_snprintf(pss->p, end - pss->p, "%s", icon); pss->p += n + 1; f->date = pss->p; tm = gmtime(&st.st_mtime); strftime(da, sizeof(da), "%Y-%b-%d %H:%M:%S %z", tm); n = lws_snprintf(pss->p, end - pss->p, "%s", da); pss->p += n + 1; f->size = st.st_size; f->m = st.st_mtime; prev->next = f; prev = f; } uv_fs_req_cleanup(&req); return ret; #else return 0; #endif }
bool hcp::Runtime::scanDir(const char* codecPath,const char** error) { uv_fs_t req; int numFiles = uv_fs_scandir(uv_default_loop(), &req, codecPath, UV_FS_SCANDIR, nullptr); if (numFiles < 0) { if (error) { *error = uv_strerror(numFiles); } return false; } for (int i = 0; i < numFiles; i++) { uv_dirent_t ent; hcp::tCodec codec; int r = uv_fs_scandir_next(&req, &ent); if (r == UV_EOF) { break; } hcp_Boolean found = HCP_FALSE; // skip codecs with duplicate name hcp_FindFirst(&_codecs.header, 0, (void*)ent.name, &found); if (found == HCP_TRUE) { continue; } if (hcp::Runtime::hasExtension(ent.name, ".DLL") || hcp::Runtime::hasExtension(ent.name, ".SO") || hcp::Runtime::hasExtension(ent.name, ".DYLIB")) { hcp_Size_t pathLen = hcp_szStrLen((hcp_szStr)codecPath); hcp_Size_t nameLen = hcp_szStrLen((hcp_szStr)ent.name); codec.path = (char*)hcp_Malloc(_state, pathLen + nameLen + 2); hcp_Memcpy(_state, codec.path, codecPath, pathLen); hcp_Memcpy(_state, codec.path + pathLen, "/", 1); hcp_Memcpy(_state, codec.path + pathLen + 1, ent.name, nameLen + 1); if (loadLibrary(codec.path, &codec, error)) { hcp_Size_t index; auto code = hcp_Push(&_codecs.header, &codec, &index); if (code != HCP_NOERROR) { // TODO: Logg load errors hcp_Free(_state, codec.path); } } else { // TODO: Logg load errors hcp_Free(_state, codec.path); } } else { continue; } } return true; }