C/C++文件监控

已于 2023-03-16 14:36:42 修改
阅读量1.6k 收藏 10
点赞数
分类专栏： Windows编程 文章标签： c++ c语言
于 2022-11-15 10:24:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31629063/article/details/127860726
版权 
#ifndef __FILE_GUARD_H__
#define __FILE_GUARD_H__

#include <functional>
#include <algorithm>
#include <thread>
#include <string>
#include <vector>
#include <map>

class FileGuard
{
public:
	//文件动作
	enum Action
	{
		//添加动作
		ADDED = 0x00000001,

		//删除动作
		REMOVED,

		//修改动作
		MODIFIED,

		//重命名旧名称动作
		RENAMED_OLD_NAME,

		//重命名新名称动作
		RENAMED_NEW_NAME,
	};

	/*
	* @brief 构造
	*/
	FileGuard();

	/*
	* @brief 析构
	*/
	~FileGuard();

	/*
	* @brief 存在路径
	* @param[in] path 路径
	* @retval true 存在
	* @retval false 不存在
	*/
	bool existPath(const std::string& path) const;

	/*
	* @brief 添加路径
	* @param[in] path 路径(*代表监控所有磁盘)(&代表监控除系统盘以外的磁盘)
	* @param[in] subpath 是否监控子路径
	* @retval true 成功
	* @retval false 失败
	*/
	bool addPath(const std::string& path, bool subpath = true);

	/*
	* @brief 删除路径
	* @param[in] path 路径
	* @return void
	*/
	void removePath(const std::string& path);

	/*
	* @brief 清空路径
	* @return void
	*/
	void clearPaths();

	/*
	* @brief 获取路径
	* @return (路径,是否监控子路径)
	*/
	std::map<std::string, bool> getPaths() const;

	/*
	* @brief 启动
	* @return void
	*/
	void start();

	/*
	* @brief 停止
	* @return void
	*/
	void stop();

	/*
	* @brief 重新开始监控
	* @retval true 成功
	* @retval false 失败
	*/
	bool restart();

	/*
	* @brief 是否启动
	* @retval true 已启动
	* @retval false 未启动
	*/
	bool isStart() const;

	/*
	* @brief 获取最终错误
	* @return 最终错误
	*/
	const char* getLastError() const;

	/*
	* @brief 添加后缀
	* @param[in] suffix 后缀名(.*或*代表所有)
	* @return void
	*/
	void addSuffix(const std::string& suffix);

	/*
	* @brief 添加后缀
	* @param[in] suffixes 后缀名
	* @return void
	*/
	void addSuffixes(const std::vector<std::string>& suffixes);

	/*
	* @brief 删除后缀
	* @param[in] suffix 后缀名
	* @return void
	*/
	void removeSuffix(const std::string& suffix);

	/*
	* @brief 删除后缀
	* @param[in] suffixes 后缀名
	* @return void
	*/
	void removeSuffixes(const std::vector<std::string>& suffixes);

	/*
	* @brief 清空后缀
	* @return void
	*/
	void clearSuffixes();

	/*
	* @brief 获取后缀
	* @return void
	*/
	std::vector<std::string> getSuffixes() const;

	//改变回调
	std::function<void(uint32_t action, const char* file)> onChanged = nullptr;

	//错误回调
	std::function<void(uint32_t error, const char* path)> onError = nullptr;

	//启动回调
	std::function<void(uint32_t thread, const char* path)> onStarted = nullptr;

	//停止回调
	std::function<void(uint32_t thread, const char* path)> onStopped = nullptr;

	//所有磁盘的路径
	static const char* const ALL_DISK_PATHS;

	//除系统以外的磁盘路径
	static const char* const EXCEPT_SYSTEM_DISK_PATHS;

	//所有后缀名
	static const char* const ALL_SUFFIXES;
protected:
	/*
	* @brief 设置最终错误
	* @param[in] fmt 格式化字符串
	* @param[in] ... 可变参数
	* @return void
	*/
	void setLastError(const char* fmt, ...);

private:
	
	//参数
	struct Arg
	{
		std::string path;
		bool subpath;
		char* buffer;
		static const size_t size = 1048576;
		void* file;
		void* wevent;
		void* revent;
		void* lapped;
		bool quit;
		unsigned long thread;
		unsigned long ecode;
		char error[256];

		Arg();

		~Arg();

		Arg(const Arg& o);

		Arg& operator=(const Arg& o);

		//创建
		bool create(const std::string& path, bool subpath);

		//释放
		void release();

		//等待
		void wait(size_t timeout = (size_t)-1) const;

		//退出
		void exit() const;
	};

	//参数
	std::vector<Arg> m_args;

	//后缀
	std::vector<std::string> m_suffixes;

	//错误信息
	std::string m_error = "未知错误";

	//是否启动
	bool m_start = false;
};

#define FILE_GUARD_C_API
#if defined(FILE_GUARD_C_API)

