simplednsclient.cpp

发送邮件

                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;

            // X25 
            case DNS_TYPE_X25:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.X25.pStringArray[1], szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;

            // NXT (next record, see RFC 2065, Secure negative response)
            case DNS_TYPE_NXT:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.NXT.pNameNext, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;

            // SRV (service record, see RFC 2052, Service location)
            case DNS_TYPE_SRV:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.SRV.pNameTarget, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;

            // Null 
            case DNS_TYPE_NULL:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, "NULL" /*pDnsRecords->Data.Null.Data[1]*/, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;

            // WKS (well-known services)
            case DNS_TYPE_WKS:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            CString szWKS = CInternetStandards::GetProtocolNameFromID(pDnsRecords->Data.WKS.chProtocol);
                            szWKS += ":";
                            IN_ADDR ipaddr;
                            ipaddr.S_un.S_addr = (pDnsRecords->Data.WKS.IpAddress);
                            szWKS += inet_ntoa(ipaddr);
                            AppendResult(wType, pDnsRecords->wType, szWKS, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;

/*


            // TKEY (TKEY record, used to establish and delete shared-secret keys between a DNS resolver and server)
            case DNS_TYPE_TKEY:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.TKEY.pNameAlgorithm, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;
            // TSIG (secret key transaction authentication record)
            case DNS_TYPE_TSIG:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.TSIG.pNameAlgorithm, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;
            // KEY (key record, see RFC 2065, DNS security)
            case DNS_TYPE_KEY:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.KEY.?, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;
            // SIG (signature, see RFC 2065, DNS security)
            case DNS_TYPE_SIG:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.SIG.pNameSigner, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;
            // ATMA (ATM address)
            case DNS_TYPE_ATMA:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.ATMA.Address, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;
            

            // AAAA (IP v6 address)
            case DNS_TYPE_AAAA:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.AAAA.Ip6Address, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;
            // WINS (Windows Internet Name Service record)
            case DNS_TYPE_WINS:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.WINS.WinsServers[1], szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;
            // WINSR (Windows Internet Name Service reverse-lookup record)
            case DNS_TYPE_WINSR:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.WINSR.pNameResultDomain, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;
            // NBSTAT
            case DNS_TYPE_NBSTA:
                {
                    do {
                        if (pDnsRecords->Flags.S.Section == DNSREC_ANSWER) {
                            AppendResult(wType, pDnsRecords->wType, pDnsRecords->Data.NBSTA.?, szFoundNames);
                        }
                        pDnsRecords = pDnsRecords->pNext;
                    } while (pDnsRecords);
                }
                break;

                */
            default:
                {
                    SetLastError(ERROR_NOT_SUPPORTED);
                    DWORD dwLastError = GetLastError();
                    SetError("DNS type not supported: ",dwLastError);
                    hReturnCode = HRESULT_FROM_WIN32(dwLastError);
                }
                break;
            }
        }

    }

    // Set output variable
    if (pvFoundNames) {
        _variant_t vFoundNames;
        vFoundNames.SetString((LPCTSTR)szFoundNames);
        *pvFoundNames = vFoundNames.Detach();
    }

    // Cleanup
    if (pDnsRecords) {
        DNS_FREE_TYPE freetype = DnsFreeRecordListDeep;
        DnsRecordListFree(pDnsRecords, freetype);
        pDnsRecords = NULL;
    }
    if (pSrvList) {
        LocalFree(pSrvList);
        pSrvList = NULL;
    }
	return hReturnCode;
}

