int win_run_cmd(char* cmd)
{
STARTUPINFO sinfo;
PROCESS_INFORMATION pinfo;
DWORD ret;
memset(&pinfo, 0, sizeof(pinfo));
memset(&sinfo, 0, sizeof(sinfo));
sinfo.cb = sizeof(sinfo);
/* start it */
if(!CreateProcess(NULL, cmd, NULL, NULL, 0, CREATE_NO_WINDOW,
NULL, NULL, &sinfo, &pinfo)) {
log_win_err(cmd, GetLastError());
return -1;
}
/* wait for it */
if(WaitForSingleObject(pinfo.hProcess, INFINITE) == WAIT_FAILED) {
log_win_err("cannot WaitForSingleObject(exe):", GetLastError());
}
if(!GetExitCodeProcess(pinfo.hProcess, &ret)) {
log_win_err("cannot GetExitCodeProcess", GetLastError());
ret = -1;
}
CloseHandle(pinfo.hProcess);
CloseHandle(pinfo.hThread);
return ret;
}
void win_set_resolv(char* ip)
{
const char* key = "SYSTEM\\CurrentControlSet\\Services\\Tcpip"
"\\Parameters";
const char* ifs = "SYSTEM\\CurrentControlSet\\services\\Tcpip"
"\\Parameters\\Interfaces";
const char* key6 = "SYSTEM\\CurrentControlSet\\Services\\Tcpip6"
"\\Parameters";
const char* ifs6 = "SYSTEM\\CurrentControlSet\\services\\Tcpip6"
"\\Parameters\\Interfaces";
HKEY hk;
verbose(VERB_DETAIL, "set reg %s", ip);
/* needs administrator permissions */
if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR)key,
0, /* reserved, mustbezero */
NULL, /* class of key, ignored */
REG_OPTION_NON_VOLATILE, /* values saved on disk */
KEY_WRITE, /* we want write permission */
NULL, /* use default security descriptor */
&hk, /* result */
NULL)) /* not interested if key new or existing */
{
log_win_err("could not open registry key", GetLastError());
} else {
/* set NameServer */
if(RegSetValueEx(hk, (LPCTSTR)"NameServer", 0, REG_SZ,
(BYTE*)ip, (DWORD)strlen(ip)+1)) {
log_win_err("could not set regkey NameServer", GetLastError());
}
RegCloseKey(hk);
}
/* set all interfaces/guid/nameserver */
enum_guids(ifs, &enum_reg_set_nameserver, ip);
/* IPv6 */
/* needs administrator permissions */
if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR)key6,
0, /* reserved, mustbezero */
NULL, /* class of key, ignored */
REG_OPTION_NON_VOLATILE, /* values saved on disk */
KEY_WRITE, /* we want write permission */
NULL, /* use default security descriptor */
&hk, /* result */
NULL)) /* not interested if key new or existing */
{
log_win_err("could not open registry key6", GetLastError());
} else {
/* set NameServer */
if(RegSetValueEx(hk, (LPCTSTR)"NameServer", 0, REG_SZ,
(BYTE*)ip, (DWORD)strlen(ip)+1)) {
log_win_err("could not set6 regkey NameServer", GetLastError());
}
RegCloseKey(hk);
}
/* set all interfaces/guid/nameserver */
enum_guids(ifs6, &enum_reg_set_nameserver, ip);
}
void ub_thread_join(ub_thread_t thr)
{
DWORD ret = WaitForSingleObject(thr, INFINITE);
if(ret == WAIT_FAILED) {
log_win_err("WaitForSingleObject(Thread):WAIT_FAILED",
GetLastError());
} else if(ret == WAIT_TIMEOUT) {
log_win_err("WaitForSingleObject(Thread):WAIT_TIMEOUT",
GetLastError());
}
/* and close the handle to the thread */
if(!CloseHandle(thr)) {
log_win_err("CloseHandle(Thread) failed", GetLastError());
}
}
void* ub_thread_key_get(ub_thread_key_t key)
{
void* ret = (void*)TlsGetValue(key);
if(ret == NULL && GetLastError() != ERROR_SUCCESS) {
log_win_err("TlsGetValue failed", GetLastError());
}
return ret;
}
void ub_thread_key_create(ub_thread_key_t* key, void* f)
{
*key = TlsAlloc();
if(*key == TLS_OUT_OF_INDEXES) {
*key = 0;
log_win_err("TlsAlloc Failed(OUT_OF_INDEXES)", GetLastError());
}
else ub_thread_key_set(*key, f);
}
void
enum_reg_set_nameserver(HKEY hk, void* arg)
{
DWORD len = 0;
if(arg) len = strlen((char*)arg);
if(RegSetValueEx(hk, (LPCTSTR)"NameServer", 0, REG_SZ,
(BYTE*)arg, (DWORD)len)) {
log_win_err("could not enumset regkey NameServer", GetLastError());
}
}
/** enumerate all subkeys of base, and call process(hk, arg) on them */
void enum_guids(const char* base, void (*process_it)(HKEY,void*), void* arg)
{
char subname[1024];
HKEY base_hk, sub_hk;
DWORD sz = sizeof(subname);
DWORD i = 0, ret;
if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR)base,
0, /* reserved, mustbezero */
NULL, /* class of key, ignored */
REG_OPTION_NON_VOLATILE, /* values saved on disk */
KEY_WRITE|KEY_ENUMERATE_SUB_KEYS,
NULL, /* use default security descriptor */
&base_hk, /* result */
NULL)) /* not interested if key new or existing */
{
log_win_err("could not open enum registry key", GetLastError());
return;
}
while( (ret=RegEnumKeyEx(base_hk, i, (LPTSTR)subname, &sz, NULL, NULL,
0, NULL)) == ERROR_SUCCESS) {
verbose(VERB_ALGO, "enum %d %s", (int)i, subname);
/* process it */
if(RegOpenKeyEx(base_hk, (LPCTSTR)subname, 0, KEY_WRITE,
&sub_hk)) {
log_win_err("enum cannot RegOpenKey", GetLastError());
} else {
fptr_ok(fptr_whitelist_enum_reg(process_it));
(*process_it)(sub_hk, arg);
RegCloseKey(sub_hk);
}
/* prepare for next iteration */
i++;
sz = sizeof(subname);
}
if(ret == ERROR_MORE_DATA) {
log_err("part of %s has registry keys that are too long", base);
} else if(ret != ERROR_NO_MORE_ITEMS) {
log_win_err("cannot RegEnumKey", GetLastError());
}
RegCloseKey(base_hk);
}
void ub_thread_create(ub_thread_t* thr, void* (*func)(void*), void* arg)
{
#ifndef HAVE__BEGINTHREADEX
*thr = CreateThread(NULL, /* default security (no inherit handle) */
0, /* default stack size */
(LPTHREAD_START_ROUTINE)func, arg,
0, /* default flags, run immediately */
NULL); /* do not store thread identifier anywhere */
#else
/* the begintheadex routine setups for the C lib; aligns stack */
*thr=(ub_thread_t)_beginthreadex(NULL, 0, (void*)func, arg, 0, NULL);
#endif
if(*thr == NULL) {
log_win_err("CreateThread failed", GetLastError());
fatal_exit("thread create failed");
}
}
void ub_thread_key_set(ub_thread_key_t key, void* v)
{
if(!TlsSetValue(key, v)) {
log_win_err("TlsSetValue failed", GetLastError());
}
}