//#define FILE_GUARD_BUILD_DLL
#if defined(FILE_GUARD_BUILD_DLL)
#define FILE_GUARD_DLL_EXPORT __declspec(dllexport)
#else
#define FILE_GUARD_DLL_EXPORT
#endif

#include <stdbool.h>
#include <stdint.h>

enum file_guard_action
{
	//添加动作
	added_action = 0x00000001,

	//删除动作
	removed_action,

	//修改动作
	modified_action,

	//重命名旧名称动作
	renamed_old_name_action,

	//重命名新名称动作
	renamed_new_name_action
};

struct file_guard_path
{
	char path[512];
	bool subpath;
};

#if defined(__cplusplus)
extern "C" {
#endif // !__cplusplus

	FILE_GUARD_DLL_EXPORT void* file_guard_initialize();

	FILE_GUARD_DLL_EXPORT void file_guard_uninitialize(void* guard);

	FILE_GUARD_DLL_EXPORT bool file_guard_exist_path(void* guard, const char* path);

	FILE_GUARD_DLL_EXPORT bool file_guard_add_path(void* guard, const char* path, bool subpath);

	FILE_GUARD_DLL_EXPORT void file_guard_remove_path(void* guard, const char* path);

	FILE_GUARD_DLL_EXPORT void file_guard_clear_paths(void* guard);

	FILE_GUARD_DLL_EXPORT int file_guard_get_paths(void* guard, struct file_guard_path* path, int size);

	FILE_GUARD_DLL_EXPORT void file_guard_set_on_changed_callback(void* guard,
		void (*callback)(uint32_t action, const char* file, void* user), void* user);

	FILE_GUARD_DLL_EXPORT void file_guard_set_on_started_callback(void* guard,
		void (*callback)(uint32_t thread, const char* path, void* user), void* user);

	FILE_GUARD_DLL_EXPORT void file_guard_set_on_stopped_callback(void* guard, 
		void (*callback)(uint32_t thread, const char* path, void* user), void* user);

	FILE_GUARD_DLL_EXPORT void file_guard_set_on_error_callback(void* guard,
		void (*callback)(uint32_t error, const char* path, void* user), void* user);

	FILE_GUARD_DLL_EXPORT void file_guard_start(void* guard);

	FILE_GUARD_DLL_EXPORT void file_guard_start_ex(void* guard, void* user,
		void (*on_changed)(uint32_t action, const char* file, void* user),
		void (*on_stared)(uint32_t thread, const char* path, void* user),
		void (*on_stopped)(uint32_t thread, const char* path, void* user),
		void (*on_error)(uint32_t error, const char* path, void* user));

	FILE_GUARD_DLL_EXPORT void file_guard_stop(void* guard);

	FILE_GUARD_DLL_EXPORT bool file_guard_restart(void* guard);

	FILE_GUARD_DLL_EXPORT bool file_guard_is_start(void* guard);

	FILE_GUARD_DLL_EXPORT void file_guard_get_error(void* guard, char* error, int size);

	FILE_GUARD_DLL_EXPORT void file_guard_add_suffix(void* guard, const char* suffix);

	FILE_GUARD_DLL_EXPORT void file_guard_remove_suffix(void* guard, const char* suffix);

	FILE_GUARD_DLL_EXPORT void file_guard_clear_suffixes(void* gurad);

	FILE_GUARD_DLL_EXPORT int file_guard_get_suffixes(void* guard, char (*suffixes)[256], int size);

#if defined(__cplusplus)
}
#endif // !__cplusplus
#endif // !FILE_GUARD_C_API
#endif // !__FILE_GUARD_H__

#include "FileGuard.h"
#include <Windows.h>
#include <io.h>

