// Reading a string resource wchar_t *ViLoadString(HINSTANCE hInst, UINT id) { wchar_t *ret = NULL; if (OS_IS_WINDOWS_9X(GetOsInfo()->OsType)) { char *a = ViLoadStringA(hInst, id); if (a != NULL) { ret = CopyStrToUni(a); Free(a); } } else { UINT tmp_size = 60000; wchar_t *tmp = Malloc(tmp_size); if (LoadStringW(hInst, id, tmp, tmp_size) != 0) { ret = CopyUniStr(tmp); } Free(tmp); } return ret; }
// Get whether the local-bridging is supported by current OS bool IsBridgeSupported() { UINT type = GetOsInfo()->OsType; if (OS_IS_WINDOWS(type)) { if (IsEthSupported()) { return true; } else { bool ret = false; #ifdef OS_WIN32 ret = MsIsAdmin(); #endif // OS_WIN32 return ret; } } else { return IsEthSupported(); } }
// Is the PCD driver supported in current OS bool IsPcdSupported() { UINT type; OS_INFO *info = GetOsInfo(); if (MsIsWindows10()) { // Windows 10 or later never supports PCD driver. return false; } type = info->OsType; if (OS_IS_WINDOWS_NT(type) == false) { // Only on Windows NT series return false; } if (GET_KETA(type, 100) >= 2) { // Good for Windows 2000 or later return true; } // Not good for Windows NT 4.0 or Longhorn return false; }
// Save the Unicode cache void SaveUnicodeCache(wchar_t *strfilename, UINT strfilesize, UCHAR *hash) { UNICODE_CACHE c; BUF *b; UINT i; IO *io; wchar_t name[MAX_PATH]; UCHAR binhash[MD5_SIZE]; // Validate arguments if (strfilename == NULL || hash == NULL) { return; } Zero(&c, sizeof(c)); UniToStr(c.StrFileName, sizeof(c.StrFileName), strfilename); c.StrFileSize = strfilesize; GetMachineName(c.MachineName, sizeof(c.MachineName)); c.OsType = GetOsInfo()->OsType; Copy(c.hash, hash, MD5_SIZE); #ifdef OS_UNIX GetCurrentCharSet(c.CharSet, sizeof(c.CharSet)); #else // OS_UNIX { UINT id = MsGetThreadLocale(); Copy(c.CharSet, &id, sizeof(id)); } #endif // OS_UNIX b = NewBuf(); WriteBuf(b, &c, sizeof(c)); WriteBufInt(b, LIST_NUM(TableList)); for (i = 0;i < LIST_NUM(TableList);i++) { TABLE *t = LIST_DATA(TableList, i); WriteBufInt(b, StrLen(t->name)); WriteBuf(b, t->name, StrLen(t->name)); WriteBufInt(b, StrLen(t->str)); WriteBuf(b, t->str, StrLen(t->str)); WriteBufInt(b, UniStrLen(t->unistr)); WriteBuf(b, t->unistr, UniStrLen(t->unistr) * sizeof(wchar_t)); } Hash(binhash, b->Buf, b->Size, false); WriteBuf(b, binhash, MD5_SIZE); GenerateUnicodeCacheFileName(name, sizeof(name), strfilename, strfilesize, hash); io = FileCreateW(name); if (io != NULL) { SeekBuf(b, 0, 0); BufToFile(io, b); FileClose(io); } FreeBuf(b); }
// Get version of Windows void GetWinVer(RPC_WINVER *v) { // Validate arguments if (v == NULL) { return; } #ifdef OS_WIN32 Win32GetWinVer(v); #else // OS_WIN32 Zero(v, sizeof(RPC_WINVER)); StrCpy(v->Title, sizeof(v->Title), GetOsInfo()->OsProductName); #endif // OS_WIN32 }
int main (int argc, char **argv) { char OsName [BUFSIZE]; char Version [BUFSIZE]; char Release [BUFSIZE]; if (GetOsInfo(OsName, Release, Version)) fprintf(stderr, "%s", OsName); /* fprintf(stderr, "IsWinNT: %d\n", iswinnt ()); fprintf(stderr, "IsWin9X: %d\n", iswin9x ()); fprintf(stderr, "IsWin31: %d\n", iswin31 ()); fprintf(stderr, "IsWinCE: %d\n", iswince ()); */ return 0; }
// Get the information UINT NtGetInfo(NAT *n, RPC_NAT_INFO *t) { OS_INFO *info; FreeRpcNatInfo(t); Zero(t, sizeof(RPC_NAT_INFO)); StrCpy(t->NatProductName, sizeof(t->NatProductName), CEDAR_ROUTER_STR); StrCpy(t->NatVersionString, sizeof(t->NatVersionString), n->Cedar->VerString); StrCpy(t->NatBuildInfoString, sizeof(t->NatBuildInfoString), n->Cedar->BuildInfo); t->NatVerInt = n->Cedar->Build; t->NatBuildInt = n->Cedar->Build; GetMachineName(t->NatHostName, sizeof(t->NatHostName)); info = GetOsInfo(); CopyOsInfo(&t->OsInfo, info); GetMemInfo(&t->MemInfo); return ERR_NO_ERROR; }
// Add a local-bridge void AddLocalBridge(CEDAR *c, char *hubname, char *devicename, bool local, bool monitor, bool tapmode, char *tapaddr, bool limit_broadcast) { UINT i; HUB *h = NULL; LOCALBRIDGE *br = NULL; // Validate arguments if (c == NULL || hubname == NULL || devicename == NULL) { return; } if (OS_IS_UNIX(GetOsInfo()->OsType) == false) { tapmode = false; } LockList(c->HubList); { LockList(c->LocalBridgeList); { bool exists = false; // Ensure that the same configuration local-bridge doesn't exist already for (i = 0;i < LIST_NUM(c->LocalBridgeList);i++) { LOCALBRIDGE *br = LIST_DATA(c->LocalBridgeList, i); if (StrCmpi(br->DeviceName, devicename) == 0) { if (StrCmpi(br->HubName, hubname) == 0) { if (br->TapMode == tapmode) { exists = true; } } } } if (exists == false) { // Add configuration br = ZeroMalloc(sizeof(LOCALBRIDGE)); StrCpy(br->HubName, sizeof(br->HubName), hubname); StrCpy(br->DeviceName, sizeof(br->DeviceName), devicename); br->Bridge = NULL; br->Local = local; br->TapMode = tapmode; br->LimitBroadcast = limit_broadcast; br->Monitor = monitor; if (br->TapMode) { if (tapaddr != NULL && IsZero(tapaddr, 6) == false) { Copy(br->TapMacAddress, tapaddr, 6); } else { GenMacAddress(br->TapMacAddress); } } Add(c->LocalBridgeList, br); // Find the hub for (i = 0;i < LIST_NUM(c->HubList);i++) { HUB *hub = LIST_DATA(c->HubList, i); if (StrCmpi(hub->Name, br->HubName) == 0) { h = hub; AddRef(h->ref); break; } } } } UnlockList(c->LocalBridgeList); } UnlockList(c->HubList); // Start the local-bridge immediately if (h != NULL && br != NULL && h->Type != HUB_TYPE_FARM_DYNAMIC) { Lock(h->lock_online); { if (h->Offline == false) { LockList(c->LocalBridgeList); { if (IsInList(c->LocalBridgeList, br)) { if (br->Bridge == NULL) { br->Bridge = BrNewBridge(h, br->DeviceName, NULL, br->Local, br->Monitor, br->TapMode, br->TapMacAddress, br->LimitBroadcast, br); } } } UnlockList(c->LocalBridgeList); } } Unlock(h->lock_online); } ReleaseHub(h); }
// Create a tap device int UnixCreateTapDeviceEx(char *name, char *prefix, UCHAR *mac_address) { int fd; struct ifreq ifr; char eth_name[MAX_SIZE]; char instance_name_lower[MAX_SIZE]; struct sockaddr sa; char *tap_name = TAP_FILENAME_1; int s; // Validate arguments if (name == NULL) { return -1; } // Generate the device name StrCpy(instance_name_lower, sizeof(instance_name_lower), name); Trim(instance_name_lower); StrLower(instance_name_lower); Format(eth_name, sizeof(eth_name), "%s_%s", prefix, instance_name_lower); eth_name[15] = 0; // Open the tun / tap #ifndef UNIX_MACOS if (GetOsInfo()->OsType == OSTYPE_LINUX) { // Linux if (IsFile(TAP_FILENAME_1) == false) { char tmp[MAX_SIZE]; Format(tmp, sizeof(tmp), "%s c 10 200", TAP_FILENAME_1); Run("mknod", tmp, true, true); Format(tmp, sizeof(tmp), "600 %s", TAP_FILENAME_1); Run("chmod", tmp, true, true); } } // Other than MacOS X fd = open(TAP_FILENAME_1, O_RDWR); if (fd == -1) { // Failure fd = open(TAP_FILENAME_2, O_RDWR); if (fd == -1) { return -1; } tap_name = TAP_FILENAME_2; } #else // UNIX_MACOS // MacOS X fd = open(TAP_MACOS_FILENAME, O_RDWR); if (fd == -1) { return -1; } tap_name = TAP_MACOS_FILENAME; #endif // UNIX_MACOS #ifdef UNIX_LINUX // Create a tap for Linux // Set the device name Zero(&ifr, sizeof(ifr)); ifr.ifr_flags = IFF_TAP | IFF_NO_PI; StrCpy(ifr.ifr_name, sizeof(ifr.ifr_name), eth_name); if (ioctl(fd, TUNSETIFF, &ifr) == -1) { // Failure close(fd); return -1; } // MAC address setting s = socket(AF_INET, SOCK_DGRAM, 0); if (s != -1) { if (mac_address != NULL) { Zero(&ifr, sizeof(ifr)); StrCpy(ifr.ifr_name, sizeof(ifr.ifr_name), eth_name); ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER; Copy(&ifr.ifr_hwaddr.sa_data, mac_address, 6); ioctl(s, SIOCSIFHWADDR, &ifr); } Zero(&ifr, sizeof(ifr)); StrCpy(ifr.ifr_name, sizeof(ifr.ifr_name), eth_name); ioctl(s, SIOCGIFFLAGS, &ifr); ifr.ifr_flags |= IFF_UP; ioctl(s, SIOCSIFFLAGS, &ifr); close(s); } #else // UNIX_LINUX #ifdef UNIX_SOLARIS // Create a tap for Solaris { int ip_fd; int tun_fd; int ppa; tun_fd = open(tap_name, O_RDWR); if (tun_fd == -1) { // Failure close(fd); return -1; } ip_fd = open("/dev/ip", O_RDWR); if (ip_fd == -1) { // Failure close(tun_fd); close(fd); return -1; } ppa = -1; ppa = ioctl(tun_fd, TUNNEWPPA, ppa); if (ppa == -1) { // Failure close(tun_fd); close(fd); close(ip_fd); return -1; } if (ioctl(fd, I_PUSH, "ip") < 0) { // Failure close(tun_fd); close(fd); close(ip_fd); return -1; } if (ioctl(fd, IF_UNITSEL, (char *)&ppa) < 0) { // Failure close(tun_fd); close(fd); close(ip_fd); return -1; } if (ioctl(ip_fd, I_LINK, fd) < 0) { // Failure close(tun_fd); close(fd); close(ip_fd); return -1; } close(tun_fd); close(ip_fd); } #endif // UNIX_SOLARIS #endif // UNIX_LINUX return fd; }
// Main process void ViMain() { char tmp[MAX_PATH]; UINT ostype = GetOsInfo()->OsType; VI_SETTING_ARCH *suitable; TOKEN_LIST *t; UINT i; if (OS_IS_WINDOWS_NT(ostype) == false || GET_KETA(ostype, 100) <= 1) { // The OS is too old MsgBox(NULL, MB_ICONEXCLAMATION, _U(IDS_BAD_OS+skip)); return; } Zero(&setting, sizeof(setting)); // Read the inf file Format(tmp, sizeof(tmp), "%s\\%s", MsGetExeDirName(), VI_INF_FILENAME); if (ViLoadInf(&setting, tmp) == false) { // Failure MsgBoxEx(NULL, MB_ICONSTOP, _U(IDS_INF_LOAD_FAILED+skip), VI_INF_FILENAME); return; } ViSetSkip(); // Parse the command line options t = GetCommandLineToken(); for (i = 0;i < t->NumTokens;i++) { char *s = t->Token[i]; if (IsEmptyStr(s) == false) { if (StartWith(s, "/") || StartWith(s, "-")) { if (StrCmpi(&s[1], "web") == 0) { setting.WebMode = true; } } else { StrCpy(setting.SettingPath, sizeof(setting.SettingPath), s); } } } FreeToken(t); suitable = ViGetSuitableArchForCpu(); // Security check if (setting.WebMode) { bool ok = true; if (ViIsInternetFile(suitable->Path) == false) { ok = false; } if (IsEmptyStr(setting.SettingPath) == false) { if (ViIsInternetFile(setting.SettingPath) == false) { ok = false; } } if (ok == false) { // Security breach MsgBox(NULL, MB_ICONEXCLAMATION, _U(IDS_SECURITY_ERROR+skip)); return; } } // Get the current installation state ViLoadCurrentInstalledStates(); if (suitable->Supported == false) { // This CPU isn't supported MsgBox(NULL, MB_ICONEXCLAMATION, _U(IDS_CPU_NOT_SUPPORTED+skip)); return; } if (suitable->CurrentInstalled && suitable->Build <= suitable->CurrentInstalledBuild) { // Do not download client software since it has already been installed setting.DownloadNotRequired = true; } // Show the dialog ViInstallDlg(); }
LIST *GetEthAdapterListInternal() { LIST *o; LIST *ret; UINT size; char *buf; UINT i, j; char *qos_tag = " (Microsoft's Packet Scheduler)"; SU *su = NULL; LIST *su_adapter_list = NULL; // Try to use SeLow if (enable_selow) { su = SuInit(); } o = NewListFast(CompareWpAdapter); size = 200000; buf = ZeroMalloc(size); // Try to enumerate with SeLow if (su != NULL) { su_adapter_list = SuGetAdapterList(su); if (su_adapter_list == NULL) { // Fail to enumerate SuFree(su); su = NULL; //WHERE; is_using_selow = false; } else { //WHERE; is_using_selow = true; } } else { is_using_selow = false; } if (su_adapter_list != NULL) { // If 1 or more adapters are enumerated by SeLow, create adapter list object UINT i; for (i = 0;i < LIST_NUM(su_adapter_list);i++) { SU_ADAPTER_LIST *t = LIST_DATA(su_adapter_list, i); WP_ADAPTER *a = ZeroMalloc(sizeof(WP_ADAPTER)); StrCpy(a->Name, sizeof(a->Name), t->Name); StrCpy(a->Guid, sizeof(a->Guid), t->Guid); StrCpy(a->Title, sizeof(a->Title), t->Info.FriendlyName); TrimCrlf(a->Title); Trim(a->Title); TrimCrlf(a->Title); Trim(a->Title); if (EndWith(a->Title, qos_tag)) { a->Title[StrLen(a->Title) - StrLen(qos_tag)] = 0; TrimCrlf(a->Title); Trim(a->Title); TrimCrlf(a->Title); Trim(a->Title); } Add(o, a); } } else { // When SeLow is not used, create adapter list with SEE or WinPcap if (wp->PacketGetAdapterNames(buf, &size) == false) { Free(buf); return o; } i = 0; if (OS_IS_WINDOWS_NT(GetOsInfo()->OsType)) { // Windows NT if (size >= 2 && buf[0] != 0 && buf[1] != 0) { goto ANSI_STR; } while (true) { wchar_t tmp[MAX_SIZE]; WP_ADAPTER *a; UniStrCpy(tmp, sizeof(tmp), L""); if (*((wchar_t *)(&buf[i])) == 0) { i += sizeof(wchar_t); break; } for (;*((wchar_t *)(&buf[i])) != 0;i += sizeof(wchar_t)) { wchar_t str[2]; str[0] = *((wchar_t *)(&buf[i])); str[1] = 0; UniStrCat(tmp, sizeof(tmp), str); } i += sizeof(wchar_t); a = ZeroMalloc(sizeof(WP_ADAPTER)); UniToStr(a->Name, sizeof(a->Name), tmp); Add(o, a); } } else { // Windows 9x ANSI_STR: while (true) { char tmp[MAX_SIZE]; WP_ADAPTER *a; StrCpy(tmp, sizeof(tmp), ""); if (*((char *)(&buf[i])) == 0) { i += sizeof(char); break; } for (;*((char *)(&buf[i])) != 0;i += sizeof(char)) { char str[2]; str[0] = *((char *)(&buf[i])); str[1] = 0; StrCat(tmp, sizeof(tmp), str); } i += sizeof(char); a = ZeroMalloc(sizeof(WP_ADAPTER)); StrCpy(a->Name, sizeof(a->Name), tmp); Add(o, a); } } for (j = 0;j < LIST_NUM(o);j++) { WP_ADAPTER *a = LIST_DATA(o, j); StrCpy(a->Title, sizeof(a->Title), &buf[i]); i += StrSize(a->Title); // If device description is "Unknown" in Win9x, skip 1 byte if (OS_IS_WINDOWS_9X(GetOsInfo()->OsType)) { if (StrCmp(a->Title, "Unknown") == 0) { if (buf[i] == 0) { i+=sizeof(char); } } } TrimCrlf(a->Title); Trim(a->Title); TrimCrlf(a->Title); Trim(a->Title); if (EndWith(a->Title, qos_tag)) { a->Title[StrLen(a->Title) - StrLen(qos_tag)] = 0; TrimCrlf(a->Title); Trim(a->Title); TrimCrlf(a->Title); Trim(a->Title); } } } for (j = 0;j < LIST_NUM(o);j++) { // Extract GUID WP_ADAPTER *a = LIST_DATA(o, j); if (IsEmptyStr(a->Guid)) { StrCpy(a->Guid, sizeof(a->Guid), a->Name); ReplaceStr(a->Guid, sizeof(a->Guid), a->Guid, "\\Device\\SEE_", ""); ReplaceStr(a->Guid, sizeof(a->Guid), a->Guid, "\\Device\\NPF_", ""); ReplaceStr(a->Guid, sizeof(a->Guid), a->Guid, "\\Device\\PCD_", ""); } } // Sort if (su_adapter_list != NULL) { // Since adapter list made by SeLow is already sorted, don't sort here Sort(o); } ret = NewListFast(CompareWpAdapter); for (i = 0;i < LIST_NUM(o);i++) { WP_ADAPTER *a = LIST_DATA(o, i); ADAPTER *ad; bool is_ethernet = false; bool ok = false; if (SearchStrEx(a->Title, "ppp", 0, false) != INFINITE || SearchStrEx(a->Title, "wan", 0, false) != INFINITE || SearchStrEx(a->Title, "dialup", 0, false) != INFINITE || SearchStrEx(a->Title, "pptp", 0, false) != INFINITE || SearchStrEx(a->Title, "telepho", 0, false) != INFINITE || SearchStrEx(a->Title, "modem", 0, false) != INFINITE || SearchStrEx(a->Title, "ras", 0, false) != INFINITE) { Free(a); continue; } // Determine whether the adapter type is Ethernet if (su == NULL) { // Determine with See ad = wp->PacketOpenAdapter(a->Name); if (ad != NULL) { NetType type; if (wp->PacketGetNetType(ad, &type)) { if (type.LinkType == 0) { is_ethernet = true; } } wp->PacketCloseAdapter(ad); } } else { // In using SeLow, all devices should be Ethernet device is_ethernet = true; } if (is_ethernet) { // Add only Ethernet device char tmp[MAX_SIZE]; UINT k; StrCpy(tmp, sizeof(tmp), a->Title); for (k = 0;;k++) { if (k == 0) { StrCpy(tmp, sizeof(tmp), a->Title); } else { Format(tmp, sizeof(tmp), "%s (%u)", a->Title, k + 1); } ok = true; for (j = 0;j < LIST_NUM(ret);j++) { WP_ADAPTER *aa = LIST_DATA(ret, j); if (StrCmpi(aa->Title, tmp) == 0) { ok = false; } } if (ok) { break; } } StrCpy(a->Title, sizeof(a->Title), tmp); a->Id = Win32EthGenIdFromGuid(a->Guid); Add(ret, a); } if (ok == false) { Free(a); } } Free(buf); Sort(ret); ReleaseList(o); if (su != NULL) { SuFreeAdapterList(su_adapter_list); SuFree(su); } return ret; }
bool CfgSaveExW3(CFG_RW *rw, FOLDER *f, wchar_t *name, UINT *written_size, bool write_binary) { wchar_t tmp[MAX_SIZE]; bool text = !write_binary; UCHAR hash[SHA1_SIZE]; BUF *b; IO *o; bool ret = true; UINT dummy_int = 0; // Validate arguments if (name == NULL || f == NULL) { return false; } if (written_size == NULL) { written_size = &dummy_int; } // Convert to buffer b = CfgFolderToBuf(f, text); if (b == NULL) { return false; } // Hash the contents Hash(hash, b->Buf, b->Size, true); // Compare the contents to be written with the content which was written last if (rw != NULL) { if (Cmp(hash, rw->LashHash, SHA1_SIZE) == 0) { // Contents are not changed ret = false; } else { Copy(rw->LashHash, hash, SHA1_SIZE); } } if (ret || OS_IS_UNIX(GetOsInfo()->OsType)) { // Generate a temporary file name UniFormat(tmp, sizeof(tmp), L"%s.log", name); // Copy the file that currently exist to a temporary file FileCopyW(name, tmp); // Save the new file o = FileCreateW(name); if (o != NULL) { if (FileWrite(o, b->Buf, b->Size) == false) { // File saving failure FileClose(o); FileDeleteW(name); FileRenameW(tmp, name); if (rw != NULL) { Zero(rw->LashHash, sizeof(rw->LashHash)); } } else { // Successful saving file FileClose(o); // Delete the temporary file FileDeleteW(tmp); } } else { // File saving failure FileRenameW(tmp, name); if (rw != NULL) { Zero(rw->LashHash, sizeof(rw->LashHash)); } } } *written_size = b->Size; // Release memory FreeBuf(b); return ret; }
static DWORD ParseJoinArgs( IN int argc, IN const char *argv[], OUT PJOIN_ARGS pArgs ) { DWORD dwError = 0; PCSTR programName = NULL; PCSTR option = NULL; LW_ARGV_CURSOR cursor; SHOW_USAGE_CALLBACK ShowUsageHelp = ShowJoinUsageHelp; SHOW_USAGE_CALLBACK ShowUsageError = ShowJoinUsageError; memset(pArgs, 0, sizeof(*pArgs)); LwArgvCursorInit(&cursor, argc, argv); programName = LwArgvCursorPop(&cursor); // Process options: for (;;) { option = PopNextOption(&cursor); if (!option) { break; } else if (IsHelpOption(option)) { ShowUsageHelp(programName); } else if (!strcmp("--name", option)) { dwError = GetOptionValue(programName, ShowUsageError, &cursor, option, &pArgs->pszMachineName); GOTO_CLEANUP_ON_WINERROR(dwError); } else if (!strcmp("--dnssuffix", option)) { dwError = GetOptionValue(programName, ShowUsageError, &cursor, option, &pArgs->pszDnsSuffix); GOTO_CLEANUP_ON_WINERROR(dwError); } else if (!strcmp("--ou", option)) { dwError = GetOptionValue(programName, ShowUsageError, &cursor, option, &pArgs->pszOu); GOTO_CLEANUP_ON_WINERROR(dwError); } else if (!strcmp("--osname", option)) { dwError = GetOptionValue(programName, ShowUsageError, &cursor, option, &pArgs->pszOsName); GOTO_CLEANUP_ON_WINERROR(dwError); } else if (!strcmp("--osversion", option)) { dwError = GetOptionValue(programName, ShowUsageError, &cursor, option, &pArgs->pszOsVersion); GOTO_CLEANUP_ON_WINERROR(dwError); } else if (!strcmp("--osservicepack", option)) { dwError = GetOptionValue(programName, ShowUsageError, &cursor, option, &pArgs->pszOsServicePack); GOTO_CLEANUP_ON_WINERROR(dwError); } else if (!strcmp("--notimesync", option)) { SetFlag(pArgs->JoinFlags, LSA_NET_JOIN_DOMAIN_NOTIMESYNC); } else if (!strcmp("--multiple", option)) { SetFlag(pArgs->JoinFlags, LSA_NET_JOIN_DOMAIN_NOTIMESYNC); SetFlag(pArgs->JoinFlags, LSA_NET_JOIN_DOMAIN_MULTIPLE); } else { fprintf(stderr, "Unrecognized option: %s\n", option); ShowUsageError(programName); } } // Process arguments: dwError = GetArgumentValue(programName, ShowUsageError, &cursor, "DOMAIN", &pArgs->pszDomain); GOTO_CLEANUP_ON_WINERROR(dwError); LwStrToUpper(pArgs->pszDomain); dwError = GetArgumentValue(programName, ShowUsageError, &cursor, "USERNAME", &pArgs->pszUsername); GOTO_CLEANUP_ON_WINERROR(dwError); // Optional argument dwError = GetArgumentValue(programName, ShowUsageError, &cursor, NULL, &pArgs->pszPassword); assert(!dwError); if (LwArgvCursorRemaining(&cursor)) { fprintf(stderr, "Too many arguments.\n"); ShowUsageError(programName); } // Initialize missing options as needed if (!pArgs->pszDnsSuffix) { dwError = LwAllocateString(pArgs->pszDomain, &pArgs->pszDnsSuffix); GOTO_CLEANUP_ON_WINERROR(dwError); } LwStrToLower(pArgs->pszDnsSuffix); if (!pArgs->pszMachineName) { dwError = GetHostname(&pArgs->pszMachineName); GOTO_CLEANUP_ON_WINERROR(dwError); } if (!pArgs->pszOsName || !pArgs->pszOsVersion || !pArgs->pszOsServicePack) { dwError = GetOsInfo( pArgs->pszOsName ? NULL : &pArgs->pszOsName, pArgs->pszOsVersion ? NULL : &pArgs->pszOsVersion, pArgs->pszOsServicePack ? NULL : &pArgs->pszOsServicePack); GOTO_CLEANUP_ON_WINERROR(dwError); } dwError = CleanupUsername(pArgs->pszDomain, &pArgs->pszUsername); GOTO_CLEANUP_ON_WINERROR(dwError); if (!pArgs->pszPassword) { dwError = PromptPassword(pArgs->pszUsername, &pArgs->pszPassword); GOTO_CLEANUP_ON_WINERROR(dwError); } cleanup: if (dwError) { FreeJoinArgsContents(pArgs); } return dwError; }
bool CreateLinkInner(wchar_t *filename, wchar_t *target, wchar_t *workdir, wchar_t *args, wchar_t *comment, wchar_t *icon, UINT icon_index) { HRESULT r; bool ret; IShellLinkW* pShellLink; IPersistFile* pPersistFile; if (OS_IS_WINDOWS_9X(GetOsInfo()->OsType)) { char *a1, *a2, *a3, *a4, *a5, *a6; a1 = CopyUniToStr(filename); a2 = CopyUniToStr(target); a3 = CopyUniToStr(workdir); a4 = CopyUniToStr(args); a5 = CopyUniToStr(icon); a6 = CopyUniToStr(comment); ret = CreateLinkInnerA(a1, a2, a3, a4, a6, a5, icon_index); Free(a1); Free(a2); Free(a3); Free(a4); Free(a5); Free(a6); return ret; } r = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLinkW, (void **)&pShellLink); if (FAILED(r)) { return false; } r = pShellLink->QueryInterface(IID_IPersistFile,(void **)&pPersistFile); if (FAILED(r)) { pShellLink->Release(); return false; } r = pShellLink->SetPath(target); if (FAILED(r)) { pShellLink->Release(); pPersistFile->Release(); return false; } if (workdir != NULL) { r = pShellLink->SetWorkingDirectory(workdir); if (FAILED(r)) { pShellLink->Release(); pPersistFile->Release(); return false; } } if (comment != NULL) { r = pShellLink->SetDescription(comment); if (FAILED(r)) { pShellLink->Release(); pPersistFile->Release(); return false; } } if (args != NULL) { r = pShellLink->SetArguments(args); if (FAILED(r)) { pShellLink->Release(); pPersistFile->Release(); return false; } } if (icon != NULL) { r = pShellLink->SetIconLocation(icon, icon_index); if (FAILED(r)) { pShellLink->Release(); pPersistFile->Release(); return false; } } r = pPersistFile->Save(filename, true); if (FAILED(r)) { pShellLink->Release(); pPersistFile->Release(); return false; } pShellLink->Release(); pPersistFile->Release(); return true; }
// Reading the Unicode cache bool LoadUnicodeCache(wchar_t *strfilename, UINT strfilesize, UCHAR *hash) { UNICODE_CACHE c, t; BUF *b; UINT i, num; IO *io; wchar_t name[MAX_PATH]; UCHAR binhash[MD5_SIZE]; UCHAR binhash_2[MD5_SIZE]; // Validate arguments if (strfilename == NULL || hash == NULL) { return false; } GenerateUnicodeCacheFileName(name, sizeof(name), strfilename, strfilesize, hash); io = FileOpenW(name, false); if (io == NULL) { return false; } b = FileToBuf(io); if (b == NULL) { FileClose(io); return false; } SeekBuf(b, 0, 0); FileClose(io); Hash(binhash, b->Buf, b->Size >= MD5_SIZE ? (b->Size - MD5_SIZE) : 0, false); Copy(binhash_2, ((UCHAR *)b->Buf) + (b->Size >= MD5_SIZE ? (b->Size - MD5_SIZE) : 0), MD5_SIZE); if (Cmp(binhash, binhash_2, MD5_SIZE) != 0) { FreeBuf(b); return false; } Zero(&c, sizeof(c)); UniToStr(c.StrFileName, sizeof(c.StrFileName), strfilename); c.StrFileSize = strfilesize; DisableNetworkNameCache(); GetMachineName(c.MachineName, sizeof(c.MachineName)); EnableNetworkNameCache(); c.OsType = GetOsInfo()->OsType; Copy(c.hash, hash, MD5_SIZE); #ifdef OS_UNIX GetCurrentCharSet(c.CharSet, sizeof(c.CharSet)); #else // OS_UNIX { UINT id = MsGetThreadLocale(); Copy(c.CharSet, &id, sizeof(id)); } #endif // OS_UNIX Zero(&t, sizeof(t)); ReadBuf(b, &t, sizeof(t)); if (Cmp(&c, &t, sizeof(UNICODE_CACHE)) != 0) { FreeBuf(b); return false; } num = ReadBufInt(b); FreeTable(); TableList = NewList(CmpTableName); for (i = 0;i < num;i++) { UINT len; TABLE *t = ZeroMalloc(sizeof(TABLE)); len = ReadBufInt(b); t->name = ZeroMalloc(len + 1); ReadBuf(b, t->name, len); len = ReadBufInt(b); t->str = ZeroMalloc(len + 1); ReadBuf(b, t->str, len); len = ReadBufInt(b); t->unistr = ZeroMalloc((len + 1) * sizeof(wchar_t)); ReadBuf(b, t->unistr, len * sizeof(wchar_t)); Add(TableList, t); } FreeBuf(b); Sort(TableList); return true; }
// Get the version information of Windows void Win32GetWinVer(RPC_WINVER *v) { // Validate arguments if (v == NULL) { return; } Zero(v, sizeof(RPC_WINVER)); v->IsWindows = true; if (OS_IS_WINDOWS_NT(GetOsType()) == false) { // Windows 9x OSVERSIONINFO os; Zero(&os, sizeof(os)); os.dwOSVersionInfoSize = sizeof(os); GetVersionEx(&os); v->Build = LOWORD(os.dwBuildNumber); v->VerMajor = os.dwMajorVersion; v->VerMinor = os.dwMinorVersion; Format(v->Title, sizeof(v->Title), "%s %s", GetOsInfo()->OsProductName, GetOsInfo()->OsVersion); Trim(v->Title); } else { // Windows NT 4.0 SP6 or later OSVERSIONINFOEX os; Zero(&os, sizeof(os)); os.dwOSVersionInfoSize = sizeof(os); Win32GetVersionExInternal((LPOSVERSIONINFOA)&os); v->IsNT = true; v->Build = os.dwBuildNumber; v->ServicePack = os.wServicePackMajor; if (os.wProductType != VER_NT_WORKSTATION) { v->IsServer = true; } v->VerMajor = os.dwMajorVersion; v->VerMinor = os.dwMinorVersion; if (GetOsInfo()->OsServicePack == 0) { StrCpy(v->Title, sizeof(v->Title), GetOsInfo()->OsProductName); } else { Format(v->Title, sizeof(v->Title), "%s Service Pack %u", GetOsInfo()->OsProductName, GetOsInfo()->OsServicePack); } Trim(v->Title); if (InStr(GetOsInfo()->OsVersion, "rc") || InStr(GetOsInfo()->OsVersion, "beta")) { v->IsBeta = true; } } }
// Installation of WinPcap void EmInstallWinPcap(HWND hWnd, RPC *r) { wchar_t temp_name[MAX_SIZE]; HGLOBAL g; HINSTANCE h; HRSRC hr; UINT size; void *data; IO *io; // Ask whether the user want to start the installation if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("EM_WPCAP_INSTALL")) == IDNO) { return; } // Generate a temporary file name UniFormat(temp_name, sizeof(temp_name), L"%s\\winpcap_installer.exe", MsGetTempDirW()); // Read from the resource h = GetUiDll(); hr = FindResource(h, MAKEINTRESOURCE(BIN_WINPCAP), "BIN"); if (hr == NULL) { RES_ERROR: MsgBox(hWnd, MB_ICONSTOP, _UU("EM_RESOURCE")); return; } g = LoadResource(h, hr); if (g == NULL) { goto RES_ERROR; } size = SizeofResource(h, hr); data = LockResource(g); if (data == NULL) { goto RES_ERROR; } // Write to a temporary file io = FileCreateW(temp_name); if (io == NULL) { goto RES_ERROR; } FileWrite(io, data, size); FileClose(io); // Run if (RunW(temp_name, NULL, false, true) == false) { // Failure FileDeleteW(temp_name); goto RES_ERROR; } FileDeleteW(temp_name); if (r == NULL) { return; } // Message after the end if (OS_IS_WINDOWS_NT(GetOsInfo()->OsType) == false) { // Need to restart the computer MsgBox(hWnd, MB_ICONINFORMATION, _UU("EM_WPCAP_REBOOT1")); } else { // Need to restart the service if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("EM_WPCAP_REBOOT2")) == IDNO) { // Not restart } else { // Restart RPC_TEST t; RPC_BRIDGE_SUPPORT t2; Zero(&t, sizeof(t)); EcRebootServer(r, &t); SleepThread(500); Zero(&t2, sizeof(t2)); CALL(hWnd, EcGetBridgeSupport(r, &t2)); } } }
// Create a VLAN object VLAN *NewVLan(char *instance_name, VLAN_PARAM *param) { VLAN *v; HANDLE h = INVALID_HANDLE_VALUE; HANDLE e = INVALID_HANDLE_VALUE; char tmp[MAX_SIZE]; char name_upper[MAX_SIZE]; // Validate arguments if (instance_name == NULL) { return NULL; } v = ZeroMalloc(sizeof(VLAN)); if (OS_IS_WINDOWS_9X(GetOsInfo()->OsType)) { v->Win9xMode = true; } // Initialize the name Format(name_upper, sizeof(name_upper), "%s", instance_name); StrUpper(name_upper); v->InstanceName = CopyStr(name_upper); Format(tmp, sizeof(tmp), NDIS_NEO_DEVICE_FILE_NAME, v->InstanceName); v->DeviceNameWin32 = CopyStr(tmp); if (v->Win9xMode == false) { Format(tmp, sizeof(tmp), NDIS_NEO_EVENT_NAME_WIN32, v->InstanceName); v->EventNameWin32 = CopyStr(tmp); } // Connect to the device h = CreateFile(v->DeviceNameWin32, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if (h == INVALID_HANDLE_VALUE) { // Connection failure goto CLEANUP; } if (v->Win9xMode == false) { // Connect to the event e = OpenEvent(SYNCHRONIZE, FALSE, v->EventNameWin32); if (e == INVALID_HANDLE_VALUE) { // Connection failure goto CLEANUP; } } else { OPENVXDHANDLE OpenVxDHandle; DWORD vxd_handle; UINT bytes_returned; OpenVxDHandle = (OPENVXDHANDLE)GetProcAddress(GetModuleHandle("KERNEL32"), "OpenVxDHandle"); // Deliver to the driver by creating an event e = CreateEvent(NULL, FALSE, FALSE, NULL); vxd_handle = (DWORD)OpenVxDHandle(e); DeviceIoControl(h, NEO_IOCTL_SET_EVENT, &vxd_handle, sizeof(DWORD), NULL, 0, &bytes_returned, NULL); } v->Event = e; v->Handle = h; v->GetBuffer = ZeroMalloc(NEO_EXCHANGE_BUFFER_SIZE); v->PutBuffer = ZeroMalloc(NEO_EXCHANGE_BUFFER_SIZE); return v; CLEANUP: if (h != INVALID_HANDLE_VALUE) { CloseHandle(h); } if (e != INVALID_HANDLE_VALUE) { CloseHandle(e); } Free(v->InstanceName); Free(v->EventNameWin32); Free(v->DeviceNameWin32); Free(v); return NULL; }
// Execution of registration UINT DCRegister(DDNS_CLIENT *c, bool ipv6, DDNS_REGISTER_PARAM *p, char *replace_v6) { char *url; char url2[MAX_SIZE]; char url3[MAX_SIZE]; PACK *req, *ret; char key_str[MAX_SIZE]; UCHAR machine_key[SHA1_SIZE]; char machine_key_str[MAX_SIZE]; char machine_name[MAX_SIZE]; BUF *cert_hash; UINT err = ERR_INTERNAL_ERROR; UCHAR key_hash[SHA1_SIZE]; char key_hash_str[MAX_SIZE]; bool use_azure = false; char current_azure_ip[MAX_SIZE]; INTERNET_SETTING t; UINT build = 0; bool use_https = false; bool use_vgs = false; // Validate arguments if (c == NULL) { return ERR_INTERNAL_ERROR; } Zero(current_azure_ip, sizeof(current_azure_ip)); GetCurrentMachineIpProcessHash(machine_key); BinToStr(machine_key_str, sizeof(machine_key_str), machine_key, sizeof(machine_key)); GetMachineHostName(machine_name, sizeof(machine_name)); StrLower(machine_name); if (ipv6 == false) { url = DDNS_URL_V4_GLOBAL; if (IsUseAlternativeHostname()) { url = DDNS_URL_V4_ALT; } } else { url = DDNS_URL_V6_GLOBAL; if (IsUseAlternativeHostname()) { url = DDNS_URL_V6_ALT; } if (replace_v6) { url = replace_v6; } } Zero(&t, sizeof(t)); if (ipv6 == false) { // Proxy Setting Copy(&t, &c->InternetSetting, sizeof(INTERNET_SETTING)); } if (ipv6 == false) { // Get the current status of the VPN Azure Client if (c->Cedar->Server != NULL) { AZURE_CLIENT *ac = c->Cedar->Server->AzureClient; if (ac != NULL) { use_azure = SiIsAzureEnabled(c->Cedar->Server); if (use_azure) { Lock(ac->Lock); { StrCpy(current_azure_ip, sizeof(current_azure_ip), ac->ConnectingAzureIp); } Unlock(ac->Lock); } } } } req = NewPack(); BinToStr(key_str, sizeof(key_str), c->Key, sizeof(c->Key)); StrUpper(key_str); PackAddStr(req, "key", key_str); // Build Number build = c->Cedar->Build; PackAddInt(req, "build", build); PackAddInt(req, "osinfo", GetOsInfo()->OsType); PackAddInt(req, "is_64bit", Is64()); #ifdef OS_WIN32 PackAddInt(req, "is_windows_64bit", MsIs64BitWindows()); #endif // OS_WIN32 PackAddBool(req, "is_softether", true); PackAddBool(req, "is_packetix", false); PackAddStr(req, "machine_key", machine_key_str); PackAddStr(req, "machine_name", machine_name); PackAddInt(req, "lasterror_ipv4", c->Err_IPv4_GetMyIp); PackAddInt(req, "lasterror_ipv6", c->Err_IPv6_GetMyIp); PackAddBool(req, "use_azure", use_azure); PackAddStr(req, "product_str", CEDAR_PRODUCT_STR); PackAddInt(req, "ddns_protocol_version", DDNS_VERSION); if (use_azure) { Debug("current_azure_ip = %s\n", current_azure_ip); PackAddStr(req, "current_azure_ip", current_azure_ip); } HashSha1(key_hash, key_str, StrLen(key_str)); BinToStr(key_hash_str, sizeof(key_hash_str), key_hash, sizeof(key_hash)); StrLower(key_hash_str); if (p != NULL) { if (IsEmptyStr(p->NewHostname) == false) { PackAddStr(req, "new_hostname", p->NewHostname); } } cert_hash = StrToBin(DDNS_CERT_HASH); Format(url2, sizeof(url2), "%s?v=%I64u", url, Rand64()); Format(url3, sizeof(url3), url2, key_hash_str[0], key_hash_str[1], key_hash_str[2], key_hash_str[3]); if (use_https == false) { ReplaceStr(url3, sizeof(url3), url3, "https://", "http://"); } ReplaceStr(url3, sizeof(url3), url3, ".servers", ".open.servers"); Debug("WpcCall: %s\n", url3); ret = WpcCallEx(url3, &t, DDNS_CONNECT_TIMEOUT, DDNS_COMM_TIMEOUT, "register", req, NULL, NULL, ((cert_hash != NULL && cert_hash->Size == SHA1_SIZE) ? cert_hash->Buf : NULL), NULL, DDNS_RPC_MAX_RECV_SIZE); Debug("WpcCall Ret: %u\n", ret); FreeBuf(cert_hash); FreePack(req); err = GetErrorFromPack(ret); ExtractAndApplyDynList(ret); // Status update Lock(c->Lock); { if (err == ERR_NO_ERROR) { char snat_t[MAX_SIZE]; char current_region[128]; // Current host name PackGetStr(ret, "current_hostname", c->CurrentHostName, sizeof(c->CurrentHostName)); PackGetStr(ret, "current_fqdn", c->CurrentFqdn, sizeof(c->CurrentFqdn)); PackGetStr(ret, "current_ipv4", c->CurrentIPv4, sizeof(c->CurrentIPv4)); PackGetStr(ret, "current_ipv6", c->CurrentIPv6, sizeof(c->CurrentIPv6)); PackGetStr(ret, "dns_suffix", c->DnsSuffix, sizeof(c->DnsSuffix)); PackGetStr(ret, "current_region", current_region, sizeof(current_region)); // SecureNAT connectivity check parameters Zero(snat_t, sizeof(snat_t)); PackGetStr(ret, "snat_t", snat_t, sizeof(snat_t)); NnSetSecureNatTargetHostname(snat_t); if (ipv6 == false) { char cert_hash[MAX_SIZE]; PackGetStr(ret, "current_azure_ip", c->CurrentAzureIp, sizeof(c->CurrentAzureIp)); c->CurrentAzureTimestamp = PackGetInt64(ret, "current_azure_timestamp"); PackGetStr(ret, "current_azure_signature", c->CurrentAzureSignature, sizeof(c->CurrentAzureSignature)); Zero(cert_hash, sizeof(cert_hash)); PackGetStr(ret, "azure_cert_hash", cert_hash, sizeof(cert_hash)); if (IsEmptyStr(cert_hash) == false) { StrCpy(c->AzureCertHash, sizeof(c->AzureCertHash), cert_hash); } } StrCpy(c->Cedar->CurrentDDnsFqdn, sizeof(c->Cedar->CurrentDDnsFqdn), c->CurrentFqdn); Debug("current_hostname=%s, current_fqdn=%s, current_ipv4=%s, current_ipv6=%s, current_azure_ip=%s, CurrentAzureTimestamp=%I64u, CurrentAzureSignature=%s, CertHash=%s\n", c->CurrentHostName, c->CurrentFqdn, c->CurrentIPv4, c->CurrentIPv6, c->CurrentAzureIp, c->CurrentAzureTimestamp, c->CurrentAzureSignature, c->AzureCertHash); if (IsEmptyStr(current_region) == false) { // Update the current region SiUpdateCurrentRegion(c->Cedar, current_region, false); } } } Unlock(c->Lock); if (IsEmptyStr(c->CurrentFqdn) == false) { SetCurrentDDnsFqdn(c->CurrentFqdn); } FreePack(ret); UniDebug(L"DCRegister Error: %s\n", _E(err)); if (err == ERR_DUPLICATE_DDNS_KEY) { // Key duplication DCGenNewKey(c->Key); c->KeyChanged = true; } if (err == ERR_DISCONNECTED) { err = ERR_DDNS_DISCONNECTED; } if (IsUseAlternativeHostname() == false) { if (err == ERR_CONNECT_FAILED) { if (ipv6 && replace_v6 == NULL) { UINT type = DetectFletsType(); if (type & FLETS_DETECT_TYPE_EAST_BFLETS_PRIVATE && err != ERR_NO_ERROR) { err = DCRegister(c, ipv6, p, DDNS_REPLACE_URL_FOR_EAST_BFLETS); } if (type & FLETS_DETECT_TYPE_EAST_NGN_PRIVATE && err != ERR_NO_ERROR) { err = DCRegister(c, ipv6, p, DDNS_REPLACE_URL_FOR_EAST_NGN); } if (type & FLETS_DETECT_TYPE_WEST_NGN_PRIVATE && err != ERR_NO_ERROR) { err = DCRegister(c, ipv6, p, DDNS_REPLACE_URL_FOR_WEST_NGN); } } } } return err; }