// 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;
}