#if defined(IDEBUG)
#define print(fmt, ...)\
do { \
	char buffer[512] = { 0 };\
	snprintf(buffer, sizeof(buffer), fmt, ##__VA_ARGS__);\
	printf(fmt, ##__VA_ARGS__);\
	OutputDebugString(buffer);\
}while(0);
#else
#define print(fmt, ...)
#endif

static std::string unicode2ascii(const std::wstring& str)
{
	int size = WideCharToMultiByte(CP_ACP, 0, str.c_str(), (int)str.size(), 0, 0, 0, 0) + 1;
	std::unique_ptr<char> buffer(new char[size]);
	WideCharToMultiByte(CP_ACP, 0, str.c_str(), (int)str.size(), buffer.get(), size, 0, 0);
	buffer.get()[size - 1] = '\0';
	return std::string(buffer.get());
}

const char* const FileGuard::ALL_DISK_PATHS = "*";

const char* const FileGuard::EXCEPT_SYSTEM_DISK_PATHS = "&";

const char* const FileGuard::ALL_SUFFIXES = ".*";

FileGuard::FileGuard()
{

}

FileGuard::~FileGuard()
{
	stop();
	clearPaths();
}

bool FileGuard::existPath(const std::string& path) const
{
	bool exist = false;
	for (const auto& x : m_args)
	{
		if (x.path == path)
		{
			exist = true;
			break;
		}
	}
	return exist;
}

bool FileGuard::addPath(const std::string& path, bool subpath)
{
	bool result = false, success = true;
	do
	{
		if (_access(path.c_str(), 0) == -1 && path != ALL_DISK_PATHS && path != EXCEPT_SYSTEM_DISK_PATHS)
		{
			setLastError("%s路径不存在", path.c_str());
			break;
		}

		std::vector<std::string> paths;
		if (path == ALL_DISK_PATHS || path == EXCEPT_SYSTEM_DISK_PATHS)
		{
			auto drives = GetLogicalDrives();
			char volume = 'A';
			while (drives)
			{
				if (drives & 1)
				{
					paths.push_back(std::string(1, volume) + ":\\");
				}
				volume++;
				drives >>= 1;
			}

			//排除无法监控的盘符
			std::vector<std::string> temp;
			for (const auto& x : paths)
			{
				uint32_t type = GetDriveType(x.c_str());
				if (type == DRIVE_UNKNOWN ||
					type == DRIVE_NO_ROOT_DIR ||
					type == DRIVE_REMOTE ||
					type == DRIVE_CDROM)
				{
					continue;
				}
				temp.push_back(x);
			}

			paths = temp;

			if (path == EXCEPT_SYSTEM_DISK_PATHS)
			{
				char dir[512] = { 0 };
				if (!GetWindowsDirectoryA(dir, sizeof(dir)))
				{
					setLastError("获取系统目录失败,错误代码:%lu", GetLastError());
					break;
				}

				const std::string win(dir, 3);
				for (auto iter = paths.begin(); iter != paths.end(); ++iter)
				{
					if (*iter == win)
					{
						paths.erase(iter);
						break;
					}
				}
			}
		}
		else
		{
			std::string str = path;
			char c = str.at(str.length() - 1);
			if (c != '\\' && c != '/')
			{
				str.append("\\");
			}

			for (auto& x : str)
			{
				if (x == '/')
				{
					x = '\\';
				}
			}
			paths.push_back(str);
		}

		for (const auto& x : paths)
		{
			if (!existPath(x))
			{
				Arg arg;
				if (!arg.create(x, subpath))
				{
					success = false;
					setLastError(arg.error);
					if (path == ALL_DISK_PATHS || path == EXCEPT_SYSTEM_DISK_PATHS)
					{
						continue;
					}
					break;
				}
				m_args.push_back(arg);
			}
		}

		if (!success)
		{
			for (const auto& x : paths)
			{
				removePath(x);
			}
			break;
		}

		result = true;
	} while (false);
	return result;
}

void FileGuard::removePath(const std::string& path)
{
	for (auto iter = m_args.begin(); iter != m_args.end(); ++iter)
	{
		if (iter->path == path)
		{
			iter->release();
			m_args.erase(iter);
			break;
		}
	}
}

void FileGuard::clearPaths()
{
	for (auto iter = m_args.begin(); iter != m_args.end(); ++iter)
	{
		iter->release();
	}
	m_args.clear();
}

std::map<std::string, bool> FileGuard::getPaths() const
{
	std::map<std::string, bool> map;
	for (const auto& x : m_args)
	{
		map.insert(std::make_pair(x.path, x.subpath));
	}
	return map;
}

void FileGuard::start()
{
	if (m_suffixes.size() == 1 && m_suffixes[0] == ".*")
	{
		m_suffixes.clear();
	}

	for (auto& x : m_args)
	{
		if (!x.quit)
		{
			continue;
		}

		std::thread([&](Arg* arg)->void
			{
				arg->quit = false;
				arg->thread = GetCurrentThreadId();
				if (onStarted)
				{
					onStarted(arg->thread, arg->path.c_str());
				}

				bool success = true;
				DWORD bytes = 0, offset = 0, error = 0;
				OVERLAPPED lapped = { 0 };
				arg->lapped = static_cast<void*>(&lapped);
				lapped.hEvent = arg->revent;
				do
				{
					memset(arg->buffer, 0, arg->size);
					print("thread %lu,path %s,start ReadDirectoryChangesW\n", arg->thread, arg->path.c_str());
					if (ReadDirectoryChangesW(arg->file,
						arg->buffer,
						arg->size,
						arg->subpath,
						FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE,
						&bytes,
						&lapped,
						nullptr))
					{
						print("thread %lu,path %s,start GetOverlappedResult\n", arg->thread, arg->path.c_str());
						if (GetOverlappedResult(arg->file, &lapped, &bytes, TRUE))
						{
							FILE_NOTIFY_INFORMATION* info = reinterpret_cast<FILE_NOTIFY_INFORMATION*>(arg->buffer);
							do
							{
								if (onChanged)
								{
									std::wstring ws(info->FileName, info->FileNameLength / sizeof(wchar_t));
									std::string s(arg->path + unicode2ascii(ws));

									if (!m_suffixes.empty())
									{
										for (size_t i = 0; i < m_suffixes.size(); ++i)
										{
											size_t npos = s.find_last_of('.');
											if (npos != std::string::npos)
											{
												std::string suffix = s.substr(npos);
												std::transform(suffix.begin(), suffix.end(), suffix.begin(), std::tolower);
												if (suffix == m_suffixes[i])
												{
													onChanged(info->Action, s.c_str());
													break;
												}
											}
										}
									}
									else
									{
										onChanged(info->Action, s.c_str());
									}
								}
								offset = info->NextEntryOffset;
								info = reinterpret_cast<FILE_NOTIFY_INFORMATION*>(reinterpret_cast<uint8_t*>(info) + offset);
							} while (offset);
						}
						else
						{
							arg->ecode = GetLastError();
							print("thread %lu,path %s,GetOverlappedResult false,error %lu\n",
								arg->thread, arg->path.c_str(), arg->ecode);
							if (arg->ecode == ERROR_OPERATION_ABORTED)
							{
								arg->ecode = 0;
								break;
							}
							success = false;
						}

						print("thread %lu,path %s,start ResetEvent\n", arg->thread, arg->path.c_str());
						if (!ResetEvent(lapped.hEvent))
						{
							arg->ecode = GetLastError();
							print("thread %lu,path %s,ResetEvent false,error %lu\n",
								arg->thread, arg->path.c_str(), arg->ecode);
							success = false;
							break;
						}
					}
					else
					{
						arg->ecode = GetLastError();
						print("thread %lu,path %s,ReadDirectoryChangeW false,error %lu\n",
							arg->thread, arg->path.c_str(), arg->ecode);
						success = false;
						break;
					}
					print("thread %lu,path %s,start WaitForSingleObject\n", arg->thread, arg->path.c_str());
					error = WaitForSingleObject(arg->wevent, 0);
				} while (error == WAIT_TIMEOUT);

				if (onError && !success)
				{
					onError(arg->ecode, arg->path.c_str());
				}

				if (onStopped)
				{
					onStopped(arg->thread, arg->path.c_str());
				}
				print("thread %lu,path %s,thread exit\n", arg->thread, arg->path.c_str());
				arg->quit = true;
			}, &x).detach();
	}
	m_start = true;
}

void FileGuard::stop()
{
	m_start = false;
	for (auto& x : m_args)
	{
		x.exit();
		x.wait();
	}
}

bool FileGuard::restart()
{
	stop();
	std::vector<Arg> args = m_args;
	clearPaths();
	for (const auto& x : args)
	{
		if (!addPath(x.path, x.subpath))
		{
			return false;
		}
	}
	start();
	return true;
}

bool FileGuard::isStart() const
{
	return m_start;
}

const char* FileGuard::getLastError() const
{
	return m_error.c_str();
}

void FileGuard::addSuffix(const std::string& suffix)
{
	std::string data(suffix);
	std::transform(data.begin(), data.end(), data.begin(), std::tolower);

	bool find = false, add = false;
	
	for (const auto& x : m_suffixes)
	{
		if (x == data)
		{
			find = true;
			break;
		}
	}

	if (!find)
	{
		if (data.find_last_of('.') == std::string::npos)
		{
			add = true;
		}
		m_suffixes.push_back(add ? "." + data : data);
	}

	for (const auto& x : m_suffixes)
	{
		if (x == ALL_SUFFIXES || std::string(".") + x == ALL_SUFFIXES)
		{
			m_suffixes.clear();
			m_suffixes.push_back(ALL_SUFFIXES);
			break;
		}
	}
}

void FileGuard::addSuffixes(const std::vector<std::string>& suffixes)
{
	m_suffixes = suffixes;
}

void FileGuard::removeSuffix(const std::string& suffix)
{
	std::string data(suffix);
	std::transform(data.begin(), data.end(), data.begin(), std::tolower);

	for (auto iter = m_suffixes.begin(); iter != m_suffixes.end(); ++iter)
	{
		if (*iter == data)
		{
			m_suffixes.erase(iter);
			break;
		}
	}
}

void FileGuard::removeSuffixes(const std::vector<std::string>& suffixes)
{
	for (auto iter = suffixes.begin(); iter != suffixes.end(); ++iter)
	{
		std::string data(*iter);
		std::transform(data.begin(), data.end(), data.begin(), std::tolower);
		m_suffixes.erase(std::remove(m_suffixes.begin(), m_suffixes.end(), data), m_suffixes.end());
	}
}

void FileGuard::clearSuffixes()
{
	m_suffixes.clear();
}

std::vector<std::string> FileGuard::getSuffixes() const
{
	return m_suffixes;
}

void FileGuard::setLastError(const char* fmt, ...)
{
	char buff[512] = { 0 };
	va_list ap;
	va_start(ap, fmt);
	vsnprintf(buff, sizeof(buff), fmt, ap);
	va_end(ap);
	m_error = buff;
}

FileGuard::Arg::Arg()
	:subpath(false),
	buffer(nullptr),
	file(INVALID_HANDLE_VALUE),
	wevent(nullptr),
	revent(nullptr),
	lapped(nullptr),
	quit(true),
	thread(0),
	ecode(0),
	error{ 0 }
{

}

FileGuard::Arg::~Arg()
{
	if (buffer)
	{
		delete[] buffer;
		buffer = nullptr;
	}
}

FileGuard::Arg::Arg(const Arg& o)
{
	path = o.path;
	subpath = o.subpath;
	if (o.buffer)
	{
		buffer = new char[o.size];
		memcpy(buffer, o.buffer, o.size);
	}
	file = o.file;
	wevent = o.wevent;
	revent = o.revent;
	lapped = o.lapped;
	quit = o.quit;
	thread = o.thread;
	ecode = o.ecode;
	memcpy(error, o.error, sizeof(error));
}

FileGuard::Arg& FileGuard::Arg::operator=(const Arg& o)
{
	if (!memcmp(this, &o, sizeof(Arg)))
	{
		return *this;
	}

	path = o.path;
	subpath = o.subpath;
	if (o.buffer)
	{
		buffer = new char[o.size];
		memcpy(buffer, o.buffer, o.size);
	}
	file = o.file;
	wevent = o.wevent;
	revent = o.revent;
	lapped = o.lapped;
	quit = o.quit;
	thread = o.thread;
	ecode = o.ecode;
	memcpy(error, o.error, sizeof(error));
	return *this;
}

bool FileGuard::Arg::create(const std::string& path, bool subpath)
{
	bool result = false;
	do
	{
		const char c = path.at(path.length() - 1);
		this->path = (c != '\\' && c != '/') ? (path + "\\") : (path);

		for (auto& x : this->path)
		{
			if (x == '/')
				x = '\\';
		}

		this->subpath = subpath;

		file = CreateFileA(path.c_str(),
			GENERIC_READ | GENERIC_WRITE | FILE_LIST_DIRECTORY,
			FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
			nullptr,
			OPEN_EXISTING,
			FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
			nullptr);
		if (file == INVALID_HANDLE_VALUE)
		{
			sprintf_s(error, "获取%s路径句柄失败,错误代码:%lu", path.c_str(), ::GetLastError());
			break;
		}

		wevent = CreateEventA(nullptr, true, false, nullptr);
		if (wevent == nullptr)
		{
			CloseHandle(file);
			file = INVALID_HANDLE_VALUE;
			sprintf_s(error, "创建%s路径事件失败,错误代码:%lu", path.c_str(), ::GetLastError());
			break;
		}

		revent = CreateEventA(nullptr, true, false, nullptr);
		if (revent == nullptr)
		{
			CloseHandle(file);
			file = INVALID_HANDLE_VALUE;
			CloseHandle(wevent);
			wevent = nullptr;
			sprintf_s(error, "创建%s路径折叠失败,错误代码:%lu", path.c_str(), ::GetLastError());
			break;
		}

		buffer = new char[size];
		if (buffer == nullptr)
		{
			CloseHandle(file);
			file = INVALID_HANDLE_VALUE;
			CloseHandle(wevent);
			wevent = nullptr;
			CloseHandle(revent);
			revent = nullptr;
			sprintf_s(error, "创建%s路径缓冲区失败,内存不足", path.c_str());
			break;
		}
		memset(buffer, 0, size);
		result = true;
	} while (false);
	return result;
}

void FileGuard::Arg::release()
{
	if (file != INVALID_HANDLE_VALUE)
	{
		CloseHandle(file);
		file = INVALID_HANDLE_VALUE;
	}

	if (wevent)
	{
		CloseHandle(wevent);
		wevent = nullptr;
	}

	if (revent)
	{
		CloseHandle(revent);
		revent = nullptr;
	}

	if (lapped)
	{
		lapped = nullptr;
	}

	if (buffer)
	{
		delete[] buffer;
		buffer = nullptr;
	}
}

void FileGuard::Arg::wait(size_t timeout) const
{
	auto tick = GetTickCount64();
	while (!quit)
	{
		if (GetTickCount64() - tick > timeout)
		{
			break;
		}
	}
}

void FileGuard::Arg::exit() const
{
	if (file != INVALID_HANDLE_VALUE)
	{
		CancelIoEx(file, static_cast<LPOVERLAPPED>(lapped));
	}
}

#if defined(FILE_GUARD_C_API)

#define get_guard(x) ((FileGuard*)(x))

void* file_guard_initialize()
{
	return new FileGuard;
}

void file_guard_uninitialize(void* guard)
{
	if (guard)
	{
		delete static_cast<FileGuard*>(guard);
	}
}

bool file_guard_exist_path(void* guard, const char* path)
{
	return get_guard(guard)->existPath(path);
}

bool file_guard_add_path(void* guard, const char* path, bool subpath)
{
	return get_guard(guard)->addPath(path, subpath);
}

void file_guard_remove_path(void* guard, const char* path)
{
	get_guard(guard)->removePath(path);
}

void file_guard_clear_paths(void* guard)
{
	get_guard(guard)->clearPaths();
}

int file_guard_get_paths(void* guard, file_guard_path* path, int size)
{
	auto map = get_guard(guard)->getPaths();
	int index = 0;
	for (const auto& x : map)
	{
		strcpy_s(path[index].path, x.first.c_str());
		path[index].subpath = x.second;
		if (index + 1 == size)
		{
			break;
		}
	}
	return index;
}

void file_guard_set_on_changed_callback(void* guard, void(*callback)(uint32_t action, const char* file, void* user), void* user)
{
	get_guard(guard)->onChanged = [user, callback](uint32_t action, const char* file) {
		callback(action, file, user);
	};
}

void file_guard_set_on_started_callback(void* guard, void(*callback)(uint32_t thread, const char* path, void* user), void* user)
{
	get_guard(guard)->onStarted = [user, callback](uint32_t thread, const char* path) {
		callback(thread, path, user);
	};
}

void file_guard_set_on_stopped_callback(void* guard, void(*callback)(uint32_t thread, const char* path, void* user), void* user)
{
	get_guard(guard)->onStopped = [user, callback](uint32_t thread, const char* path) {
		callback(thread, path, user);
	};
}

void file_guard_set_on_error_callback(void* guard, void(*callback)(uint32_t error, const char* path, void* user), void* user)
{
	get_guard(guard)->onError = [user, callback](uint32_t error, const char* path) {
		callback(error, path, user);
	};
}

void file_guard_start(void* guard)
{
	get_guard(guard)->start();
}

void file_guard_start_ex(void* guard, void* user,
	void(*on_changed)(uint32_t action, const char* file, void* user),
	void(*on_started)(uint32_t thread, const char* path, void* user),
	void(*on_stopped)(uint32_t thread, const char* path, void* user),
	void(*on_error)(uint32_t error, const char* path, void* user))
{
	get_guard(guard)->onChanged = [user, on_changed](uint32_t action, const char* file) {
		on_changed(action, file, user);
	};

	get_guard(guard)->onStarted = [user, on_started](uint32_t thread, const char* path) {
		on_started(thread, path, user);
	};

	get_guard(guard)->onStopped = [user, on_stopped](uint32_t thread, const char* path) {
		on_stopped(thread, path, user);
	};

	get_guard(guard)->onError = [user, on_error](uint32_t error, const char* path) {
		on_error(error, path, user);
	};

	get_guard(guard)->start();
}

void file_guard_stop(void* guard)
{
	get_guard(guard)->stop();
}

bool file_guard_restart(void* guard)
{
	return get_guard(guard)->restart();
}

bool file_guard_is_start(void* guard)
{
	return get_guard(guard)->isStart();
}

void file_guard_get_error(void* guard, char* error, int size)
{
	strncpy_s(error, size, get_guard(guard)->getLastError(), _TRUNCATE);
}

void file_guard_add_suffix(void* guard, const char* suffix)
{
	get_guard(guard)->addSuffix(suffix);
}

void file_guard_remove_suffix(void* guard, const char* suffix)
{
	get_guard(guard)->removeSuffix(suffix);
}

void file_guard_clear_suffixes(void* guard)
{
	get_guard(guard)->clearSuffixes();
}

int file_guard_get_suffixes(void* guard, char(*suffixes)[256], int size)
{
	auto datas = get_guard(guard)->getSuffixes();
	size_t i = 0;
	for (; i < datas.size(); ++i)
	{
		strcpy_s(suffixes[i], datas[i].c_str());
		if (i == size - 1)
		{
			i++;
			break;
		}
	}
	return (int)i;
}

#endif // !FILE_GUARD_BUILD_DLL


//测试代码
#include "FileGuard.h"
#include <stdio.h>

//C++风格
#if defined(__cplusplus)
int main()
{
	FileGuard guard;
	guard.addPath("*");//*代表监控当前计算机中,所有的磁盘
	guard.onChanged = [](uint32_t action, const char* file) {
		switch (action)
		{
			case FileGuard::Action::ADDED:
				printf("onChanged-> 文件[%s]添加动作\n", file);
				break;
			case FileGuard::Action::MODIFIED:
				printf("onChanged-> 文件[%s]修改动作\n", file);
				break;;
			case FileGuard::Action::REMOVED:
				printf("onChanged-> 文件[%s]移除动作\n", file);
				break;
			case FileGuard::Action::RENAMED_OLD_NAME:
				printf("onChanged-> 文件[%s]改名动作(旧)\n", file);
				break;
			case FileGuard::Action::RENAMED_NEW_NAME:
				printf("onChanged-> 文件[%s]改名动作(新)\n", file);
				break;
		default:
			break;
		}
	};

	guard.onError = [](uint32_t error, const char* path) {
		printf("onError-> 错误代码:%lu,路径:%s\n", error, path);
	};

	guard.onExit = [](uint32_t thread, const char* path) {
		printf("onExit-> 线程:%lu,路径:%s\n", thread, path);
	};

	guard.start();
	getchar();
	guard.stop();

	return 0;
}
#else
//C风格,如果使用C语言进行操作,需要将FileGuard编译为静态库或动态库,
//头文件中,删除C++的声明.因为是用C++写的,外面套了一层C语言的壳进行封装.
#pragma comment(lib, "FileGuard.lib")
void file_guard_on_changed(uint32_t action, const char* file, void* user)
{
	switch (action)
	{
		case FileGuard::Action::ADDED:
			printf("on_changed-> 文件[%s]添加动作\n", file);
			break;
		case FileGuard::Action::MODIFIED:
			printf("on_changed-> 文件[%s]修改动作\n", file);
			break;;
		case FileGuard::Action::REMOVED:
			printf("on_changed-> 文件[%s]移除动作\n", file);
			break;
		case FileGuard::Action::RENAMED_OLD_NAME:
			printf("on_changed-> 文件[%s]改名动作(旧)\n", file);
			break;
		case FileGuard::Action::RENAMED_NEW_NAME:
			printf("on_changed-> 文件[%s]改名动作(新)\n", file);
			break;
		default:
		break;
	}
}

void file_guard_on_exit(uint32_t thread, const char* path, void* user)
{
	printf("on_exit-> 路径%s,线程%lu\n", path, thread);
}

void file_guard_on_error(uint32_t error, const char* path, void* user)
{
	printf("on_error-> 路径%s,错误代码%lu\n", path, error);
}

int main()
{
    void* guard = file_guard_initialize();
	
	file_guard_add_path(guard, "*", true);//*代表监控当前计算机中,所有的磁盘
	
	file_guard_start(guard, NULL,
                    file_guard_on_changed,
                    file_guard_on_exit,
                    file_guard_on_error);
	
	getchar();
	file_guard_stop(guard);
	file_guard_uninitialize(guard);

    return 0;
}
#endif // !__cplusplus

项目展示:

通用DLL下载链接地址:

C/C++文件监控通用DLL-C++文档类资源-CSDN文库

夜晚不懂天的白
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++之监控文件是否被修改
草上爬的博客
02-04 3046
软件开发过程中经常会用到配置文件，某些应用场景要求在软件运行时动态修改配置文件，此时就需要监控配置文件是否被修改，如果修改了，重新加载。这里config.txt和可执行文件同一目录，每次修改config.txt，就会打印File changed。
c++ 在windwos上创建盘符，并且，监控盘符里面任一文件的变动事件
天才
07-23 2518
#include "stdafx.h" #include "device.h" #include #include #define  MAX_PATH 1024 char * setw(int w) {     return "h"; } MyClass::MyClass(string _root_name,string _real_path) {   
QT监视文件和目录变化（QFileSystemWatcher的使用）
01-06
QFileSystemWatcher的使用程序效果展示 程序 .h #ifndef WIDGET_H #define WIDGET_H #include #include #include class Widget : public QWidget { Q_OBJECT public: Widget(QWidget *parent = 0); ~Widget(); public slots: void directroyChanged(QString path); private: QLabel *pathLabel; QFileSystemW
C#中监控文件夹变动的利器：FileSystemWatcher类
weixin_44837958的博客
03-14 697
类提供了一个异步机制来监视文件系统的更改。Created：当在指定目录中创建新文件或目录时发生。Deleted：当在指定目录中删除文件或目录时发生。Changed：当在指定目录中更改文件时发生。Renamed：当在指定目录中重命名文件或目录时发生。类是一个强大且易用的工具，用于在C#中监控文件夹中的文件变动。通过合理地使用它，你可以实现自动备份、日志记录、实时同步等功能。在使用时，请确保处理好事件，并考虑到性能和资源使用的因素。
C/C++获取Windows的文件占用大小
MUTONG的博客
04-02 354
为了在 C++ 中递归计算文件夹的大小，使用 Windows API 中的。C/C++获取Windows的文件占用大小。C/C++获取Windows的文件占用大小。
windows下c++ 目录文件的监控--ReadDirectoryChangesW函数的使用
841451955的博客
06-15 3846
最近在做一个项目，其中涉及到监控指定目录下所有文件和子目录内的修改信息。经过一番努力，总算实现这一功能，在此特别感谢那些帮助过我的朋友和同事们。今天整理一下这几天的收获，列出相关的知识点，供后来者参考。1.FindFirstChangeNotification()函数：功能：创建一个改变通知句柄，并设置通知条件，即发生某种修改时，该通知句柄将被促发生效。该函数仅仅负责对文件修改作出通知，并不记录和...
C++学习笔记（6）常用程序功能实现-目录监控
tlzxp的博客
03-25 832
目录监控功能主要用在系统间数据迁移时观察缓存目录文件变化的场景，结合文件类型检测、病毒检测、安全文件传输等功能可以构建一个完整的系统文件安全入出的解决方案。该功能有多种实现方式，下面我们介绍两种不同方式来实现该功能。
c#/c++ 通过系统api监视文件变化的问题
nightwizard2030的博客
07-04 1049
所以在dotnet上，实际上并没有使用这种方式，而是通过ReadDirectoryChangesW 去实现的，这种基于buffer的，理论不溢出，就不会出现丢失的情况。总结一下，使用fsw千万需要小心，在win和linux上的表现是不同的，win上可以放心用，linux上可能会漏文件，需要在自己场景下特定的时间点进行检测。所以在linux下，我的那种场景，刚好就触发了这个问题，这种是基于inotify的缺陷，因为这玩意也没buffer，我猜测与上面c++的demo出现的问题类似。
C/C++ 实现目录监视器（详解版）
余识-
05-27 3654
VC++ 详解一个目录监视器的实习过程
C++监测文件夹变化
热门推荐
Barry的博客
11-30 1万+
转自：http://blog.csdn.net/zhihu008/article/details/7995829 FileSystemWatcher.h #ifndef __FILESYSTEMWATCHER_HPP__ #define __FILESYSTEMWATCHER_HPP__ #if(_WIN32_WINNT < 0x0400) #define _WIN32_WINNT
linux下c++实现文件监控
onejune的博客
08-18 5308
linux下文件监控
C/C++文件监控通用DLL
11-17
文件监控DLL,可供C/C++,Python,C#,Java,Lua,VB...编程语言调用,只要是在Windows下平台的基本上都可以使用.
监视文件和记录，或在它们发生更改时触发操作。-C/C++开发
05-26
监视人一种文件监视服务。 用途监视员的存在是为了监视文件并记录文件实际更改的时间。 匹配文件更改时，它还可以触发操作（例如重建资产）。 Documentati Watchman文件监视服务。 用途监视员的存在是为了监视文件并...
vs2008编写的C/C++U盘监控程序
10-30
vs2008编写的C/C++U盘监控程序，帮你了解vs2008的使用方法和c/c++的开发技术.
基于C/C++的xrkmonitor国产开源云监控系统设计源码
最新发布
04-18
本项目是基于C/C++的xrkmonitor国产开源云监控系统设计源码，包含1094个文件，其中主要包含171个h头文件，149个cpp源代码文件等。系统采用了C/C++编程语言，实现了业务监控点监控、日志监控、数据可视化以及监控告警...
c++文件监控之FileSystemWatcher
12-31
具体代码如下： #using #include using namespace std; using namespace System; using namespace System::IO; using namespace System::Security::Permissions;...public ref class Watcher ... static void OnChanged...
Hook 技术初探
Android 开发架构
04-27 710
一名优秀的Android开发，需要一份完备的 知识体系，在这里，让我们一起成长为自己所想的那样~。 Hook 技术 Hook 是钩子的意思，在 Android 操作系统中系统维护着自己的一套事件分发机制。应用程序，包括应用触发事件和后台逻辑处理，也是根据事件流程一步步地向下执行。 而钩子的意思，就是在事件传送到终点前截获监控事件的传输，像个钩子钩上事件一样，并且能够在钩上事件时，处理一些...
C＋＋Builder 资料库
hemeinvyiqiluoben的专栏
09-02 4738
转自：  1.怎样在C＋＋Builder中创建使用DLL  2.用C++Bulider在WIN.INI中保存信息  3.如何在C＋＋Builder中检测硬件  4.C++Builder如何响应消息及自定义消息  5.利用C++ Builder开发动画DLL  6.用C++ Builder 3制作屏幕保护程序  7.TCP/IP头格式  8.UDP  9.判断windows的D
四极管：C++builder 文件及目录的操作
杨琦（四极管）
11-24 1189
文章是转的，但是发现有些问题，现在补上： 一、判断目录是否存在：           C++   Builder中提供了检查文件是否存在的函数FileExists，indows   程序实现如下：           设char   *Dir为带判断的目录       bool   Exist;   //   最后结果，表示目录是否存在       if(Dir[strl
hook 监控文件 拷贝 c++
12-09
hook 监控文件是一种用于实时监控文件变化的技术，它可以在文件被创建、修改、移动或删除时立即触发相应的操作。拷贝C是指将特定文件或文件夹从一个位置复制到另一个位置，通常用于备份或迁移数据。 在实际操作中，利用hook监控文件可以实现当目标文件发生变化时立即执行拷贝C的操作。例如，当监控的文件被修改或更新时，hook可以触发自动执行文件拷贝到指定位置，以确保数据的实时同步与备份。 这样的应用场景包括但不限于数据备份、文件同步、实时数据监控等。通过hook监控文件变化并及时拷贝C，可以保证数据的安全性和完整性，同时减少人工干预，提高工作效率。 需要注意的是，在实施过程中需要确保hook监控的准确性和稳定性，避免误操作或丢失数据。同时，也需要根据具体需求对拷贝C的规则和方法进行合理设定，以满足不同业务场景的需求。 总之，通过利用hook监控文件变化并实时触发拷贝C操作，可以提高数据处理的自动化程度和效率，保障数据的安全性和完整性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值