bool CFSModule::Create_Directory( const std::string& Dir ) { // Enforce leading / if( Dir.empty() || (Dir.substr(0,1) != "/") || (Dir.substr(Dir.length() - 1) == "/") ) { return NULL; } string Node; string BaseDir; // Split path into Node and Basedir Split_Full_Path( Dir, BaseDir, Node ); CFSNode* pNode = Get_Node( BaseDir ); if( pNode->Get_Node_Type() != NODE_DIR ) { return NULL; } CDirectory* pBaseDir = (CDirectory*)pNode; // Create the directory if( pBaseDir->Create_Directory( Node ) ) { return true; } else { return false; } }
bool CFSModule::Create_File( const std::string& Name ) { // Enforce leading / if( Name.empty() || (Name.substr(0,1) != "/") || (Name.substr(Name.length() - 1) == "/") ) { return NULL; } string Node; string BaseDir; // Split path into Node and Basedir Split_Full_Path( Name, BaseDir, Node ); CDirectory* pDir = (CDirectory*)Get_Node( BaseDir ); if( !pDir ) { return NULL; } if( pDir->Get_Node_Type() != NODE_DIR ) { return NULL; } if( pDir->Create_File( Node ) ) { return true; } else { return false; } }
bool CDirectory::dir2fdd(char *sourceDirectory, char *fddImageName) { Debug::out(LOG_INFO, "CDirectory::dir2fdd() -- will try to create %s from %s", fddImageName, sourceDirectory); CDirectory *pDir = new CDirectory(); pDir->DirectoryScan(sourceDirectory); if(!pDir) { Debug::out(LOG_ERROR, "CreateTreeFromDirectory failed..."); return false; } CFloppy floppy; floppy.Create(NB_HEAD,NB_SECTOR_PER_TRACK,NB_CYLINDER); bool bOk = floppy.Fill( pDir, (char *) "CONF_FDD" ); if (bOk) { Debug::out(LOG_INFO, "CDirectory::dir2fdd() -- Writing file %s", fddImageName); floppy.WriteImage(fddImageName); } delete pDir; return bOk; }
bool CLanguage::Load ( const CString& szLangName ) { CString szPath ( "../lang/%s/", szLangName.c_str () ); CDirectory dir ( szPath ); if ( !dir.IsOk ( ) ) return false; for ( CDirectory::CIterator iter = dir.Begin (); iter != dir.End (); ++iter ) { CString szCur = iter.GetName (); size_t iExt = szCur.rfind ( '.' ); if ( iExt != CString::npos ) { if ( szCur.substr ( iExt ) == ".txt" ) { LoadFile ( szLangName, szCur.substr ( 0, iExt ) ); } } } m_bIsOk = true; return true; }
void CSingleIndexBarrelReader::open(const tchar* name) { m_name = name; CDirectory* pDirectory = m_pIndex->getDirectory(); tstring s = m_name + _T(".fdi"); CIndexInput* pIndexInput = pDirectory->openInput(s.c_str()); m_pFieldsInfo->read(pIndexInput); pIndexInput->close(); delete pIndexInput; m_pStoredFieldsReader->open(pDirectory,name,m_pFieldsInfo); m_pNormsReader->open(name,m_pFieldsInfo); if(pDirectory->fileExists(m_name + _T(".del"))) { CIndexInput* pDelInput = pDirectory->openInput(m_name + _T(".del")); m_pDeletedDocs = new CBitVector(pDelInput); delete pDelInput; } else m_pDeletedDocs = new CBitVector(); if(m_pTermReader) { delete m_pTermReader; m_pTermReader = NULL; } if(m_pFieldsInfo->numIndexFields() > 1) { m_pTermReader = new CMultiFieldTermReader(pDirectory,name,m_pFieldsInfo,m_pDeletedDocs,getFactoryFinder()); m_pTermReader->setFilter(m_pDeletedDocs); } else if(m_pFieldsInfo->numIndexFields() == 1) { m_pFieldsInfo->startIterator(); CFieldInfo* pFieldInfo; while (m_pFieldsInfo->hasNext()) { pFieldInfo = m_pFieldsInfo->next(); if(pFieldInfo->isIndexed()) { m_pTermReader = getFactoryFinder()->getFactory(pFieldInfo->getID())->createTermReader(); m_pTermReader->setFilter(m_pDeletedDocs); m_pTermReader->open(pDirectory,name,pFieldInfo,m_pDeletedDocs); break; } } } else { FIRTEX_THROW2(INDEX_COLLAPSE_ERROR,_T("the field number is 0.")); } }
IDirectory *LibrarySystem::OpenDirectory(const char *path) { CDirectory *dir = new CDirectory(path); if (!dir->IsValid()) { delete dir; return NULL; } return dir; }
// native open_dir(dir[], firstfile[], length, &FileType:type = FileType_Unknown, bool:use_valve_fs=false, const valve_path_id[] = "GAME"); static cell AMX_NATIVE_CALL amx_open_dir(AMX *amx, cell *params) { int length; const char* path = get_amxstring(amx, params[1], 0, length); if (!*path) { return 0; } size_t numParams = *params / sizeof(cell); if (numParams >= 4 && params[5] > 0) { const char* wildcardedPath = g_LibSys.PathFormat("%s%s*", path, (path[length - 1] != '/' && path[length - 1] != '\\') ? "/" : ""); const char* pathID = get_amxstring_null(amx, params[6], 1, length); static FileFindHandle_t handle; const char* pFirst = g_FileSystem->FindFirst(wildcardedPath, &handle, pathID); if (!pFirst) { return 0; } set_amxstring_utf8(amx, params[2], pFirst, strlen(pFirst), params[3] + 1); cell* fileType = get_amxaddr(amx, params[4]); *fileType = g_FileSystem->FindIsDirectory(handle) ? FileType_Directory : FileType_File; return reinterpret_cast<cell>(new DirectoryHandle(reinterpret_cast<void*>(&handle), true)); } CDirectory* dir = g_LibSys.OpenDirectory(build_pathname("%s", path)); if (!dir) { return 0; } if (numParams >= 4) { cell* fileType = get_amxaddr(amx, params[4]); *fileType = dir->IsEntryDirectory() ? FileType_Directory : FileType_File; } const char* entry = dir->GetEntryName(); set_amxstring_utf8(amx, params[2], entry, strlen(entry), params[3] + 1); return reinterpret_cast<cell>(new DirectoryHandle(reinterpret_cast<void*>(dir), false)); }
bool vip_Start::Process() { GFRLOG_TRACE("VIP starts to process"); CDirectory dir; list<string> filelist = dir.get_file_list(m_str_src); list<string>::iterator it; for (it = filelist.begin(); it != filelist.end(); ++it) { cout<< "Processing [" << *it << "]" <<endl; this->load_file(*it); } return true; }
CDirectory* CDirectoryQueue::Pop() { bool force_wait = false; CDirectory* tmp; CDirectory* tmpPrev; EnterCriticalSection(&_cs); tmpPrev = NULL; tmp = _head; while (tmp != NULL) { if (tmp->TryLock()) { if (tmp == _head) _head = _head->_next; if (tmpPrev != NULL) tmpPrev->_next = tmp->_next; // unlink it if (tmp == _tail) _tail = tmpPrev; --_length; break; } Warning("Skipping locked directory %s (will return to it)", tmp->GetDirectoryName()); tmpPrev = tmp; tmp = tmp->_next; } if (tmp == NULL && _head != NULL) { // There's at least one directory, but they're all in use by another // copy of rl. Just grab the first one and wait on it. tmp = _head; _head = _head->_next; if (tmp == _tail) _tail = NULL; --_length; // wait until it's no longer in use..... However, don't wait inside the // critical section. force_wait = true; } ReleaseSemaphore(_hMaxWorkQueueSem, 1, NULL); LeaveCriticalSection(&_cs); if (tmp != NULL) // might be empty diff queue before masters are run tmp->_next = NULL; if (force_wait) tmp->WaitLock(); return tmp; }
void CDirectory::DirectoryScan(const char *pDir) { char tmpName[_MAX_PATH]; strcpy(tmpName,pDir); strcat(tmpName,"\\*.*"); DIR *dir = opendir((char *) pDir); // try to open the dir if(dir == NULL) { // not found? return; } while(1) { // while there are more files, store them struct dirent *de = readdir(dir); // read the next directory entry if(de == NULL) { // no more entries? break; } if(de->d_type != DT_DIR && de->d_type != DT_REG) { // not a file, not a directory? continue; } sprintf(tmpName,"%s/%s", pDir, de->d_name); if(de->d_type == DT_DIR) { // for dir if(de->d_name[0] == '.') { // skip . and .. continue; } CDirectory *pNewDir = new CDirectory(); this->AddEntry(de, pNewDir, tmpName); pNewDir->DirectoryScan(tmpName); } else { this->AddEntry(de, NULL, tmpName); } } closedir(dir); }
bool CFileOperations::FillFileItemList(const CVariant ¶meterObject, CFileItemList &list) { if (parameterObject.isMember("directory")) { CStdString media = parameterObject["media"].asString(); media = media.ToLower(); CStdString strPath = parameterObject["directory"].asString(); if (!strPath.empty()) { CFileItemList items; CStdString extensions = ""; CStdStringArray regexps; if (media.Equals("video")) { regexps = g_advancedSettings.m_videoExcludeFromListingRegExps; extensions = g_settings.m_videoExtensions; } else if (media.Equals("music")) { regexps = g_advancedSettings.m_audioExcludeFromListingRegExps; extensions = g_settings.m_musicExtensions; } else if (media.Equals("pictures")) { regexps = g_advancedSettings.m_pictureExcludeFromListingRegExps; extensions = g_settings.m_pictureExtensions; } CDirectory directory; if (directory.GetDirectory(strPath, items, extensions)) { items.Sort(SORT_METHOD_FILE, SortOrderAscending); CFileItemList filteredDirectories; for (unsigned int i = 0; i < (unsigned int)items.Size(); i++) { if (CUtil::ExcludeFileOrFolder(items[i]->GetPath(), regexps)) continue; if (items[i]->m_bIsFolder) filteredDirectories.Add(items[i]); else if ((media == "video" && items[i]->HasVideoInfoTag()) || (media == "music" && items[i]->HasMusicInfoTag())) list.Add(items[i]); else { CFileItem fileItem; if (FillFileItem(items[i], fileItem, media)) list.Add(CFileItemPtr(new CFileItem(fileItem))); else if (media == "files") list.Add(items[i]); } } if (parameterObject.isMember("recursive") && parameterObject["recursive"].isBoolean()) { for (int i = 0; i < filteredDirectories.Size(); i++) { CVariant val = parameterObject; val["directory"] = filteredDirectories[i]->GetPath(); FillFileItemList(val, list); } } return true; } } } return false; }
// native next_file(dirh, buffer[], length, &FileType:type = FileType_Unknown); static cell AMX_NATIVE_CALL amx_get_dir(AMX *amx, cell *params) { DirectoryHandle* p = reinterpret_cast<DirectoryHandle*>(params[1]); if (!p) { return 0; } size_t numParams = *params / sizeof(cell); if (p->valvefs) { FileFindHandle_t* handle = reinterpret_cast<FileFindHandle_t*>(p->handle); if (!handle) { return 0; } const char* entry = g_FileSystem->FindNext(*handle); if (!entry) { return 0; } if (numParams >= 4) { cell* fileType = get_amxaddr(amx, params[4]); *fileType = g_FileSystem->FindIsDirectory(*handle) ? FileType_Directory : FileType_File; } set_amxstring_utf8(amx, params[2], entry, strlen(entry), params[3] + 1); } else { CDirectory* handle = reinterpret_cast<CDirectory*>(p->handle); if (!handle) { return 0; } handle->NextEntry(); if (!handle->MoreFiles()) { return 0; } if (numParams >= 4) { cell* fileType = get_amxaddr(amx, params[4]); *fileType = handle->IsEntryDirectory() ? FileType_Directory : FileType_File; } const char* entry = handle->GetEntryName(); set_amxstring_utf8(amx, params[2], entry, strlen(entry), params[3] + 1); } return 1; }
void CGUIWindowPrograms::PopulateTrainersList() { CDirectory directory; CFileItemList trainers; CFileItemList archives; CFileItemList inArchives; // first, remove any dead items std::vector<CStdString> vecTrainerPath; m_database.GetAllTrainers(vecTrainerPath); CGUIDialogProgress* m_dlgProgress = (CGUIDialogProgress*)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS); m_dlgProgress->SetLine(0,12023); m_dlgProgress->SetLine(1,""); m_dlgProgress->SetLine(2,""); m_dlgProgress->StartModal(); m_dlgProgress->SetHeading(12012); m_dlgProgress->ShowProgressBar(true); m_dlgProgress->Progress(); bool bBreak=false; bool bDatabaseState = m_database.IsOpen(); if (!bDatabaseState) m_database.Open(); m_database.BeginTransaction(); for (unsigned int i=0;i<vecTrainerPath.size();++i) { m_dlgProgress->SetPercentage((int)((float)i/(float)vecTrainerPath.size()*100.f)); CStdString strLine; strLine.Format("%s %i / %i",g_localizeStrings.Get(12013).c_str(), i+1,vecTrainerPath.size()); m_dlgProgress->SetLine(1,strLine); m_dlgProgress->Progress(); if (!CFile::Exists(vecTrainerPath[i]) || vecTrainerPath[i].find(g_guiSettings.GetString("myprograms.trainerpath",false)) == -1) m_database.RemoveTrainer(vecTrainerPath[i]); if (m_dlgProgress->IsCanceled()) { bBreak = true; m_database.RollbackTransaction(); break; } } if (!bBreak) { CLog::Log(LOGDEBUG,"trainerpath %s",g_guiSettings.GetString("myprograms.trainerpath",false).c_str()); directory.GetDirectory(g_guiSettings.GetString("myprograms.trainerpath").c_str(),trainers,".xbtf|.etm"); if (g_guiSettings.GetString("myprograms.trainerpath",false).IsEmpty()) { m_database.RollbackTransaction(); m_dlgProgress->Close(); return; } directory.GetDirectory(g_guiSettings.GetString("myprograms.trainerpath").c_str(),archives,".rar|.zip",false); // TODO: ZIP SUPPORT for( int i=0;i<archives.Size();++i) { if (stricmp(URIUtils::GetExtension(archives[i]->GetPath()),".rar") == 0) { g_RarManager.GetFilesInRar(inArchives,archives[i]->GetPath(),false); CHDDirectory dir; dir.SetMask(".xbtf|.etm"); for (int j=0;j<inArchives.Size();++j) if (dir.IsAllowed(inArchives[j]->GetPath())) { CFileItemPtr item(new CFileItem(*inArchives[j])); CStdString strPathInArchive = item->GetPath(); CStdString path; URIUtils::CreateArchivePath(path, "rar", archives[i]->GetPath(), strPathInArchive,""); item->SetPath(path); trainers.Add(item); } } if (stricmp(URIUtils::GetExtension(archives[i]->GetPath()),".zip")==0) { // add trainers in zip CStdString strZipPath; URIUtils::CreateArchivePath(strZipPath,"zip",archives[i]->GetPath(),""); CFileItemList zipTrainers; directory.GetDirectory(strZipPath,zipTrainers,".etm|.xbtf"); for (int j=0;j<zipTrainers.Size();++j) { CFileItemPtr item(new CFileItem(*zipTrainers[j])); trainers.Add(item); } } } if (!m_dlgProgress) m_dlgProgress = (CGUIDialogProgress*)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS); m_dlgProgress->SetPercentage(0); m_dlgProgress->ShowProgressBar(true); CLog::Log(LOGDEBUG,"# trainers %i",trainers.Size()); m_dlgProgress->SetLine(1,""); int j=0; while (j < trainers.Size()) { if (trainers[j]->m_bIsFolder) trainers.Remove(j); else j++; } for (int i=0;i<trainers.Size();++i) { CLog::Log(LOGDEBUG,"found trainer %s",trainers[i]->GetPath().c_str()); m_dlgProgress->SetPercentage((int)((float)(i)/trainers.Size()*100.f)); CStdString strLine; strLine.Format("%s %i / %i",g_localizeStrings.Get(12013).c_str(), i+1,trainers.Size()); m_dlgProgress->SetLine(0,strLine); m_dlgProgress->SetLine(2,""); m_dlgProgress->Progress(); if (m_database.HasTrainer(trainers[i]->GetPath())) // skip existing trainers continue; CTrainer trainer; if (trainer.Load(trainers[i]->GetPath())) { m_dlgProgress->SetLine(1,trainer.GetName()); m_dlgProgress->SetLine(2,""); m_dlgProgress->Progress(); unsigned int iTitle1, iTitle2, iTitle3; trainer.GetTitleIds(iTitle1,iTitle2,iTitle3); if (iTitle1) m_database.AddTrainer(iTitle1,trainers[i]->GetPath()); if (iTitle2) m_database.AddTrainer(iTitle2,trainers[i]->GetPath()); if (iTitle3) m_database.AddTrainer(iTitle3,trainers[i]->GetPath()); } if (m_dlgProgress->IsCanceled()) { m_database.RollbackTransaction(); break; } } } m_database.CommitTransaction(); m_dlgProgress->Close(); if (!bDatabaseState) m_database.Close(); else Update(m_vecItems->GetPath()); }
JSON_STATUS CFileOperations::GetDirectory(const CStdString &method, ITransportLayer *transport, IClient *client, const Value ¶meterObject, Value &result) { CStdString media = parameterObject["media"].asString(); media = media.ToLower(); CDirectory directory; CFileItemList items; CStdString strPath = parameterObject["directory"].asString(); CStdStringArray regexps; CStdString extensions = ""; if (media.Equals("video")) { regexps = g_advancedSettings.m_videoExcludeFromListingRegExps; extensions = g_stSettings.m_videoExtensions; } else if (media.Equals("music")) { regexps = g_advancedSettings.m_audioExcludeFromListingRegExps; extensions = g_stSettings.m_musicExtensions; } else if (media.Equals("pictures")) { regexps = g_advancedSettings.m_pictureExcludeFromListingRegExps; extensions = g_stSettings.m_pictureExtensions; } if (directory.GetDirectory(strPath, items, extensions)) { CFileItemList filteredDirectories, filteredFiles; for (unsigned int i = 0; i < (unsigned int)items.Size(); i++) { if (CUtil::ExcludeFileOrFolder(items[i]->m_strPath, regexps)) continue; if (items[i]->IsSmb()) { CURI url(items[i]->m_strPath); items[i]->m_strPath = url.GetWithoutUserDetails(); } if (items[i]->m_bIsFolder) filteredDirectories.Add(items[i]); else filteredFiles.Add(items[i]); } // Check if the "fields" list exists // and make sure it contains the "file" // field Value param = parameterObject; if (!param.isMember("fields")) param["fields"] = Value(arrayValue); bool hasFileField = false; for (unsigned int i = 0; i < param["fields"].size(); i++) { if (param["fields"][i].asString().compare("file") == 0) { hasFileField = true; break; } } if (!hasFileField) param["fields"].append("file"); HandleFileItemList(NULL, true, "files", filteredDirectories, param, result); for (unsigned int index = 0; index < result["files"].size(); index++) { result["files"][index]["filetype"] = "directory"; } int count = result["limits"]["total"].asInt(); HandleFileItemList(NULL, true, "files", filteredFiles, param, result); for (unsigned int index = count; index < result["files"].size(); index++) { result["files"][index]["filetype"] = "file"; } count += result["limits"]["total"].asInt(); result["limits"]["end"] = count; result["limits"]["total"] = count; result["success"] = true; return OK; } return InvalidParams; }
bool CFileOperations::FillFileItemList(const Value ¶meterObject, CFileItemList &list) { if (parameterObject.isObject() && parameterObject.isMember("directory")) { CStdString media = "files"; if (parameterObject.isMember("media")) { if (parameterObject["media"].isString()) media = parameterObject["media"].asString(); else return false; } media = media.ToLower(); if (media.Equals("video") || media.Equals("music") || media.Equals("pictures") || media.Equals("files") || media.Equals("programs")) { CDirectory directory; CFileItemList items; CStdString strPath = parameterObject["directory"].asString(); CStdStringArray regexps; CStdString extensions = ""; if (media.Equals("video")) { regexps = g_advancedSettings.m_videoExcludeFromListingRegExps; extensions = g_stSettings.m_videoExtensions; } else if (media.Equals("music")) { regexps = g_advancedSettings.m_audioExcludeFromListingRegExps; extensions = g_stSettings.m_musicExtensions; } else if (media.Equals("pictures")) { regexps = g_advancedSettings.m_pictureExcludeFromListingRegExps; extensions = g_stSettings.m_pictureExtensions; } if (directory.GetDirectory(strPath, items, extensions)) { CFileItemList filteredDirectories; for (unsigned int i = 0; i < (unsigned int)items.Size(); i++) { if (CUtil::ExcludeFileOrFolder(items[i]->m_strPath, regexps)) continue; if (items[i]->m_bIsFolder) filteredDirectories.Add(items[i]); else list.Add(items[i]); } if (parameterObject.isMember("recursive") && parameterObject["recursive"].isBool()) { for (int i = 0; i < filteredDirectories.Size(); i++) { Value val = parameterObject; val["directory"] = filteredDirectories[i]->m_strPath; FillFileItemList(val, list); } } return true; } } } return false; }
bool CGameConfig::Reparse(char *error, size_t maxlength) { m_Offsets.clear(); m_OffsetsByClass.clear(); m_Keys.clear(); m_Addresses.clear(); char path[PLATFORM_MAX_PATH]; const char *dataDir = get_localinfo("amxx_datadir", "addons/amxmodx/data"); build_pathname_r(path, sizeof(path), "%s/gamedata/%s/master.games.txt", dataDir, m_File); if (!g_LibSys.PathExists(path)) { // Single config file without master g_LibSys.PathFormat(path, sizeof(path), "%s.txt", m_File); if (!EnterFile(path, error, maxlength)) { return false; } // Allow customizations of default gamedata files build_pathname_r(path, sizeof(path), "%s/gamedata/custom/%s.txt", dataDir, m_File); if (g_LibSys.PathExists(path)) { g_LibSys.PathFormat(path, sizeof(path), "custom/%s.txt", m_File); auto success = EnterFile(path, error, maxlength); if (success) { AMXXLOG_Log("[AMXX] Parsed custom gamedata override file: %s", path); } return success; } return true; } SMCError err; SMCStates state = { 0, 0 }; ke::Vector<ke::AString> fileList; MasterReader.m_FileList = &fileList; err = textparsers->ParseSMCFile(path, &MasterReader, &state, error, maxlength); if (err != SMCError_Okay) { const char *msg = textparsers->GetSMCErrorString(err); AMXXLOG_Error("Error parsing master gameconf file \"%s\":", path); AMXXLOG_Error("Error %d on line %d, col %d: %s", err, state.line, state.col, msg ? msg : "Unknown error"); return false; } for (size_t i = 0; i < fileList.length(); ++i) { g_LibSys.PathFormat(path, sizeof(path), "%s/%s", m_File, fileList[i].chars()); if (!EnterFile(path, error, maxlength)) { return false; } } build_pathname_r(path, sizeof(path), "%s/gamedata/%s/custom", dataDir, m_File); CDirectory *customDir = g_LibSys.OpenDirectory(path); if (!customDir) { return true; } while (customDir->MoreFiles()) { if (!customDir->IsEntryFile()) { customDir->NextEntry(); continue; } const char *currentFile = customDir->GetEntryName(); size_t length = strlen(currentFile); if (length > 4 && strcmp(¤tFile[length - 4], ".txt") != 0) { customDir->NextEntry(); continue; } g_LibSys.PathFormat(path, sizeof(path), "%s/custom/%s", m_File, currentFile); if (!EnterFile(path, error, maxlength)) { g_LibSys.CloseDirectory(customDir); return false; } AMXXLOG_Log("[AMXX] Parsed custom gamedata override file: %s", path); customDir->NextEntry(); } g_LibSys.CloseDirectory(customDir); return true; }
int CStorageServer::initilize() { //todo: storage initilize typedef CThread* CThreadPtr; CDirectory dir; int nthread_curr, ret; addr_list proxy_addr_list; CThreadBeatHeart *pbeat_heart_func; CThreadSyncData *psync_thread_func; g_ntimeout = m_storage_server_conf.ntimeout; g_nstorage_bind_port = m_storage_server_conf.nbind_port; g_nstorage_zone_id = m_storage_server_conf.nzone_id; g_nstorage_weight = m_storage_server_conf.nweight; memcpy(g_device_root, m_storage_server_conf.device_path, KL_COMMON_PATH_LEN); CInetAddr bind_addr(m_storage_server_conf.bind_host, \ m_storage_server_conf.nbind_port); if(bind_addr.getipaddress(g_storage_bind_ip, KL_COMMON_IP_ADDR_LEN) != 0) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "get storage node bind ip failed, err: %s", \ __LINE__, strerror(errno)); return errno; } try { g_pcontainer_rwlock = new CRWLock(); } catch(std::bad_alloc) { g_pcontainer_rwlock = NULL; } catch(int errcode) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "call CRWLock constructor failed, err: %s", \ __LINE__, strerror(errcode)); return errcode; } if(g_pcontainer_rwlock == NULL) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create vnode container rwlock", \ __LINE__); return ENOMEM; } try { g_pstorage_vnode_container = new CStorageVnodeContainer(); } catch(std::bad_alloc) { g_pstorage_vnode_container = NULL; } catch(int errcode) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "call CStorageVnodeContainer constructor failed, err: %s", \ __LINE__, strerror(errcode)); return errcode; } if(g_pstorage_vnode_container == NULL) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create storage vnode container", \ __LINE__); return ENOMEM; } //create sync message queue try { m_psync_msg_queue = new CMsgQueue(); } catch(std::bad_alloc) { m_psync_msg_queue = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create sync msg queue", \ __LINE__); return ENOMEM; } catch(int errcode) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "call CMsgQueue constructor failed, err: %s", \ __LINE__, strerror(errcode)); return errcode; } //create sync push thread proxy_addr_list = m_storage_server_conf.proxy_addr_list; if(proxy_addr_list.empty()) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no proxy server address to join and report", \ __LINE__); return -1; } try { psync_thread_func = new CThreadSyncData(m_psync_msg_queue, proxy_addr_list[0]); } catch(std::bad_alloc) { psync_thread_func = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create sync thread function", \ __LINE__); return ENOMEM; } try { m_psync_thread = new CThread(psync_thread_func, \ m_storage_server_conf.nthread_stack_size); } catch(std::bad_alloc) { m_psync_thread = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create storage sync thread", \ __LINE__); return ENOMEM; } catch(int errcode) { m_psync_thread = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "call CThread constructor failed, err: %s", \ __LINE__, strerror(errcode)); return errcode; } //create beat-hearting thread to report try { m_ppreport_threads = new CThreadPtr[proxy_addr_list.size()]; } catch(std::bad_alloc) { m_ppreport_threads = NULL; } if(m_ppreport_threads == NULL) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create report thread array", \ __LINE__); return ENOMEM; } //create a report thread to each proxynode for(nthread_curr = 0; nthread_curr < proxy_addr_list.size(); nthread_curr++) { try { pbeat_heart_func = new CThreadBeatHeart(proxy_addr_list[nthread_curr], \ m_psync_msg_queue, nthread_curr); } catch(std::bad_alloc) { pbeat_heart_func = NULL; } catch(int errcode) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "call CThreadBeatHeart constructor failed, err: %s", \ __LINE__, strerror(errcode)); return errcode; } if(pbeat_heart_func == NULL) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create beat-hearting function", \ __LINE__); return ENOMEM; } try { m_ppreport_threads[nthread_curr] = new CThread(pbeat_heart_func, \ m_storage_server_conf.nthread_stack_size); } catch(std::bad_alloc) { m_ppreport_threads[nthread_curr] = NULL; } catch(int errcode) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "call CThread constructor failed, err: %s", \ __LINE__, strerror(errcode)); return errcode; } if(m_ppreport_threads[nthread_curr] == NULL) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create beat-hearting thread", \ __LINE__); return ENOMEM; } } //make device root dir if(dir.dir_exist(g_device_root)) { dir.remove_dir(g_device_root); } if((ret = dir.make_dir(g_device_root)) != 0) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "make device root dir failed, dir_path: %s, err: %s", \ __LINE__, g_device_root, strerror(ret)); return ret; } //do base server initilize return CBaseServer::initilize(); }
JSON_STATUS CFileOperations::GetDirectory(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result) { CStdString media = parameterObject["media"].asString(); media = media.ToLower(); CDirectory directory; CFileItemList items; CStdString strPath = parameterObject["directory"].asString(); CStdStringArray regexps; CStdString extensions = ""; if (media.Equals("video")) { regexps = g_advancedSettings.m_videoExcludeFromListingRegExps; extensions = g_settings.m_videoExtensions; } else if (media.Equals("music")) { regexps = g_advancedSettings.m_audioExcludeFromListingRegExps; extensions = g_settings.m_musicExtensions; } else if (media.Equals("pictures")) { regexps = g_advancedSettings.m_pictureExcludeFromListingRegExps; extensions = g_settings.m_pictureExtensions; } if (directory.GetDirectory(strPath, items, extensions)) { CFileItemList filteredDirectories, filteredFiles; for (unsigned int i = 0; i < (unsigned int)items.Size(); i++) { if (CUtil::ExcludeFileOrFolder(items[i]->GetPath(), regexps)) continue; if (items[i]->IsSmb()) { CURL url(items[i]->GetPath()); items[i]->SetPath(url.GetWithoutUserDetails()); } if (items[i]->m_bIsFolder) filteredDirectories.Add(items[i]); else if ((media == "video" && items[i]->HasVideoInfoTag()) || (media == "music" && items[i]->HasMusicInfoTag())) filteredFiles.Add(items[i]); else { CFileItem fileItem; if (FillFileItem(items[i]->GetPath(), fileItem, media)) filteredFiles.Add(CFileItemPtr(new CFileItem(fileItem))); } } // Check if the "fields" list exists // and make sure it contains the "file" // field CVariant param = parameterObject; if (!param.isMember("fields")) param["fields"] = CVariant(CVariant::VariantTypeArray); bool hasFileField = false; for (CVariant::const_iterator_array itr = param["fields"].begin_array(); itr != param["fields"].end_array(); itr++) { if (*itr == CVariant("file")) { hasFileField = true; break; } } if (!hasFileField) param["fields"].append("file"); HandleFileItemList(NULL, true, "files", filteredDirectories, param, result); for (unsigned int index = 0; index < result["files"].size(); index++) { result["files"][index]["filetype"] = "directory"; } int count = (int)result["limits"]["total"].asInteger(); HandleFileItemList("id", true, "files", filteredFiles, param, result); for (unsigned int index = count; index < result["files"].size(); index++) { result["files"][index]["filetype"] = "file"; } count += (int)result["limits"]["total"].asInteger(); result["limits"]["end"] = count; result["limits"]["total"] = count; return OK; } return InvalidParams; }