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);
}
}
}
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));
}
}
void FileImpl::handleLastErrorImpl(const std::string& path)
{
switch (errno)
{
case EIO:
throw IOException(path, errno);
case EPERM:
throw FileAccessDeniedException("insufficient permissions", path, errno);
case EACCES:
throw FileAccessDeniedException(path, errno);
case ENOENT:
throw FileNotFoundException(path, errno);
case ENOTDIR:
throw OpenFileException("not a directory", path, errno);
case EISDIR:
throw OpenFileException("not a file", path, errno);
case EROFS:
throw FileReadOnlyException(path, errno);
case EEXIST:
throw FileExistsException(path, errno);
case ENOSPC:
throw FileException("no space left on device", path, errno);
case EDQUOT:
throw FileException("disk quota exceeded", path, errno);
#if !defined(_AIX)
case ENOTEMPTY:
throw DirectoryNotEmptyException(path, errno);
#endif
case ENAMETOOLONG:
throw PathSyntaxException(path, errno);
case ENFILE:
case EMFILE:
throw FileException("too many open files", path, errno);
default:
throw FileException(Error::getMessage(errno), path, errno);
}
}
void FileImpl::handleLastErrorImpl(const std::string& path)
{
DWORD err = GetLastError();
switch (err)
{
case ERROR_FILE_NOT_FOUND:
throw FileNotFoundException(path, err);
case ERROR_PATH_NOT_FOUND:
case ERROR_BAD_NETPATH:
case ERROR_CANT_RESOLVE_FILENAME:
case ERROR_INVALID_DRIVE:
throw PathNotFoundException(path, err);
case ERROR_ACCESS_DENIED:
throw FileAccessDeniedException(path, err);
case ERROR_ALREADY_EXISTS:
case ERROR_FILE_EXISTS:
throw FileExistsException(path, err);
case ERROR_INVALID_NAME:
case ERROR_DIRECTORY:
case ERROR_FILENAME_EXCED_RANGE:
case ERROR_BAD_PATHNAME:
throw PathSyntaxException(path, err);
case ERROR_FILE_READ_ONLY:
throw FileReadOnlyException(path, err);
case ERROR_CANNOT_MAKE:
throw CreateFileException(path, err);
case ERROR_DIR_NOT_EMPTY:
throw FileException("directory not empty", path, err);
case ERROR_WRITE_FAULT:
throw WriteFileException(path, err);
case ERROR_READ_FAULT:
throw ReadFileException(path, err);
case ERROR_SHARING_VIOLATION:
throw FileException("sharing violation", path, err);
case ERROR_LOCK_VIOLATION:
throw FileException("lock violation", path, err);
case ERROR_HANDLE_EOF:
throw ReadFileException("EOF reached", path, err);
case ERROR_HANDLE_DISK_FULL:
case ERROR_DISK_FULL:
throw WriteFileException("disk is full", path, err);
case ERROR_NEGATIVE_SEEK:
throw FileException("negative seek", path, err);
default:
throw FileException(path, err);
}
}