STDMETHODIMP CSimpleDNSClient::GetDNSDomain(VARIANT *pvDNSDomainName)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

    HKEY hKey = NULL;
    CString szDNSDomain;
    LONG nResult = S_OK;

    CString szDomainKeys[] = {
        "Domain",
        "DhcpDomain"
    };

    // Find DNS domain with IP Helper API (function GetNetworkParams)
    // CAUTION: this code should run on Windows 2000 and Windows Me only
    PFIXED_INFO pNetInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
    ULONG nNetInfoSize = sizeof(FIXED_INFO);
    DWORD nErrorCode = GetNetworkParams(pNetInfo, &nNetInfoSize);
    if (nErrorCode == ERROR_BUFFER_OVERFLOW) {
        // OK, buffer is too small but function returns the needed size
        GlobalFree(pNetInfo);
        pNetInfo = NULL;
        pNetInfo = (FIXED_INFO *)GlobalAlloc(GPTR, nNetInfoSize);
        nErrorCode = GetNetworkParams(pNetInfo, &nNetInfoSize);
    }
    if (nErrorCode == ERROR_SUCCESS) {

        szDNSDomain = pNetInfo->DomainName;
    
    }

    if (szDNSDomain.GetLength() == 0) {
    
        // Find DNS from Registry HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters
        // CAUTION: this code runs on NT4 only, but it's a good fallback
        nResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                               "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
                               0,
                               KEY_READ,
                               &hKey
                               );

        if (nResult == ERROR_SUCCESS) {

            for (int i=0; i < sizeof(szDomainKeys)/sizeof(szDomainKeys[0]); i++) {
                DWORD dwType;
                BYTE lpData[256];
                DWORD dwDataSize = sizeof(lpData);
                nResult = RegQueryValueEx(hKey,
                                          szDomainKeys[i],
                                          NULL,
                                          &dwType,
                                          lpData,
                                          &dwDataSize
                                          );

                if (nResult == ERROR_SUCCESS) {

                    TCHAR lpszData[256];
                    memcpy((void *)lpszData, (const void *)lpData, dwDataSize);
                    lpszData[dwDataSize] = '\0';

                    szDNSDomain = lpszData;

                } else {

                    szDNSDomain = "";
                    CString szErrorMessage = "Cannot open registry key \"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\" +szDomainKeys[i] + "\":";
                    SetError(szErrorMessage, nResult);

                }

                if (szDNSDomain != "") {
                    break;
                }

            }

        } else {

            szDNSDomain = "";
            CString szErrorMessage = "Cannot open registry key \"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\":";
            SetError(szErrorMessage, nResult);

        }

    }

    // Return value
    if (pvDNSDomainName) {
        _variant_t vDNSDomain;
        vDNSDomain.SetString((LPCTSTR)szDNSDomain);
        *pvDNSDomainName = vDNSDomain.Detach();
    }

    // Cleanup
    if (hKey) {
        RegCloseKey(hKey);
        hKey = NULL;
    }
    if (pNetInfo) {
        GlobalFree(pNetInfo);
        pNetInfo = NULL;
    }

	return HRESULT_FROM_WIN32(nResult);
}

STDMETHODIMP CSimpleDNSClient::FindServerAddresses(VARIANT *pvServerAddresses)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

    CString szServerAddresses = FindAllDNSServers();
    HRESULT hResult = S_OK;

    if (szServerAddresses == "") {
        DWORD dwLastError = GetLastError();
        SetError("Cannot find DNS Servers in registry: ", dwLastError);
        hResult = HRESULT_FROM_WIN32(dwLastError);
    } else {
        hResult = S_OK;
    }

    // Return value
    if (pvServerAddresses) {
        _variant_t vServerAddresses = szServerAddresses;
        *pvServerAddresses = vServerAddresses.Detach();
    }

	return hResult;
}

STDMETHODIMP CSimpleDNSClient::get_Separator(BSTR *pVal)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

    if (pVal) {
        *pVal = _bstr_t(m_szSeparator);
    }

	return S_OK;
}

STDMETHODIMP CSimpleDNSClient::put_Separator(BSTR newVal)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

    _bstr_t BNewVal = newVal;
	m_szSeparator = (LPCTSTR)BNewVal;

	return S_OK;