包管理器：各平台安装卸载相关记述-Aet

Bingliaolong 2023-09-17 16:34 Aet | 隐藏边栏 | 抢沙发 | 19 0

文章评分 3 次，平均分 5.0 ：

Windows

安装

为了确定安装目标，在安装前后调用了get_reg_items

reg_helper reg;

auto res1 = reg.get_reg_items();

auto res = create_process(path);

auto res2 = reg.get_reg_items();

get_reg_items

std::map<std::wstring, std::map<std::wstring, std::wstring>> reg_helper::get_reg_items() {

std::map<std::wstring, std::map<std::wstring, std::wstring>> res;

for (auto item : programKeys) {

enum_sub_key(HKEY_LOCAL_MACHINE, item, res);

}

for (auto item : programKeysUser) {

enum_sub_key(HKEY_CURRENT_USER, item, res);

}

return res;

}

上买的Windows实现是通过枚举注册表
1. 把几个目标路径的注册表存到一起
2. 然后根据安装前后这些路径下的注册表的项数，来找出新增的那个

std::vector<std::wstring> programKeys = {

L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall",

L"SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall",

};

std::vector<std::wstring> programKeysUser = {

L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall",

};

void reg_helper::enum_sub_key(HKEY key, const std::wstring & path,

std::map<std::wstring, std::map<std::wstring, std::wstring>>&res) {

HKEY hKey;

if (RegOpenKeyEx(key, path.c_str(), 0, KEY_READ | KEY_WOW64_64KEY, &hKey) != ERROR_SUCCESS) {

DWORD dwError = GetLastError();

LPVOID lpMsgBuf;

DWORD len = FormatMessageW(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL,

dwError,

MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

(LPTSTR)&lpMsgBuf,

0, NULL);

if (len) {

LPWSTR lpMsgStr = (LPWSTR)lpMsgBuf;

std::wstring result(lpMsgStr, lpMsgStr + len);

LocalFree(lpMsgBuf);

}

return;

}

DWORD subkeys = 0;

DWORD maxValueNameLen = 0;

if (RegQueryInfoKey(hKey, NULL, NULL, NULL, &subkeys, NULL, NULL, NULL, &maxValueNameLen, NULL, NULL, NULL) != ERROR_SUCCESS) {

RegCloseKey(hKey);

return;

}

TCHAR subkeyName[256];

DWORD subkeyNameSize;

for (DWORD i = 0; i < subkeys; i++) {

subkeyNameSize = sizeof(subkeyName) / sizeof(TCHAR);

if (RegEnumKeyEx(hKey, i, subkeyName, &subkeyNameSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {

std::wstring tmp(subkeyName);

auto mp = res.emplace(tmp, std::map<std::wstring, std::wstring>());

if (!mp.second) {

continue;

}

HKEY hSubKey;

if (RegOpenKeyEx(hKey, subkeyName, 0, KEY_READ, &hSubKey) == ERROR_SUCCESS) {

read_reg_values(hSubKey, res, tmp);

RegCloseKey(hSubKey);

}

RegCloseKey(hKey);

}

通过比较，确定新增项，然后记录下新安装软件的卸载位置，为了安装后的卸载
1. 下面的set_db_record就是把下载的软件的编号和对应的卸载路径存起来

if (res2.size() > res1.size()) {

auto str = get_goal_reg(res2, res1);

if (!str.empty()) {

set_db_record(appid, str);

}

std::wstring installer_helper::get_goal_reg(std::map<std::wstring, std::map<std::wstring, std::wstring>>&vec1,

std::map<std::wstring, std::map<std::wstring, std::wstring>>&vec2) {

std::wstring res;

for (const auto& item : vec1) {

if (vec2.find(item.first) == vec2.end()) {

auto tmp = item.second;

auto ite = tmp.find(L"UninstallString");

if (ite == tmp.end()) {

continue;

}

res = ite->second;

break;

}

return res;

}

卸载

根据编号去获取存储的软件卸载路径

1	std::wstring goal_path = m_app->get_unist_goal(appid);

设置路径参数

auto helper = std::make_unique<uninstaller_helper>(this);

helper->set_goal_path(appid, goal_path.c_str());

helper->set_group(task_group::em_tg_low_group);

helper->check_and_start();

根据这个路径开始卸载

void uninstaller_helper::start_uninstall() {

#if defined(WIN32) || defined(__WIN32) || defined(__WIN32__) || defined(__NT__)

DWORD exitCode;

sync_status syst(sync_status::em_syst_install_default);

SHELLEXECUTEINFO execInfo = { 0 };

execInfo.cbSize = sizeof(SHELLEXECUTEINFO);

execInfo.fMask = SEE_MASK_NOCLOSEPROCESS;

execInfo.hwnd = NULL;

execInfo.lpVerb = L"runas";

execInfo.lpFile = m_path;

execInfo.lpParameters = NULL;

execInfo.lpDirectory = NULL;

execInfo.nShow = SW_SHOW;

execInfo.hInstApp = NULL;

execInfo.hProcess = NULL;

if (!ShellExecuteEx(&execInfo)) {

DWORD dwError = GetLastError();

LPVOID lpMsgBuf;

DWORD len = FormatMessageW(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL,

dwError,

MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

(LPTSTR)&lpMsgBuf,

0, NULL);

if (len) {

LPWSTR lpMsgStr = (LPWSTR)lpMsgBuf;

std::wstring result(lpMsgStr, lpMsgStr + len);

LocalFree(lpMsgBuf);

}

if (m_unist && m_appid) {

m_unist->uninstall_status(install_type::em_it_uninstalled_failed, m_appid);

}

return;

}

if (execInfo.hProcess == NULL || execInfo.hProcess == INVALID_HANDLE_VALUE) {

if (m_unist && m_appid) {

m_unist->uninstall_status(install_type::em_it_uninstalled_failed, m_appid);

}

return;

}

WaitForSingleObject(execInfo.hProcess, INFINITE);

if (GetExitCodeProcess(execInfo.hProcess, &exitCode)) {

syst = (exitCode == 0) ? sync_status::em_syst_uninstall_success

: sync_status::em_syst_uninstall_failed;

}

CloseHandle(execInfo.hProcess);

if (syst == sync_status::em_syst_uninstall_success) {

if (m_unist && m_appid) {

m_unist->uninstall_status(install_type::em_it_uninstalled_success, m_appid);

}

else if (syst == sync_status::em_syst_uninstall_failed) {

if (m_unist && m_appid) {

m_unist->uninstall_status(install_type::em_it_uninstalled_failed, m_appid);

}

Linux

安装

linux同样也是在安装前后，把一些文件做了保存，然后根据这些文件来确定，具体安装的是哪一个软件
1. 这里选择保存的是linux下软件的list文件

reg_helper reg;

auto res1 = reg.get_reg_items();

auto res = create_process(path);

auto res2 = reg.get_reg_items();

std::vector<std::string> reg_helper::get_reg_items() {

std::vector<std::string> res;

try {

std::string dPkgPath("/var/lib/dpkg/info/");

if (!boost::filesystem::exists(dPkgPath)) {

dPkgPath = "/usr/lib/dpkg-db/info/";

}

boost::filesystem::path dirPath(dPkgPath);

for (boost::filesystem::directory_iterator it(dirPath); it != boost::filesystem::directory_iterator(); ++it) {

if (it->path().extension() == ".list") {

auto file = it->path().string();

res.push_back(file);

}

} catch(const boost::filesystem::filesystem_error& err) {

return {};

}

return res;

}

具体安装的方法暂时linux和apple都使用了system调命令的方法

#elif defined(__APPLE__) || defined(__linux__)

std::string tmpStr = to_str(path);

if (tmpStr.empty()) {

return sync_status::em_syst_create_process_failed;

}

#if defined(__APPLE__)

std::string tmp("/System/Library/CoreServices/Installer.app/Contents/MacOS/Installer ");

#elif defined(__linux__)

std::string tmp("pkexec dpkg -i ");

#endif

std::string cmdStr("\"");

cmdStr.append(tmpStr).append("\"");

tmp.append(cmdStr);

int return_code = system(tmp.c_str());

if (return_code == 0) {

return sync_status::em_syst_install_success;

}

else {

return sync_status::em_syst_install_failed;

}

#endif

不同之处在于，单步过程中发现个别软件表现不一致，比如一些软件卸载完成后就删掉了list文件，而有一些则是清空list文件但不删除
1. 这会导致部分软件在第二次安装的时候，比list数量时，发现是一样的
2. 所以，暂时想了个策略，就是在安装前记录下一个时间戳，用以对比，如下：

#elif defined(__APPLE__) || defined(__linux__)

reg_helper reg;

auto res1 = reg.get_reg_items();

#if defined(__linux__)

auto now = std::chrono::system_clock::now();

#endif

auto res = create_process(path);

auto res2 = reg.get_reg_items();

当安装完后，发现成功了，当发现list数量安装后比安装前多，就获取目标软件的路径
1. 可以看到，这里是用上了上面记录的时间戳，进程函数后，又创建了一个时间戳，并计算出了一个时间间隔
2. 然后获取每个文件的最后修改时间，和后面的时间戳作间隔处理，并和上面的对比
3. 如果后面的间隔小于等于前面两个时间戳的间隔，则认为这个文件是目标软件安装过程中被修改过的
4. 所以把它保存起来，并且，这里我的做法是，找了一个这样的路径后，就不再查找了
5. 这样的做法，从理论上来看，是做不到完全的准确的

auto str = get_goal_reg(res2, res1, now);

if (str.empty()) {

type = install_type::em_it_installed_failed;

} else {

auto tmp_str = to_wstr(str.c_str());

if (tmp_str.empty()) {

type = install_type::em_it_installed_failed;

} else {

set_db_record(appid, tmp_str);

type = install_type::em_it_installed_success;

}

std::string installer_helper::get_goal_reg(std::vector<std::string>& vec1,

std::vector<std::string>& vec2,

std::chrono::system_clock::time_point clock) {

auto now = std::chrono::system_clock::now();

auto interval = std::chrono::duration_cast<std::chrono::seconds>(now - clock);

std::vector<std::string> tmp;

for (auto item : vec1) {

if (std::find(vec2.begin(), vec2.end(), item) == vec2.end()) {

tmp.push_back(item);

}

if (tmp.empty()) {

return "";

}

std::string res_p;

for (auto items : tmp) {

try {

boost::filesystem::path file(items);

auto last_time = boost::filesystem::last_write_time(file);

auto time = std::chrono::system_clock::from_time_t(last_time);

auto file_interval = std::chrono::duration_cast<std::chrono::seconds>(now - time);

if (file_interval <= interval) {

res_p = items;

break;

}

} catch(const boost::filesystem::filesystem_error&) {

continue ;

}

return res_p;

}

还有一种情况，就是上面说的list数量一样的情况，同样也做了类似处理
1. 根据时间间隔来处理，考虑到这样的文件可能会有多个，所以在实现时，只使用了res[0]
2. 并对路径进行了保存

if (res2.size() > res1.size()) {

// ...

} else if (res2.size() == res1.size()) {

auto str = get_goal_second_linux(res2, now);

if (str.empty()) {

type = install_type::em_it_installed_failed;

} else {

std::wstring wstr = to_wstr(str.c_str());

set_db_record(appid, wstr);

type = install_type::em_it_installed_success;

}

std::string installer_helper::get_goal_second_linux(std::vector<std::string>& res,

std::chrono::system_clock::time_point clock) {

std::vector<std::string> tmpres;

auto now = std::chrono::system_clock::now();

auto interval = std::chrono::duration_cast<std::chrono::seconds>(now - clock);

try {

for (auto item : res) {

boost::filesystem::path file(item);

if (!boost::filesystem::exists(file)) {

continue ;

}

std::time_t lastModified = boost::filesystem::last_write_time(file);

auto fileTimePoint = std::chrono::system_clock::from_time_t(lastModified);

auto duration = std::chrono::duration_cast<std::chrono::seconds>(now - fileTimePoint);

if (duration.count() <= interval.count()) {

tmpres.push_back(file.string());

}

}catch(boost::filesystem::filesystem_error&) {}

if (tmpres.empty()) {

return "";

}

auto resstr = tmpres.at(0);

return resstr;

}

卸载

linux的卸载，同样还是调用了system命令

boost::filesystem::path path(m_path);

std::string programName = path.stem().string();

std::string uninstallCmd = "pkexec dpkg -P --force-all " + programName;

int result = system(uninstallCmd.c_str());

if (result == 0) {

if (m_unist && m_appid) {

m_unist->uninstall_status(install_type::em_it_uninstalled_success, m_appid);

}

} else {

if (m_unist && m_appid) {

m_unist->uninstall_status(install_type::em_it_uninstalled_failed, m_appid);

}

关于上面代码中的路径，使用了list文件的名字来拼接了卸载命令

1	std::string programName = path.stem().string();

macOS

安装

macos下面的安装，和上面讲的linux也有类似之处
1. 同样是通过文件数量来定位安装的是哪个文件，不过macos用的bom文件

std::unordered_set<std::string> reg_helper::get_reg_items() {

std::unordered_set<std::string> res;

try {

boost::filesystem::path dirPath("/var/db/receipts");

for (boost::filesystem::directory_iterator it(dirPath); it != boost::filesystem::directory_iterator(); ++it) {

if (it->path().extension() == ".bom") {

auto file = it->path().string();

res.insert(file);

}

catch (const boost::filesystem::filesystem_error& err) {

return {};

}

auto str = get_goal_reg(res2, res1);

std::string installer_helper::get_goal_reg(std::unordered_set<std::string>& res1,

std::unordered_set<std::string>& res2) {

std::vector<std::string> tmp;

for (auto item : res1) {

if (res2.find(item) != res2.end()) {

continue;

}

tmp.push_back(item);

}

if (tmp.empty()) {

return "";

}

return tmp[0];

}

安装

1 2	auto res = create_process(path); auto res2 = reg.get_reg_items();

// create_process

std::string tmpStr = to_str(path);

if (tmpStr.empty()) {

return sync_status::em_syst_create_process_failed;

}

#if defined(__APPLE__)

std::string tmp("/System/Library/CoreServices/Installer.app/Contents/MacOS/Installer ");

#elif defined(__linux__)

std::string tmp("pkexec dpkg -i ");

#endif

std::string cmdStr("\"");

cmdStr.append(tmpStr).append("\"");

tmp.append(cmdStr);

int return_code = system(tmp.c_str());

if (return_code == 0) {

return sync_status::em_syst_install_success;

}

else {

return sync_status::em_syst_install_failed;

}

#endif

}

至于路径的确定，macos这里使用了不一样的方法
1. 可以看到调用了一个get_goal_second_path
2. 具体就是，定位到这个bom文件，用apple的工具lsbom去输出它的内容，并把内容重定位到一个临时文件里面
3. 然后再冲文件里面去逐行读取
4. 把第一个找到.app字样的行进行处理，从中拿出一个路径，类似/Applications/xx.app

auto str = get_goal_reg(res2, res1);

if (!str.empty()) {

auto res_path = get_goal_second_path(str);

if (res_path.empty()) {

type = install_type::em_it_installed_failed;

break;

}

size_t len = std::mbstowcs(nullptr, res_path.c_str(), 0);

std::wstring wstr_to(len, L'\0');

std::mbstowcs(&wstr_to[0], str.c_str(), len);

set_db_record(appid, wstr_to);

type = install_type::em_it_installed_success;

} else {

type = install_type::em_it_installed_failed;

}

std::string installer_helper::get_goal_second_path(std::string & respath) {

std::string res_str;

#if defined(__APPLE__)

auto path = get_ues_path();

if (path.empty()) {

return "";

}

struct stat buff;

const char* log_path = path.c_str();

if (stat(log_path, &buff) != 0) {

auto mask_tmp = umask(0);

mode_t mode = 0777;

::mkdir(log_path, mode);

umask(mask_tmp);

}

path.append("/tmpbom");

auto tmp_bomm = respath;

std::string command = "lsbom " + tmp_bomm + " > " + path;

int result = system(command.c_str());

if (result != 0) {

return "";

}

std::ifstream infile(path);

if (!infile.is_open()) {

return "";

}

std::string line;

while (std::getline(infile, line)) {

if (line.size() >= 4) {

auto pos = line.find(".app");

if (pos != std::string::npos) {

res_str = line.substr(1, pos + 3);

break;

}

infile.close();

std::remove(path.c_str());

#endif

return res_str;

}

同样的，上面的bom的文件数量也有一样的时候，因为这个bom文件是apple操作系统写的，所以，软件卸载的时候不会去删掉它
1. 也就是，第二次安装的时候，这个软件对应的bom文件其实已经存在的
2. 所以，还是需要和上面linux一样的方法来确定到底是哪个bom文件
3. 不同的是，apple这里的实现，我当时写死了，就是判断30秒以内的

std::string installer_helper::get_goal_second() {

std::vector<std::string> tmpres;

auto now = std::chrono::system_clock::now();

std::string res;

try {

boost::filesystem::path dirPath("/var/db/receipts");

for (boost::filesystem::directory_iterator it(dirPath); it != boost::filesystem::directory_iterator(); ++it) {

auto file = it->path();

if (file.extension() != ".bom") {

continue;

}

std::time_t lastModified = boost::filesystem::last_write_time(file);

auto fileTimePoint = std::chrono::system_clock::from_time_t(lastModified);

auto duration = std::chrono::duration_cast<std::chrono::seconds>(now - fileTimePoint);

if (duration.count() <= 30) {

tmpres.push_back(file.string());

}

catch (const boost::filesystem::filesystem_error& err) {

}

if (tmpres.empty()) {

return "";

}

std::string res_str;

res_str = get_goal_second_path(tmpres[0]);

return res_str;

}

然后存储的时候，就是把软件的队友编号，和上面解析出来的那个/Applications/xx.app这个路径对照起来，然后存起来

卸载

卸载的话，首先从数据库里面获取了软件编号对应的应用路径，如/Applications/xx.app
然后，为了达到阻塞的效果，使用了oc的方法，如下：
1. 具体的效果，就是用这个路径，拼了一个苹果脚本
2. 这个脚本的效果，就是把这个路径对应的应用放到废纸篓（涉及权限）
3. 为了阻塞的去执行这个任务，用oc的方法创建了一个进程

1	int result = unist_task(tmpStr.c_str());

int unist_task(const char* path) {

@autoreleasepool {

OSStatus status;

AuthorizationRef authorizationRef;

status = AuthorizationCreate(nullptr, kAuthorizationEmptyEnvironment, kAuthorizationFlagDefaults, &authorizationRef);

if (status != errAuthorizationSuccess) {

return -1;

}

NSString *osascriptCmd = [NSString stringWithFormat:@"tell app \"Finder\" to move POSIX file \"%s\" to trash", path];

const char *cmd = [osascriptCmd UTF8String];

char *osascriptArgs[] = { "-e", (char*)cmd, nullptr };

FILE *pipe = nullptr;

status = AuthorizationExecuteWithPrivileges(authorizationRef, "/usr/bin/osascript", kAuthorizationFlagDefaults, osascriptArgs, &pipe);

if (status != errAuthorizationSuccess) {

return -1;

}

char buffer[1024];

while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {

}

bool flag = false;

do {

int exitStatus = pclose(pipe);

if (WIFEXITED(exitStatus)) {

int returnCode = WEXITSTATUS(exitStatus);

if (returnCode == 0) {

flag = true;

break;

}

} while(false);

AuthorizationFree(authorizationRef, kAuthorizationFlagDestroyRights);

if (flag) {

return 0;

}

return -1;

}

Windows
安装
卸载
Linux
安装
卸载
macOS
安装
卸载

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0

Everything will be better.

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

Windows

安装

卸载

Linux

安装

卸载

macOS

安装

卸载

你可能也喜欢

热评文章

发表评论

标签云集