void OutVhOption(PACK *p, VH_OPTION *t)
{
// Validate arguments
if (t == NULL || p == NULL)
{
return;
}
PackAddData(p, "MacAddress", t->MacAddress, 6);
PackAddIp(p, "Ip", &t->Ip);
PackAddIp(p, "Mask", &t->Mask);
PackAddBool(p, "UseNat", t->UseNat);
PackAddInt(p, "Mtu", t->Mtu);
PackAddInt(p, "NatTcpTimeout", t->NatTcpTimeout);
PackAddInt(p, "NatUdpTimeout", t->NatUdpTimeout);
PackAddBool(p, "UseDhcp", t->UseDhcp);
PackAddIp(p, "DhcpLeaseIPStart", &t->DhcpLeaseIPStart);
PackAddIp(p, "DhcpLeaseIPEnd", &t->DhcpLeaseIPEnd);
PackAddIp(p, "DhcpSubnetMask", &t->DhcpSubnetMask);
PackAddInt(p, "DhcpExpireTimeSpan", t->DhcpExpireTimeSpan);
PackAddIp(p, "DhcpGatewayAddress", &t->DhcpGatewayAddress);
PackAddIp(p, "DhcpDnsServerAddress", &t->DhcpDnsServerAddress);
PackAddIp(p, "DhcpDnsServerAddress2", &t->DhcpDnsServerAddress2);
PackAddStr(p, "DhcpDomainName", t->DhcpDomainName);
PackAddBool(p, "SaveLog", t->SaveLog);
PackAddStr(p, "RpcHubName", t->HubName);
PackAddBool(p, "ApplyDhcpPushRoutes", true);
PackAddStr(p, "DhcpPushRoutes", t->DhcpPushRoutes);
}
// Error code setting
void RpcError(PACK *p, UINT err)
{
// Validate arguments
if (p == NULL)
{
return;
}
PackAddInt(p, "error", 1);
PackAddInt(p, "error_code", err);
}
// エラーコード設定
void RpcError(PACK *p, UINT err)
{
// 引数チェック
if (p == NULL)
{
return;
}
PackAddInt(p, "error", 1);
PackAddInt(p, "error_code", err);
}
void OutRpcNatStatus(PACK *p, RPC_NAT_STATUS *t)
{
// 引数チェック
if (p == NULL || t == NULL)
{
return;
}
PackAddStr(p, "HubName", t->HubName);
PackAddInt(p, "NumTcpSessions", t->NumTcpSessions);
PackAddInt(p, "NumUdpSessions", t->NumUdpSessions);
PackAddInt(p, "NumDhcpClients", t->NumDhcpClients);
}
void OutRpcEnumNat(PACK *p, RPC_ENUM_NAT *t)
{
UINT i;
// Validate arguments
if (t == NULL || p == NULL)
{
return;
}
PackAddInt(p, "NumItem", t->NumItem);
PackAddStr(p, "HubName", t->HubName);
for (i = 0;i < t->NumItem;i++)
{
RPC_ENUM_NAT_ITEM *e = &t->Items[i];
PackAddIntEx(p, "Id", e->Id, i, t->NumItem);
PackAddIntEx(p, "Protocol", e->Protocol, i, t->NumItem);
PackAddIp32Ex(p, "SrcIp", e->SrcIp, i, t->NumItem);
PackAddStrEx(p, "SrcHost", e->SrcHost, i, t->NumItem);
PackAddIntEx(p, "SrcPort", e->SrcPort, i, t->NumItem);
PackAddIp32Ex(p, "DestIp", e->DestIp, i, t->NumItem);
PackAddStrEx(p, "DestHost", e->DestHost, i, t->NumItem);
PackAddIntEx(p, "DestPort", e->DestPort, i, t->NumItem);
PackAddInt64Ex(p, "CreatedTime", e->CreatedTime, i, t->NumItem);
PackAddInt64Ex(p, "LastCommTime", e->LastCommTime, i, t->NumItem);
PackAddInt64Ex(p, "SendSize", e->SendSize, i, t->NumItem);
PackAddInt64Ex(p, "RecvSize", e->RecvSize, i, t->NumItem);
PackAddIntEx(p, "TcpStatus", e->TcpStatus, i, t->NumItem);
}
}
void OutRpcEnumDhcp(PACK *p, RPC_ENUM_DHCP *t)
{
UINT i;
// Validate arguments
if (p == NULL || t == NULL)
{
return;
}
PackAddInt(p, "NumItem", t->NumItem);
PackAddStr(p, "HubName", t->HubName);
for (i = 0;i < t->NumItem;i++)
{
RPC_ENUM_DHCP_ITEM *e = &t->Items[i];
PackAddIntEx(p, "Id", e->Id, i, t->NumItem);
PackAddInt64Ex(p, "LeasedTime", e->LeasedTime, i, t->NumItem);
PackAddInt64Ex(p, "ExpireTime", e->ExpireTime, i, t->NumItem);
PackAddDataEx(p, "MacAddress", e->MacAddress, 6, i, t->NumItem);
PackAddIp32Ex(p, "IpAddress", e->IpAddress, i, t->NumItem);
PackAddIntEx(p, "Mask", e->Mask, i, t->NumItem);
PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumItem);
}
}
void OutRpcNatStatus(PACK *p, RPC_NAT_STATUS *t)
{
// Validate arguments
if (p == NULL || t == NULL)
{
return;
}
PackAddStr(p, "HubName", t->HubName);
PackAddInt(p, "NumTcpSessions", t->NumTcpSessions);
PackAddInt(p, "NumUdpSessions", t->NumUdpSessions);
PackAddInt(p, "NumIcmpSessions", t->NumIcmpSessions);
PackAddInt(p, "NumDnsSessions", t->NumDnsSessions);
PackAddInt(p, "NumDhcpClients", t->NumDhcpClients);
PackAddBool(p, "IsKernelMode", t->IsKernelMode);
}
void OutRpcNatInfo(PACK *p, RPC_NAT_INFO *t)
{
// Validate arguments
if (t == NULL || p == NULL)
{
return;
}
PackAddStr(p, "NatProductName", t->NatProductName);
PackAddStr(p, "NatVersionString", t->NatVersionString);
PackAddStr(p, "NatBuildInfoString", t->NatBuildInfoString);
PackAddInt(p, "NatVerInt", t->NatVerInt);
PackAddInt(p, "NatBuildInt", t->NatBuildInt);
PackAddStr(p, "NatHostName", t->NatHostName);
OutRpcOsInfo(p, &t->OsInfo);
OutRpcMemInfo(p, &t->MemInfo);
}
void OutRpcAddDevice(PACK *p, RPC_ADD_DEVICE *t)
{
UINT i;
// Validate arguments
if (t == NULL || p == NULL)
{
return;
}
PackAddStr(p, "DeviceName", t->DeviceName);
PackAddInt(p, "NoPromiscus", t->NoPromiscus);
PackAddInt(p, "PacketLogSwitchType", t->LogSetting.PacketLogSwitchType);
for (i = 0;i < NUM_PACKET_LOG;i++)
{
PackAddIntEx(p, "PacketLogConfig", t->LogSetting.PacketLogConfig[i], i, NUM_PACKET_LOG);
}
}
void OutRpcDummy(PACK *p, RPC_DUMMY *t)
{
// Validate arguments
if (t == NULL || p == NULL)
{
return;
}
PackAddInt(p, "DummyValue", t->DummyValue);
}
void OutRpcDummy(PACK *p, RPC_DUMMY *t)
{
// 引数チェック
if (t == NULL || p == NULL)
{
return;
}
PackAddInt(p, "DummyValue", t->DummyValue);
}
// RPC server function
PACK *NiRpcServer(RPC *r, char *name, PACK *p)
{
NAT *n = (NAT *)r->Param;
PACK *ret;
UINT err;
bool ok;
// Validate arguments
if (r == NULL || name == NULL || p == NULL)
{
return NULL;
}
ret = NewPack();
err = ERR_NO_ERROR;
ok = false;
if (0) {}
// RPC function definition: From here
// DECLARE_RPC("Online", RPC_DUMMY, NtOnline, InRpcDummy, OutRpcDummy)
// DECLARE_RPC("Offline", RPC_DUMMY, NtOffline, InRpcDummy, OutRpcDummy)
DECLARE_RPC("SetHostOption", VH_OPTION, NtSetHostOption, InVhOption, OutVhOption)
DECLARE_RPC("GetHostOption", VH_OPTION, NtGetHostOption, InVhOption, OutVhOption)
// DECLARE_RPC_EX("SetClientConfig", RPC_CREATE_LINK, NtSetClientConfig, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)
// DECLARE_RPC_EX("GetClientConfig", RPC_CREATE_LINK, NtGetClientConfig, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)
DECLARE_RPC_EX("GetStatus", RPC_NAT_STATUS, NtGetStatus, InRpcNatStatus, OutRpcNatStatus, FreeRpcNatStatus)
// DECLARE_RPC_EX("GetInfo", RPC_NAT_INFO, NtGetInfo, InRpcNatInfo, OutRpcNatInfo, FreeRpcNatInfo)
DECLARE_RPC_EX("EnumNatList", RPC_ENUM_NAT, NtEnumNatList, InRpcEnumNat, OutRpcEnumNat, FreeRpcEnumNat)
DECLARE_RPC_EX("EnumDhcpList", RPC_ENUM_DHCP, NtEnumDhcpList, InRpcEnumDhcp, OutRpcEnumDhcp, FreeRpcEnumDhcp)
// DECLARE_RPC("SetPassword", RPC_SET_PASSWORD, NtSetPassword, InRpcSetPassword, OutRpcSetPassword)
// RPC function definition: To here
if (ok == false)
{
err = ERR_NOT_SUPPORTED;
}
PackAddInt(ret, "error", err);
return ret;
}
// RPC server function
PACK *ElRpcServer(RPC *r, char *name, PACK *p)
{
EL *e = (EL *)r->Param;
PACK *ret;
UINT err;
bool ok;
// Validate arguments
if (r == NULL || name == NULL || p == NULL || e == NULL)
{
return NULL;
}
ret = NewPack();
err = ERR_NO_ERROR;
ok = false;
if (0) {}
DECLARE_RPC("AddDevice", RPC_ADD_DEVICE, EtAddDevice, InRpcAddDevice, OutRpcAddDevice)
DECLARE_RPC("DelDevice", RPC_DELETE_DEVICE, EtDelDevice, InRpcDeleteDevice, OutRpcDeleteDevice)
DECLARE_RPC("SetDevice", RPC_ADD_DEVICE, EtSetDevice, InRpcAddDevice, OutRpcAddDevice)
DECLARE_RPC("GetDevice", RPC_ADD_DEVICE, EtGetDevice, InRpcAddDevice, OutRpcAddDevice)
DECLARE_RPC_EX("EnumDevice", RPC_ENUM_DEVICE, EtEnumDevice, InRpcEnumDevice, OutRpcEnumDevice, FreeRpcEnumDevice)
DECLARE_RPC("SetPassword", RPC_SET_PASSWORD, EtSetPassword, InRpcSetPassword, OutRpcSetPassword)
DECLARE_RPC_EX("EnumAllDevice", RPC_ENUM_DEVICE, EtEnumAllDevice, InRpcEnumDevice, OutRpcEnumDevice, FreeRpcEnumDevice)
DECLARE_RPC("AddLicenseKey", RPC_TEST, EtAddLicenseKey, InRpcTest, OutRpcTest)
DECLARE_RPC("DelLicenseKey", RPC_TEST, EtDelLicenseKey, InRpcTest, OutRpcTest)
DECLARE_RPC_EX("EnumLicenseKey", RPC_ENUM_LICENSE_KEY, EtEnumLicenseKey, InRpcEnumLicenseKey, OutRpcEnumLicenseKey, FreeRpcEnumLicenseKey)
DECLARE_RPC("GetLicenseStatus", RPC_EL_LICENSE_STATUS, EtGetLicenseStatus, InRpcElLicenseStatus, OutRpcElLicenseStatus)
DECLARE_RPC("GetBridgeSupport", RPC_BRIDGE_SUPPORT, EtGetBridgeSupport, InRpcBridgeSupport, OutRpcBridgeSupport)
DECLARE_RPC("RebootServer", RPC_TEST, EtRebootServer, InRpcTest, OutRpcTest)
if (ok == false)
{
err = ERR_NOT_SUPPORTED;
}
PackAddInt(ret, "error", err);
return ret;
}
void OutRpcEnumDevice(PACK *p, RPC_ENUM_DEVICE *t)
{
UINT i;
// Validate arguments
if (t == NULL || p == NULL)
{
return;
}
PackAddInt(p, "NumItem", t->NumItem);
for (i = 0;i < t->NumItem;i++)
{
RPC_ENUM_DEVICE_ITEM *d = &t->Items[i];
PackAddStrEx(p, "DeviceName", d->DeviceName, i, t->NumItem);
PackAddBoolEx(p, "Active", d->Active, i, t->NumItem);
}
PackAddBool(p, "IsLicenseSupported", t->IsLicenseSupported);
}
// 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;
}
// RPC call
PACK *RpcCall(RPC *r, char *function_name, PACK *p)
{
PACK *ret;
UINT num_retry = 0;
UINT err = 0;
// Validate arguments
if (r == NULL || function_name == NULL)
{
return NULL;
}
// Debug("RpcCall: %s\n", function_name);
Lock(r->Lock);
{
if (p == NULL)
{
p = NewPack();
}
PackAddStr(p, "function_name", function_name);
RETRY:
err = 0;
ret = RpcCallInternal(r, p);
if (ret == NULL)
{
if (r->IsVpnServer && r->Sock != NULL)
{
if (num_retry < 1)
{
num_retry++;
// Attempt to reconnect the RPC to the VPN Server
err = AdminReconnect(r);
if (err == ERR_NO_ERROR)
{
goto RETRY;
}
}
}
}
FreePack(p);
if (ret == NULL)
{
if (err == 0)
{
err = ERR_DISCONNECTED;
}
ret = PackError(err);
PackAddInt(ret, "error_code", err);
}
}
Unlock(r->Lock);
return ret;
}
