int bd_rename(const char *pFilename, const char *pDestFilename) { if (strcmp(pFilename, pDestFilename) == 0) return 0; char filenameSrc[FILENAME_SIZE]; if (GetFilenameFromPath(pFilename, filenameSrc) == 0) return -1; char directorySrc[PATH_SIZE]; if (GetDirFromPath(pFilename, directorySrc) == 0) return -1; iNodeEntry *pInodeParentSrc = alloca(sizeof(*pInodeParentSrc)); if (GetINodeFromPath(directorySrc, &pInodeParentSrc) == -1) return -1; iNodeEntry *pInodeSrc = alloca(sizeof(*pInodeSrc)); if (GetINodeFromPath(pFilename, &pInodeSrc) == -1) return -1; char filenameDest[FILENAME_SIZE]; if (GetFilenameFromPath(pDestFilename, filenameDest) == 0) return -1; char directoryDest[PATH_SIZE]; if (GetDirFromPath(pDestFilename, directoryDest) == 0) return -1; iNodeEntry *pInodeParentDest = alloca(sizeof(*pInodeParentDest)); if (GetINodeFromPath(directoryDest, &pInodeParentDest) == -1) return -1; if (pInodeSrc->iNodeStat.st_mode & G_IFDIR) { if (strcmp(directorySrc, directoryDest) != 0) { pInodeParentSrc->iNodeStat.st_nlink--; pInodeParentDest->iNodeStat.st_nlink++; } char dataBlock[BLOCK_SIZE]; if (ReadBlock(pInodeSrc->Block[0], dataBlock) == -1) return -1; DirEntry *pDirEntry = (DirEntry*)dataBlock; pDirEntry[1].iNode = pInodeParentDest->iNodeStat.st_ino; if (WriteBlock(pInodeSrc->Block[0], dataBlock) == -1) return -1; } if (RemoveINodeFromINode(filenameSrc, pInodeSrc, pInodeParentSrc) == -1) return -1; if (strcmp(directorySrc, directoryDest) == 0) { pInodeParentDest = pInodeParentSrc; } if (AddINodeToINode(filenameDest, pInodeSrc, pInodeParentDest) == -1) return -1; return 0; }
void ZipArchiveEntry::SetFullName(const std::string& fullName) { std::string filename = fullName; std::string correctFilename; // unify slashes std::replace(filename.begin(), filename.end(), '\\', '/'); bool isDirectory = IsDirectoryPath(filename); // if slash is first char, remove it if (filename[0] == '/') { filename = filename.substr(filename.find_first_not_of('/')); } // find multiply slashes bool prevWasSlash = false; for (std::string::size_type i = 0; i < filename.length(); ++i) { if (filename[i] == '/' && prevWasSlash) continue; prevWasSlash = (filename[i] == '/'); correctFilename += filename[i]; } _centralDirectoryFileHeader.Filename = correctFilename; _name = GetFilenameFromPath(correctFilename); this->SetAttributes(isDirectory ? Attributes::Directory : Attributes::Archive); }
int bd_create(const char *pFilename) { char directory[PATH_SIZE]; if (GetDirFromPath(pFilename, directory) == 0) return -1; char filename[PATH_SIZE]; if (GetFilenameFromPath(pFilename, filename) == 0 || strlen(filename) > FILENAME_SIZE) return -1; iNodeEntry *pInodeDir = alloca(sizeof(*pInodeDir)); if (GetINodeFromPath(directory, &pInodeDir) == -1) return -1; iNodeEntry *pInodeFile = alloca(sizeof(*pInodeFile)); if (GetINodeFromPath(pFilename, &pInodeFile) != -1) return -2; if (GetFreeINode(&pInodeFile) != -1) { pInodeFile->iNodeStat.st_mode |= G_IRWXU | G_IRWXG | G_IFREG; pInodeFile->iNodeStat.st_nlink = 1; if (AddINodeToINode(filename, pInodeFile, pInodeDir) != -1) return WriteINodeToDisk(pInodeFile); } return -1; }
int bd_rmdir(const char *pFilename) { int iNode = find_iNode(pFilename); if (iNode == -1) { return iNode; } int isDirectory = is_directory(iNode); if (!isDirectory) { return -2; } int isDirectoryEmpty = is_directory_empty(iNode); if (isDirectoryEmpty == -3) { return isDirectoryEmpty; } char parentPath[strlen(pFilename)]; GetDirFromPath(pFilename, parentPath); int parentiNode = find_iNode(parentPath); char filename[FILENAME_SIZE]; GetFilenameFromPath(pFilename, filename); remove_directory(iNode, parentiNode, filename); return 0; }
int bd_mkdir(const char *pDirName) { char pathName[strlen(pDirName)]; GetDirFromPath(pDirName, pathName); int parentiNode = find_iNode(pathName); if (parentiNode == -1) { return parentiNode; } int iNode = find_iNode(pDirName); if (iNode != -1) { return -2; } char directoryName[FILENAME_SIZE]; GetFilenameFromPath(pDirName, directoryName); // Create a file with the directory name create_file(parentiNode, directoryName); increase_link_count(parentiNode); // Find the newly created directory inode iNode = find_iNode(pDirName); // Increase its link count increase_link_count(iNode); // Set the right flags set_directory_flags(iNode); // Adds '.' and '..' directories add_default_directories(iNode, parentiNode); return 0; }
int bd_hardlink(const char *pPathExistant, const char *pPathNouveauLien) { int existingFileiNode = find_iNode(pPathExistant); if (existingFileiNode == -1) { return -1; } // We check if the directory that will contain the new hardlink exists char newLinkPath[strlen(pPathNouveauLien)]; GetDirFromPath(pPathNouveauLien, newLinkPath); int newLinkPathiNode = find_iNode(newLinkPath); if (newLinkPathiNode == -1) { return -1; } // We check that the new hardlink doesn't already exists int newLinkExists = find_iNode(pPathNouveauLien); if (newLinkExists != -1) { return -2; } char linkName[strlen(pPathNouveauLien)]; GetFilenameFromPath(pPathNouveauLien, linkName); int isSuccess = create_hardlink(existingFileiNode, newLinkPathiNode, linkName); return isSuccess; }
int bd_hardlink(const char *pPathExistant, const char *pPathNouveauLien) { iNodeEntry *pInodeEx = alloca(sizeof(*pInodeEx)); if (GetINodeFromPath(pPathExistant, &pInodeEx) == -1) return -1; char directory[PATH_SIZE]; if (GetDirFromPath(pPathNouveauLien, directory) == 0) return -1; iNodeEntry *pInodeNewDir = alloca(sizeof(*pInodeNewDir)); if (GetINodeFromPath(directory, &pInodeNewDir) == -1) return -1; iNodeEntry *pInodeNewFile = alloca(sizeof(*pInodeNewFile)); if (GetINodeFromPath(pPathNouveauLien, &pInodeNewFile) != -1) return -2; if ((pInodeEx->iNodeStat.st_mode & G_IFDIR) && !(pInodeEx->iNodeStat.st_mode & G_IFREG)) return -3; char filename[FILENAME_SIZE]; if (GetFilenameFromPath(pPathNouveauLien, filename) == 0) return -1; pInodeEx->iNodeStat.st_nlink++; if (AddINodeToINode(filename, pInodeEx, pInodeNewDir) == -1) return -1; return WriteINodeToDisk(pInodeEx); }
int bd_unlink(const char *pFilename) { iNodeEntry *pInode = alloca(sizeof(*pInode)); if (GetINodeFromPath(pFilename, &pInode) == -1) return -1; if (!(pInode->iNodeStat.st_mode & G_IFREG)) return -2; char directory[PATH_SIZE]; if (GetDirFromPath(pFilename, directory) == 0) return -1; iNodeEntry *pInodeDir = alloca(sizeof(*pInodeDir)); if (GetINodeFromPath(directory, &pInodeDir) == -1) return -1; pInode->iNodeStat.st_nlink -= 1; if (pInode->iNodeStat.st_nlink == 0) { size_t i; for (i = 0; i < pInode->iNodeStat.st_blocks; ++i) ReleaseBlockFromDisk(pInode->Block[i]); ReleaseINodeFromDisk(pInode->iNodeStat.st_ino); } else WriteINodeToDisk(pInode); char filename[FILENAME_SIZE]; if (GetFilenameFromPath(pFilename, filename) == 0) return -1; if (RemoveINodeFromINode(filename, pInode, pInodeDir) == -1) return -1; return 0; }
int bd_rmdir(const char *pFilename) { iNodeEntry *pInodeDir = alloca(sizeof(*pInodeDir)); if (GetINodeFromPath(pFilename, &pInodeDir) == -1) return -1; if (pInodeDir->iNodeStat.st_mode & G_IFREG) return -2; const size_t nDir = NumberofDirEntry(pInodeDir->iNodeStat.st_size); if (nDir == 2) { iNodeEntry *pInodeParent = alloca(sizeof(*pInodeParent)); char directory[PATH_SIZE]; if (GetDirFromPath(pFilename, directory) == 0) return -1; if (GetINodeFromPath(directory, &pInodeParent) == -1) return -1; pInodeParent->iNodeStat.st_nlink--; char filename[FILENAME_SIZE]; if (GetFilenameFromPath(pFilename, filename) == 0) return -1; if (RemoveINodeFromINode(filename, pInodeDir, pInodeParent) == -1) return -1; ReleaseBlockFromDisk(pInodeDir->Block[0]); ReleaseINodeFromDisk(pInodeDir->iNodeStat.st_ino); return 0; } return -3; }
void CScriptDebugging::LogBadType ( lua_State* luaVM, const char* szFunction ) { assert ( szFunction ); lua_Debug debugInfo; if ( lua_getstack ( luaVM, 1, &debugInfo ) ) { lua_getinfo ( luaVM, "nlS", &debugInfo ); const char* szFilename = GetFilenameFromPath ( debugInfo.source ); // Populate a message to print/send LogWarning ( luaVM, "%s: Bad argument @ '%s' - Line: %d", szFilename, szFunction, debugInfo.currentline ); } }
void CScriptDebugging::LogBadLevel ( lua_State* luaVM, const char* szFunction, unsigned int uiRequiredLevel ) { assert ( szFunction ); lua_Debug debugInfo; if ( lua_getstack ( luaVM, 1, &debugInfo ) ) { lua_getinfo ( luaVM, "nlS", &debugInfo ); const char* szFilename = GetFilenameFromPath ( debugInfo.source ); // Populate a message to print/send LogWarning ( luaVM, "%s: Requires level '%d' @ '%s' - Line: %d", szFilename, uiRequiredLevel, szFunction, debugInfo.currentline ); } }
void CScriptDebugging::LogBadPointer ( lua_State* luaVM, const char* szFunction, const char* szArgumentType, unsigned int uiArgument ) { assert ( szFunction ); assert ( szArgumentType ); lua_Debug debugInfo; if ( lua_getstack ( luaVM, 1, &debugInfo ) ) { lua_getinfo ( luaVM, "nlS", &debugInfo ); const char* szFilename = GetFilenameFromPath ( debugInfo.source ); // Populate a message to print/send LogWarning ( luaVM, "%s: Bad '%s' pointer @ '%s'(%u) - Line: %d", szFilename, szArgumentType, szFunction, uiArgument, debugInfo.currentline ); } }
void _log(char* path, char* function, int line, GAME_LOG type, char* vaArgs, ...) { va_list list; fopen_s(&fileHandler, "log.txt", SESSION_TRACKER ? "a+" : "w"); char* typeOfLog = GetTypeOfLog(type); fprintf(fileHandler, "[%s][%s - %s - %d] : ", typeOfLog, GetFilenameFromPath(path) , function, line); va_start(list, vaArgs); for(char* arg = vaArgs; *arg; ++arg) { if(*arg != '%') { fputc(*arg, fileHandler); } else { switch(*++arg) { //char case 's': { char* argValueCharPointer = va_arg(list, char*); fprintf(fileHandler, "%s", argValueCharPointer); } continue; //integer case 'd': { int argValueInteger = va_arg(list, int); fprintf(fileHandler, "%d", argValueInteger); } continue; default: { fputc(*arg, fileHandler); } break; } } } va_end(list); fputc('\n', fileHandler); SESSION_TRACKER++; fclose(fileHandler); }
int GetFaceFromFilename(const string filePath, const Vec4f point, Face& faces) { string sign; int id; string filename = GetFilenameFromPath(filePath); ReadFilename(filename, id, sign); Mat image = imread(filePath, 0); if (image.empty()) return 0; //图片读取失败,返回 Point2f pLeft = Point2f(point[0],point[1]); Point2f pRight = Point2f(point[2],point[3]); Mat dst = AlignFace(image, pRight, pLeft); //尺寸归一化 faces.filename = filePath; faces.id = id; faces.sign = sign; faces.eyePoints = point; faces.face = dst; faces.value = 0.0; return 1; }
int bd_create(const char *pFilename) { int fileExists = find_iNode(pFilename); if (fileExists != -1) { return -2; } char pathName[strlen(pFilename)]; GetDirFromPath(pFilename, pathName); int pathiNode = find_iNode(pathName); if (pathiNode == -1) { return -1; } char filename[FILENAME_SIZE]; GetFilenameFromPath(pFilename, filename); create_file(pathiNode, filename); return 0; }
int remove_file(ino iNode, const char *filePath) { int isFile = check_if_inode_is_file(iNode); if (isFile == -2) { return isFile; } char path[strlen(filePath)]; GetDirFromPath(filePath, path); int pathiNode = find_iNode(path); char file[FILENAME_SIZE]; GetFilenameFromPath(filePath, file); // We can't use the file inode directly since hardlinks have the same name // as the file they are linked against remove_file_from_directory(pathiNode, iNode, file); // Decrease link count and, if link == 0, remove file decrease_link_count(iNode); return 0; }
int find_iNode(const char *pFilename) { int slashesCount = count_delimiter(pFilename, '/'); char filename[FILENAME_SIZE]; char path[strlen(pFilename)]; GetFilenameFromPath(pFilename, filename); GetDirFromPath(pFilename, path); if (slashesCount > 1) { return find_iNode_in_subpath(filename, path); } else { char directoryDataBlock[BLOCK_SIZE]; // We read the root directory ReadBlock(6, directoryDataBlock); DirEntry *directory = (DirEntry *)directoryDataBlock; if (strlen(pFilename) == 1) { int i; for (i = 0; i < BLOCK_SIZE; ++i) { if (strcmp(directory[i].Filename, ".") == 0) { return directory[i].iNode; } } } else { int i; for (i = 0; i < BLOCK_SIZE; ++i) { // printf("\tFile: %s\n", directory[i].Filename); // printf("\tFile to find: %s\n\n", filename); if (strcmp(directory[i].Filename, filename) == 0) { return directory[i].iNode; } } } } return -1; }
int bd_rename(const char *pFilename, const char *pDestFilename) { // Check if both directory are valid, if so keep them in memory char initialDirectory[BLOCK_SIZE]; char newDirectory[BLOCK_SIZE]; if (GetDirFromPath(pFilename, initialDirectory) != 1) { return -1; } if (GetDirFromPath(pDestFilename, newDirectory) != 1) { return -1; } // Find directory inodes and if there are valid int newDirectoryiNode = find_iNode(newDirectory); if (newDirectoryiNode == -1) { return -1; } int initialDirectoryiNode = find_iNode(initialDirectory); if (initialDirectoryiNode == -1) { return -1; } // Check if they have the same directory, if so, assigned the initial inode // to the newDirectory if (strcmp(initialDirectory, newDirectory) == 0) { newDirectoryiNode = initialDirectoryiNode; } // If pFilename is not a directory, we simply do an hardlink int pFilenameiNode = find_iNode(pFilename); if (check_if_inode_is_file(pFilenameiNode) == 0) { int renamingFilenameSuccess = bd_hardlink(pFilename, pDestFilename); if (renamingFilenameSuccess == 0) { int unlinkingFilenameSuccess = bd_unlink(pFilename); return unlinkingFilenameSuccess; } } else { // If pFilename is a directory char newFile[BLOCK_SIZE]; // If the new directory doesn't exists if (find_iNode(pDestFilename) == -1) { // We remove directory from it's initial parentDirectory if (GetFilenameFromPath(pFilename, newFile) == 1) { remove_file_from_directory(initialDirectoryiNode, pFilenameiNode, newFile); decrease_link_count(initialDirectoryiNode); } else { return -1; } // We add directory to it's new parentDirectory if (GetFilenameFromPath(pDestFilename, newFile) == 1) { char directoryDataBlock[BLOCK_SIZE]; ReadBlock(6 + newDirectoryiNode - 1, directoryDataBlock); DirEntry *directory = (DirEntry *)directoryDataBlock; int filesNumber = numberOfFilesInDirectory(directory); // Assign newDirectory informations strcpy(directory[filesNumber].Filename, newFile); directory[filesNumber].iNode = pFilenameiNode; // Adjuste the newDirectory and its parentDirectory size add_size_to_inode_size(sizeof(directory[filesNumber]), newDirectoryiNode); increase_link_count(newDirectoryiNode); add_parentiNode(pFilenameiNode, newDirectoryiNode); WriteBlock(6 + newDirectoryiNode - 1, directoryDataBlock); } } } return 0; }
int bd_read(const char *pFilename, char *buffer, int offset, int numbytes) { iNodeEntry *pInode = alloca(sizeof(*pInode)); const int inode = GetINodeFromPath(pFilename, &pInode); if (inode == -1) { printf("Le fichier %s est inexistant!\n", pFilename); return -1; } if (pInode->iNodeStat.st_mode & G_IFDIR) { printf("Le fichier %s est un repertoire!\n", pFilename); return -2; } if (pInode->iNodeStat.st_size < offset) { return 0; } const size_t firstBlock = offset / BLOCK_SIZE; const size_t offsetFirstBlock = offset % BLOCK_SIZE; const size_t sizeToRead = min(pInode->iNodeStat.st_size - offset, numbytes); const size_t lastBlock = (sizeToRead + offset) / BLOCK_SIZE; const size_t offsetLastBlock = (sizeToRead + offset) % BLOCK_SIZE; size_t length[N_BLOCK_PER_INODE] = {[0 ... N_BLOCK_PER_INODE - 1] = BLOCK_SIZE}; length[lastBlock] = offsetLastBlock; length[firstBlock] = min(BLOCK_SIZE - offsetFirstBlock, sizeToRead); size_t readOffset[N_BLOCK_PER_INODE] = {[0 ... N_BLOCK_PER_INODE - 1] = 0}; readOffset[firstBlock] = offsetFirstBlock; size_t i, writeOffset = 0; for (i = firstBlock; (i <= lastBlock) && (i < N_BLOCK_PER_INODE); ++i) { char *dataBlock = alloca(BLOCK_SIZE); if (ReadBlock(pInode->Block[i], dataBlock) == -1) return -1; memcpy(&buffer[writeOffset], &dataBlock[readOffset[i]], length[i]); writeOffset += length[i]; } return sizeToRead; } int bd_write(const char *pFilename, const char *buffer, int offset, int numbytes) { iNodeEntry *pInode = alloca(sizeof(*pInode)); const int inode = GetINodeFromPath(pFilename, &pInode); if (inode == -1) { printf("Le fichier %s est inexistant!\n", pFilename); return -1; } if (pInode->iNodeStat.st_mode & G_IFDIR) { printf("Le fichier %s est un repertoire!\n", pFilename); return -2; } if (offset > pInode->iNodeStat.st_size) { printf("L'offset demande est trop grand!\n"); return -3; } const size_t maxFileSize = N_BLOCK_PER_INODE * BLOCK_SIZE; if (offset >= maxFileSize) { printf("Taille trop grande (offset=%ld) pour le fichier %s!\n", maxFileSize, pFilename); return -4; } if ((numbytes + offset) > maxFileSize) { printf("Le fichier %s deviendra trop gros!\n", pFilename); } const size_t firstBlock = offset / BLOCK_SIZE; const size_t offsetFirstBlock = offset % BLOCK_SIZE; const size_t sizeToWrite = min(numbytes, maxFileSize - offset); const size_t lastBlock = (sizeToWrite + offset) / BLOCK_SIZE; const size_t offsetLastBlock = (sizeToWrite + offset) % BLOCK_SIZE; size_t length[N_BLOCK_PER_INODE] = {[0 ... N_BLOCK_PER_INODE - 1] = BLOCK_SIZE}; length[lastBlock] = offsetLastBlock; length[firstBlock] = min(BLOCK_SIZE - offsetFirstBlock, sizeToWrite); size_t writeOffset[N_BLOCK_PER_INODE] = {[0 ... N_BLOCK_PER_INODE - 1] = 0}; writeOffset[firstBlock] = offsetFirstBlock; size_t i, readOffset = 0; for (i = firstBlock; (i <= lastBlock) && (i < N_BLOCK_PER_INODE); ++i) { if (i >= pInode->iNodeStat.st_blocks) { int block = 0; if ((block = GetFreeBlock()) == -1) return -1; pInode->Block[i] = block; pInode->iNodeStat.st_blocks++; } char *dataBlock = alloca(BLOCK_SIZE); if (ReadBlock(pInode->Block[i], dataBlock) == -1) return -1; memcpy(&dataBlock[writeOffset[i]], &buffer[readOffset], length[i]); if (WriteBlock(pInode->Block[i], dataBlock) == -1) return -1; readOffset += length[i]; } pInode->iNodeStat.st_size = max(pInode->iNodeStat.st_size, offset + sizeToWrite); if (WriteINodeToDisk(pInode) == -1) return -1; return sizeToWrite; } int bd_mkdir(const char *pDirName) { char pathOfDir[PATH_SIZE]; if (GetDirFromPath(pDirName, pathOfDir) == 0) return -1; char dirName[PATH_SIZE]; if (GetFilenameFromPath(pDirName, dirName) == 0 || strlen(dirName) > FILENAME_SIZE) return -1; iNodeEntry *pDirInode = alloca(sizeof(*pDirInode)); if (GetINodeFromPath(pathOfDir, &pDirInode) == -1 || pDirInode->iNodeStat.st_mode & G_IFREG) return -1; const size_t nDir = NumberofDirEntry(pDirInode->iNodeStat.st_size); if (((nDir + 1) * sizeof(DirEntry)) > BLOCK_SIZE) return -1; iNodeEntry *pChildInode = alloca(sizeof(*pChildInode)); if (GetINodeFromPath(pDirName, &pChildInode) != -1) return -2; if (GetFreeINode(&pChildInode) == -1) return -1; char dataBlock[BLOCK_SIZE]; DirEntry *pDirEntry = (DirEntry*)dataBlock; strcpy(pDirEntry[0].Filename, "."); strcpy(pDirEntry[1].Filename, ".."); pDirEntry[0].iNode = pChildInode->iNodeStat.st_ino; pDirEntry[1].iNode = pDirInode->iNodeStat.st_ino; const int idBlocDir = GetFreeBlock(); if (idBlocDir == -1) { ReleaseINodeFromDisk(pChildInode->iNodeStat.st_ino); return -1; } if (WriteBlock(idBlocDir, dataBlock) == -1) { ReleaseINodeFromDisk(pChildInode->iNodeStat.st_ino); ReleaseBlockFromDisk(idBlocDir); return -1; } pChildInode->iNodeStat.st_mode |= G_IFDIR | G_IRWXU | G_IRWXG; pChildInode->iNodeStat.st_nlink = 2; pChildInode->iNodeStat.st_size = 2 * sizeof(DirEntry); pChildInode->iNodeStat.st_blocks = 1; pChildInode->Block[0] = idBlocDir; if (WriteINodeToDisk(pChildInode) == -1) { ReleaseINodeFromDisk(pChildInode->iNodeStat.st_ino); ReleaseBlockFromDisk(idBlocDir); return -1; } pDirInode->iNodeStat.st_nlink++; if (AddINodeToINode(dirName, pChildInode, pDirInode) == -1) { ReleaseINodeFromDisk(pChildInode->iNodeStat.st_ino); ReleaseBlockFromDisk(idBlocDir); return -1; } return 0; }