void MergeStreams(FileInputStream * in1, FileInputStream * in2, char * outfile) { FileOutputStream * outStream = NULL; try { int nbytes; char buffer[1]; outStream = new FileOutputStream(outfile); while ((nbytes = (in1->read(buffer, 1)) != -1)) { outStream->write(buffer, nbytes); } while ((nbytes = (in2->read(buffer, 1)) != -1)) { outStream->write(buffer, nbytes); } delete outStream; } catch (IOException & err) { err.Display(); cout<<"Deleting dynamic outStream object"<<endl; delete outStream; throw FileNotFoundException(outfile); } catch (Xception & err) { err.Display(); cout<<"Deleting dynamic FileOutputStream object"<<endl; delete outStream; throw FileNotFoundException(outfile); } }
int JpegStegoDecoder::Decode(char *infile, char *outfile, bool getMes) { if(!outfile) outfile = "nul"; // test for existing input and output files FILE *fp; if ((fp = fopen(infile, READ_BINARY)) == NULL) { throw FileNotFoundException("File not found\n",infile); } fclose(fp); if ((fp = fopen(outfile, WRITE_BINARY)) == NULL) { throw FileNotFoundException("File not found\n",outfile); } fclose(fp); InitJpegStego(true); int argc = 3; char *argv[3]; char name[]="djpeg"; argv[0]=name; argv[1]=infile; argv[2]=outfile; return main_djpeg(argc, argv, sData); }
void SerialChannelImpl::handleError(const std::string& name) { std::string errorText; DWORD error = GetLastError(); switch (error) { case ERROR_FILE_NOT_FOUND: throw FileNotFoundException(name, getErrorText(errorText)); case ERROR_ACCESS_DENIED: throw FileAccessDeniedException(name, getErrorText(errorText)); case ERROR_ALREADY_EXISTS: case ERROR_FILE_EXISTS: throw FileExistsException(name, getErrorText(errorText)); case ERROR_FILE_READ_ONLY: throw FileReadOnlyException(name, getErrorText(errorText)); case ERROR_CANNOT_MAKE: case ERROR_INVALID_NAME: case ERROR_FILENAME_EXCED_RANGE: throw CreateFileException(name, getErrorText(errorText)); case ERROR_BROKEN_PIPE: case ERROR_INVALID_USER_BUFFER: case ERROR_INSUFFICIENT_BUFFER: throw IOException(name, getErrorText(errorText)); case ERROR_NOT_ENOUGH_MEMORY: throw OutOfMemoryException(name, getErrorText(errorText)); case ERROR_HANDLE_EOF: break; default: throw FileException(name, getErrorText(errorText)); } }
ArchiveReader::ArchiveReader(const path_t &path, const path_t *encrypted_fso, RsaKeyPair *keypair): manifest_offset(-1), path(path), keypair(keypair){ if (!boost::filesystem::exists(path) || !boost::filesystem::is_regular_file(path)) throw FileNotFoundException(path); }
FileReader::FileReader(const String& fileName) { this->file = newInstance<std::ifstream>(StringUtils::toUTF8(fileName).c_str(), std::ios::binary | std::ios::in); if (!file->is_open()) boost::throw_exception(FileNotFoundException(fileName)); _length = FileUtils::fileLength(fileName); }
void ConfigFile::load( const std::string fileName, const std::string delimiter, const std::string comment, const std::string inc, const std::string sentry ) { // Construct a ConfigFile, getting keys and values from given file // the old values std::string delimiter1 = _delimiter; std::string comment1 = _comment; std::string inc1 = _include; std::string sentry1 = _sentry; if (delimiter != "") _delimiter = delimiter; if (comment != "") _comment = comment; if (inc != "") _include = inc; if (sentry != "") _sentry = sentry; std::ifstream in( fileName.c_str() ); if( !in ) { throw FileNotFoundException(fileName); } in >> (*this); _delimiter = delimiter1; _comment = comment1; _include = inc1; _sentry = sentry1; }
void CFileContent::load() { ifstream is( realPath_m, ifstream::binary ); if ( !is ) throw FileNotFoundException( userPath_m.c_str(), "" ); is.seekg( 0, is.end ); size_m = (size_t) is.tellg(); is.seekg( 0, is.beg ); char * buf = new char[size_m]; is.read( buf, size_m ); size_m = (size_t) is.tellg(); data_m.insert( data_m.begin(), buf, buf + size_m ); delete[] buf; if ( !is.good() ) throw FileErrorException( userPath_m.c_str() ); is.close(); modificationTime(); creationTime(); }
//-------- WatchID FileWatcherWin32::addWatch(const String& directory, FileWatchListener* watcher, bool recursive) { WatchID watchid = ++mLastWatchID; WatchStruct* watch = CreateWatch( directory.c_str(), FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_FILE_NAME, recursive); if(!watch) { std::ostringstream message; message << "In " << __FILE__ << " at line " << __LINE__ << ": "; throw FileNotFoundException(directory, message.str()); } watch->mWatchid = watchid; watch->mFileWatcher = this; watch->mFileWatchListener = watcher; watch->mRecursive = recursive; watch->mDirName = new char[directory.length()+1]; strcpy(watch->mDirName, directory.c_str()); mWatches.insert(std::make_pair(watchid, watch)); return watchid; }
void addFile(const String& name, bool imitEvents = true) { //fprintf(stderr, "ADDED: %s\n", name.c_str()); // create entry struct stat attrib; stat(name.c_str(), &attrib); int fd = open(name.c_str(), O_RDONLY | O_EVTONLY); if(fd == -1) throw FileNotFoundException(name); ++mChangeListCount; char* namecopy = new char[name.length() + 1]; strncpy(namecopy, name.c_str(), name.length()); namecopy[name.length()] = 0; EntryStruct* entry = new EntryStruct(namecopy, mWatchID, attrib.st_mtime); // set the event data at the end of the list EV_SET(&mChangeList[mChangeListCount], fd, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_ONESHOT/* | EV_CLEAR*/, NOTE_DELETE | NOTE_EXTEND | NOTE_WRITE | NOTE_ATTRIB | NOTE_RENAME | NOTE_LINK | NOTE_REVOKE, 0, (void*)entry); // qsort qsort(mChangeList + 1, mChangeListCount, sizeof(KEvent), comparator); // handle action if(imitEvents) handleAction(name, Actions::Add); }
Entity* EntityCreator::CreateFromFile(const string& filepath) { std::ifstream fin(filepath, std::ios::in); if (fin) { Json::Value rootNode; Json::Reader reader; bool success = reader.parse(fin, rootNode); if (success) { Model* model = nullptr; PhysicsBody* body = nullptr; if (CheckExistence(rootNode, "model")) { const Json::Value& modelNode = rootNode["model"]; model = ModelCreator::CreateFromJson(modelNode); } if (CheckExistence(rootNode, "body")) { const Json::Value& bodyNode = rootNode["body"]; body = PhysicsCreator::CreateFromJson(bodyNode, model); } Entity* entity = new Entity(model, body); return entity; } else { throw Exception("SceneCreator: Cannot parse file '" + filepath + "': " + reader.getFormatedErrorMessages()); } } else { throw FileNotFoundException(filepath); } }
void removeFile(const String& name, bool imitEvents = true) { // bsearch KEvent target; EntryStruct tempEntry(name.c_str(), 0); target.udata = &tempEntry; KEvent* ke = (KEvent*)bsearch(&target, &mChangeList, mChangeListCount + 1, sizeof(KEvent), comparator); if(!ke) throw FileNotFoundException(name); tempEntry.mFilename = 0; // delete close(ke->ident); delete((EntryStruct*)ke->udata); memset(ke, 0, sizeof(KEvent)); // move end to current memcpy(ke, &mChangeList[mChangeListCount], sizeof(KEvent)); memset(&mChangeList[mChangeListCount], 0, sizeof(KEvent)); --mChangeListCount; // qsort qsort(mChangeList + 1, mChangeListCount, sizeof(KEvent), comparator); // handle action if(imitEvents) handleAction(name, Actions::Delete); }
void addAll() { // add base dir int fd = open(mDirName.c_str(), O_RDONLY | O_EVTONLY); EV_SET(&mChangeList[0], fd, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_ONESHOT, NOTE_DELETE | NOTE_EXTEND | NOTE_WRITE | NOTE_ATTRIB, 0, 0); //fprintf(stderr, "ADDED: %s\n", mDirName.c_str()); // scan directory and call addFile(name, false) on each file DIR* dir = opendir(mDirName.c_str()); if(!dir) throw FileNotFoundException(mDirName); struct dirent* entry; struct stat attrib; while((entry = readdir(dir)) != NULL) { String fname = (mDirName + "/" + String(entry->d_name)); stat(fname.c_str(), &attrib); if(S_ISREG(attrib.st_mode)) addFile(fname, false); //else // fprintf(stderr, "NOT ADDED: %s (%d)\n", fname.c_str(), attrib.st_mode); }//end while closedir(dir); }
utils::File::File(const zchar* const filename, FileAccess access, FileShare share, FileMode mode, FileType type) { hFile = CreateFileW(filename, static_cast<DWORD>(access), static_cast<DWORD>(share), nullptr, static_cast<DWORD>(mode), static_cast<DWORD>(type), nullptr); if (hFile == INVALID_HANDLE_VALUE) { OutputDebugStringW(L"Something is wrong:\n"); auto error = GetLastError(); switch (error) { case ERROR_FILE_EXISTS: OutputDebugStringW(L"File already exists.\n"); throw FileAlreadyExistsException(); case ERROR_FILE_NOT_FOUND: OutputDebugStringW(L"File not found.\n"); throw FileNotFoundException(); case ERROR_SHARING_VIOLATION: OutputDebugStringW(L"File cannot be shared.\n"); throw FileSharingViolationException(); default: OutputDebugStringW(L"Reason is not defined.\n"); throw FileException(); } } }
std::vector<Task>* Parser::parse_stg(const char *filepath, DirectedAcyclicGraph* &graph) throw(FileNotFoundException) { enum section { HEADER, GRAPH, FOOTER }; std::vector<Task>* tasks = NULL; section s = HEADER; std::ifstream file(filepath); if(!file) throw FileNotFoundException(filepath); unsigned int task_count = 0; while(file.good()) { if(s == HEADER) { file >> task_count; if (task_count !=0) { // STG format always includes two dummy nodes task_count = task_count + 2; graph = new DirectedAcyclicGraph(task_count); tasks = new std::vector<Task>(task_count); s = GRAPH; } } else if(s == GRAPH) {
/** * Compute the SHA1 hash for the given file. * @param filename The filename (with or without prefixed by a path). If the file * is not found the exeption 'FileNotFoundException' is thrown. * @param bufferSize The size of the buffer used to give the data to 'QCryptographicHash'. * @return The sha1 hash. */ QByteArray computeSHA1(const QString& filename, qint32 bufferSize) throw (FileNotFoundException) { #if not WITH_SHA1_LINUS QCryptographicHash crypto(QCryptographicHash::Sha1); #endif QFile file(filename); if (!file.open(QIODevice::ReadOnly)) throw FileNotFoundException(); #if WITH_SHA1_LINUS blk_SHA_CTX sha1State; blk_SHA1_Init(&sha1State); unsigned char bufferHash[20]; #endif char buffer[bufferSize]; qint64 bytesRead = 0; while ((bytesRead = file.read(buffer, bufferSize)) > 0) { #if WITH_SHA1_LINUS blk_SHA1_Update(&sha1State, buffer, bytesRead); #else crypto.addData(buffer, bytesRead); #endif } #if WITH_SHA1_LINUS blk_SHA1_Final(bufferHash, &sha1State); return QByteArray((const char*)bufferHash, 20); #else return crypto.result(); #endif }
void FileImpl::handleLastErrorImpl(const std::string& path) { switch (errno) { case EIO: throw IOException(path); case EPERM: throw FileAccessDeniedException("insufficient permissions", path); case EACCES: throw FileAccessDeniedException(path); case ENOENT: throw FileNotFoundException(path); case ENOTDIR: throw OpenFileException("not a directory", path); case EISDIR: throw OpenFileException("not a file", path); case EROFS: throw FileReadOnlyException(path); case EEXIST: throw FileExistsException(path); case ENOSPC: throw FileException("no space left on device", path); case ENOTEMPTY: throw FileException("directory not empty", path); case ENAMETOOLONG: throw PathSyntaxException(path); case ENFILE: case EMFILE: throw FileException("too many open files", path); default: throw FileException(std::strerror(errno), path); } }
void FileImpl::renameToImpl(const std::string& path) { poco_assert (!_path.empty()); POCO_DESCRIPTOR_STRING(oldNameDsc, _path); POCO_DESCRIPTOR_STRING(newNameDsc, path); int res; if ((res = lib$rename_file(&oldNameDsc, &newNameDsc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) != 1) { switch (res & 0x0FFFFFFF) { case RMS$_FNF: throw FileNotFoundException(_path); case RMS$_DEV: case RMS$_DNF: throw PathNotFoundException(_path); case RMS$_SYN: throw PathSyntaxException(path); case RMS$_RMV: throw FileAccessDeniedException(_path); case RMS$_PRV: throw FileAccessDeniedException("insufficient privileges", _path); default: throw FileException(path); } } }
/// <summary>Get fully resolved copy of the path</summary> /// <returns></returns> /// <exception cref="Logic::ComException">COM operation failed</exception> /// <exception cref="Logic::FileNotFoundException">Path not found</exception> /// <exception cref="Logic::IOException">Unable to query properties</exception> Path Path::GetResolved() const { Path resolved; // Resolve path if (!GetFullPathName(c_str(), MAX_PATH, (wchar*)resolved, nullptr)) throw IOException(HERE, L"Unable to resolve path: "+SysErrorString()); // Ensure exists if (!resolved.Exists()) throw FileNotFoundException(HERE, resolved); // Get info SHFILEINFO info; if (!SHGetFileInfo((wchar*)resolved, 0, &info, sizeof(info), SHGFI_ATTRIBUTES)) throw IOException(HERE, L"Unable to retrieve file info: "+SysErrorString()); // Ensure is link if (info.dwAttributes & SFGAO_LINK) { IShellLinkPtr shell(CLSID_ShellLink); IPersistFilePtr file(shell); HRESULT hr; // Load file, resolve link, extract resolved path if (FAILED(hr=file->Load(resolved.c_str(), STGM_READ)) || FAILED(hr=shell->Resolve(nullptr, SLR_NO_UI|SLR_ANY_MATCH)) || FAILED(hr=shell->GetPath((wchar*)resolved, MAX_PATH, nullptr, 0))) throw ComException(HERE, L"Unable to resolve shell link: ", hr); } // Return resolved path return resolved; }
std::pair<std::string, std::string> ShaderManager::FindShaderCode(const std::string& name) const { std::string keyName = StripShaderName(name); std::string fileName = StripShaderName(name, false); // try it in direct source cache auto codeIt = m_codes.find(keyName); if (codeIt != m_codes.end()) { return { keyName, codeIt->second }; } // try it in directories for (const auto& directory : m_directories) { auto filepath = directory / (fileName + ".hlsl"); std::ifstream fs(filepath.c_str()); if (fs.is_open()) { fs.seekg(0, std::ios::end); size_t s = fs.tellg(); fs.seekg(0, std::ios::beg); std::unique_ptr<char[]> content = std::make_unique<char[]>(s + 1); fs.read(content.get(), s); content[s] = '\0'; return { filepath.generic_string(), content.get() }; } } throw FileNotFoundException("Shader was not found.", keyName + "(" + name + " as requested)"); }
void ImageImporter::execute() { if (mFilename == "") throw Exception("No filename was supplied to the ImageImporter"); uchar* convertedPixelData; // Load image from disk using Qt QImage image; reportInfo() << "Trying to load image..." << Reporter::end(); if(!image.load(mFilename.c_str())) { throw FileNotFoundException(mFilename); } reportInfo() << "Loaded image with size " << image.width() << " " << image.height() << Reporter::end(); QImage::Format format; if(mGrayscale) { format = QImage::Format_Grayscale8; } else { format = QImage::Format_RGB888; } QImage convertedImage = image.convertToFormat(format); // Get pixel data convertedPixelData = convertedImage.bits(); Image::pointer output = getOutputData<Image>(); std::cout << "image info" << std::endl; std::cout << convertedImage.width() << std::endl; std::cout << convertedImage.depth() << std::endl; std::cout << convertedImage.bytesPerLine() << std::endl; if(convertedImage.width()*convertedImage.depth()/8 != convertedImage.bytesPerLine()) { const int bytesPerPixel = (convertedImage.depth()/8); std::unique_ptr<uchar[]> fixedPixelData = std::make_unique<uchar[]>(image.width()*image.height()); // Misalignment for(int scanline = 0; scanline < image.height(); ++scanline) { std::memcpy( &fixedPixelData[scanline*image.width()*bytesPerPixel], &convertedPixelData[scanline*convertedImage.bytesPerLine()], image.width()*bytesPerPixel ); } output->create( image.width(), image.height(), TYPE_UINT8, mGrayscale ? 1 : 3, getMainDevice(), fixedPixelData.get() ); } else { output->create( image.width(), image.height(), TYPE_UINT8, mGrayscale ? 1 : 3, getMainDevice(), convertedPixelData ); } }
bool File::open() throw(FileNotFoundException) { if(!exists()) throw FileNotFoundException(path); inStream = new std::ifstream(path, std::ifstream::binary); return this->isOpen(); }
CFile::CFile(const char* fname, const char* mode) { assert(fname != NULL && mode != NULL); m_fp = fopen(fname, mode); if(m_fp == NULL) { throw FileNotFoundException(EXCEPTION_TRACE, "fopen error"); } }
string FileReader::ReadNextData() { if (fileHandle == NULL) throw FileNotFoundException(); // if we have no more data, return empty string if (fgets(buffer, bufferSize, fileHandle) == NULL) return string(); return string(buffer); }
Font* Font::CreateFont(std::string file) { if(exists(file.c_str()) == false) { throw FileNotFoundException(file); } if(std::string(get_extension(file.c_str())).compare("bmp") != 0) { throw TypeNotSupportedException("Non-.bmp"); } return (new Font(file)); }
void Package::addFile(const std::string& input, const std::string& target) { // At the moment, Package just supports adding files to the package. // It does not allow you to modify an existing file. So, if the user // is trying to add an existing file, we return: if (fileIndex.count(target) > 0 || !file.is_open()) { return; } std::ifstream newFile; // The file is open in binary read mode. The pointer is located at the // end of the file. newFile.open(input, std::ios_base::in | std::ios_base::binary | std::ios_base::ate); if (!newFile.is_open()) throw FileNotFoundException(input); // Since the pointer is at the end, tellg() tells us the size of the file. unsigned long size = newFile.tellg(); // We move the pointer at the beginning. newFile.seekg(0); // In the output file, we move the cursor at the end of the file. // We will write the new file there. file.seekg(0, std::ios_base::end); // Write the size of the file. file.write((const char *)&size, SIZE_BYTES); // The filename is going to be stored temporarily in an array. char name[NAME_BYTES]; // We clean the memory. std::memset(name, 0, NAME_BYTES); // Then we copy the name. std::memcpy(name, target.c_str(), target.size()); // And we write it on the file. file.write(name, NAME_BYTES); // Note: writing just file.write(target.c_str(), NAME_BYTES) can give // problems if target.size() < NAME_SIZE because the memory could be dirty. // The pointer is still pointing at the beginning of the file. It's the // right moment to add the new file to the index: fileIndex[std::string(target)] = PackageFileInfo(file.tellp(), size); char byte; // Finally, we copy the contents of the file in the package. while (!newFile.eof()) { newFile.read(&byte, 1); if (newFile.eof()) break; file.write((const char *)&byte, 1); } newFile.close(); file.clear(); }
void Package::create(const std::string& fileName, unsigned int compression) { packageName = fileName; file.open(fileName, std::ios_base::in | std::ios_base::out | std::ios_base::binary | std::ios_base::trunc); if (!file.is_open()) throw FileNotFoundException(fileName); file.write(MAGIC_NUMBER, 4); file.write((char *)&VERSION, 4); file.write((char *)&compression, 4); }
void Package::open(const std::string& fileName) { packageName = fileName; // Open the file en binary read/write mode. file.open(fileName, std::ios_base::in | std::ios_base::out | std::ios_base::binary | std::ios_base::app); if (!file.is_open()) throw FileNotFoundException(fileName); // Instead of loading all files in memory when this method is called, // it just builds an index to be able to load files faster when the user // requests them. // The index relates the filename with its position and size. unsigned long position = 12; // 4 (MAGIC) + 4 (VERSION) + 4 (COMPRESSION) file.seekg(position); // For each file... while (!file.eof()) { unsigned long size; // 1. Get the file size. Note: the size does NOT include the size of the // filename. file.read((char *)&size, SIZE_BYTES); if (file.eof()) break; char name[NAME_BYTES]; // 2. Read the name/path of the file. file.read(name, NAME_BYTES); if (file.eof()) break; // El cursor ahora mismo está en <<position>>, apuntando al inicio // del archivo empaquetado. // 3. Store the position and size of the file. // Note that <<position>> is NOT really pointing to the file but // to the file size. After the file size is the file name. That's // why we must calculate position + SIZE_BYTES + NAME_BYTES to // get the actual file position in our package. fileIndex[std::string(name)] = PackageFileInfo(position + NAME_BYTES + SIZE_BYTES, size); // We move the pointer to the next file header. position += size + SIZE_BYTES + NAME_BYTES; file.seekg(position); } // After reading the file fome error flags can be activated. // If we want to use <<file>> later (for example, with addFile()) those // error flags will give problems. // Calling file.clear() we avoid that. file.clear(); }
/** * * This function will throw an IllegalArgumentException if the file contents cannot be multibyte decoded. */ void PropertiesConfiguration::load(const String &file) { // std::clog << "Loading properties file: " << file << std::endl; std::ifstream input(file.c_str(), std::ifstream::in); // fail() catches File Not Found, bad() does not. ASSERT(!input.fail()); if (input.fail()) throw FileNotFoundException("Failed to open file for read: " + file); parseStream(input); }
void InMemoryStorageBackend::openFileStream(std::ifstream &stream, const std::string &filename, bool isBackupValid) { // TODO: Consider adding exceptions to streams and handling them: // stream.exceptions(std::ifstream::failbit | std::ifstream::badbit); stream.open(filename); if (!stream.is_open()) { throw FileNotFoundException(filename); } m_checksum.compare(stream, filename, isBackupValid); }
Path TemplateCache::resolvePath(const Path& path) const { if ( path.isAbsolute() ) return path; for(std::vector<Path>::const_iterator it = _includePaths.begin(); it != _includePaths.end(); ++it) { Path templatePath(*it, path); File templateFile(templatePath); if ( templateFile.exists() ) { if ( _logger ) { poco_trace_f2(*_logger, "%s template file resolved to %s", path.toString(), templatePath.toString()); } return templatePath; } if ( _logger ) { poco_trace_f1(*_logger, "%s doesn't exist", templatePath.toString()); } } throw FileNotFoundException(path.toString()); }