You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1412 lines
43 KiB
1412 lines
43 KiB
//-----------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: D L G A D D R . C P P
|
|
//
|
|
// Contents: CTcpAddrPage implementation
|
|
//
|
|
// Notes: CTcpAddrPage is the IP Address page
|
|
//
|
|
// Author: tongl 5 Nov, 1997
|
|
//-----------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
#include "tcpipobj.h"
|
|
#include "dlgaddr.h"
|
|
|
|
#include "resource.h"
|
|
#include "tcpconst.h"
|
|
#include "tcperror.h"
|
|
#include "tcphelp.h"
|
|
#include "tcputil.h"
|
|
|
|
#include "ncatlui.h"
|
|
#include "ncstl.h"
|
|
#include "ncui.h"
|
|
#include "ncsvc.h"
|
|
#include "ncperms.h"
|
|
|
|
#include "dlgaddrm.h"
|
|
#include "dlgdns.h"
|
|
#include "dlgwins.h"
|
|
#include "dlgatm.h"
|
|
#include "dlgopt.h"
|
|
#include "dlgras.h"
|
|
|
|
CTcpAddrPage::CTcpAddrPage(CTcpipcfg * ptcpip, const DWORD * adwHelpIDs) :
|
|
m_pageBackup(ptcpip, g_aHelpIDS_IDD_BACK_UP),
|
|
m_hBackupPage(NULL)
|
|
{
|
|
Assert(ptcpip);
|
|
m_ptcpip = ptcpip;
|
|
m_adwHelpIDs = adwHelpIDs;
|
|
m_pAdapterInfo = ptcpip->GetConnectionAdapterInfo();
|
|
|
|
m_fModified = FALSE;
|
|
m_fWarnedDisjointGw = FALSE;
|
|
m_fWarnedMismatchIPandGw = FALSE;
|
|
|
|
m_fPropShtOk = FALSE;
|
|
m_fPropShtModified = FALSE;
|
|
m_fLmhostsFileReset = FALSE;
|
|
|
|
//IPSec is removed from connection UI
|
|
// m_fIpsecPolicySet = FALSE;
|
|
|
|
m_ConnType = m_ptcpip->GetConnectionType();
|
|
Assert(m_ConnType != CONNECTION_UNSET);
|
|
|
|
m_fRasNotAdmin = m_ptcpip->IsRasNotAdmin();
|
|
|
|
m_pIpSettingsPage = NULL;
|
|
m_pTcpDnsPage = NULL;
|
|
m_pTcpWinsPage = NULL;
|
|
m_pAtmArpcPage = NULL;
|
|
m_pTcpOptionsPage = NULL;
|
|
m_pTcpRasPage = NULL;
|
|
}
|
|
|
|
CTcpAddrPage::~CTcpAddrPage()
|
|
{
|
|
FreeCollectionAndItem(m_vstrWarnedDupIpList);
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnInitDialog(UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam, BOOL& fHandled)
|
|
{
|
|
// limit the field ranges for the address fields
|
|
m_ipAddress.Create(m_hWnd, IDC_IPADDR_IP);
|
|
m_ipAddress.SetFieldRange(0, c_iIPADDR_FIELD_1_LOW, c_iIPADDR_FIELD_1_HIGH);
|
|
|
|
m_ipDnsPrimary.Create(m_hWnd, IDC_DNS_PRIMARY);
|
|
m_ipDnsPrimary.SetFieldRange(0, c_iIPADDR_FIELD_1_LOW, c_iIPADDR_FIELD_1_HIGH);
|
|
|
|
m_ipDnsSecondary.Create(m_hWnd, IDC_DNS_SECONDARY);
|
|
m_ipDnsSecondary.SetFieldRange(0, c_iIPADDR_FIELD_1_LOW, c_iIPADDR_FIELD_1_HIGH);
|
|
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
// these are for Lan connections only
|
|
m_ipSubnetMask.Create(m_hWnd, IDC_IPADDR_SUB);
|
|
|
|
m_ipDefGateway.Create(m_hWnd, IDC_IPADDR_GATE);
|
|
m_ipDefGateway.SetFieldRange(0, c_iIPADDR_FIELD_1_LOW, c_iIPADDR_FIELD_1_HIGH);
|
|
}
|
|
|
|
if (!FHasPermission(NCPERM_AllowAdvancedTCPIPConfig))
|
|
{
|
|
::EnableWindow(GetDlgItem(IDC_IPADDR_ADVANCED), FALSE);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnContextMenu(UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam, BOOL& fHandled)
|
|
{
|
|
ShowContextHelp(m_hWnd, HELP_CONTEXTMENU, m_adwHelpIDs);
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnHelp(UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam, BOOL& fHandled)
|
|
{
|
|
LPHELPINFO lphi = reinterpret_cast<LPHELPINFO>(lParam);
|
|
Assert(lphi);
|
|
|
|
if (HELPINFO_WINDOW == lphi->iContextType)
|
|
{
|
|
ShowContextHelp(static_cast<HWND>(lphi->hItemHandle), HELP_WM_HELP,
|
|
m_adwHelpIDs);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnActive(int idCtrl, LPNMHDR pnmh, BOOL& fHandled)
|
|
{
|
|
m_fSetInitialValue = TRUE;
|
|
SetInfo();
|
|
m_fSetInitialValue = FALSE;
|
|
|
|
::SetWindowLongPtr(m_hWnd, DWLP_MSGRESULT, 0);
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnKillActive(int idCtrl, LPNMHDR pnmh, BOOL& fHandled)
|
|
{
|
|
// All error values are loaded and then checked here
|
|
// while all non-error values are checked in OnApply
|
|
|
|
BOOL fError = FALSE; // Allow page to lose active status
|
|
HWND hWndFocus = 0;
|
|
|
|
|
|
// If the ip address and subnet mask on this page mismatch,
|
|
// just raise error and do not update the UI
|
|
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
if (m_ipAddress.IsBlank() && !m_ipSubnetMask.IsBlank())
|
|
{
|
|
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_NO_IP,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipAddress;
|
|
fError = TRUE;
|
|
}
|
|
else if (!m_ipAddress.IsBlank() && m_ipSubnetMask.IsBlank())
|
|
{
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_NOSUBNET,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipSubnetMask;
|
|
fError = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!m_ipDnsPrimary.IsBlank() && !m_ipDnsSecondary.IsBlank())
|
|
{
|
|
tstring strPrimaryDns;
|
|
tstring strSecondDns;
|
|
|
|
m_ipDnsPrimary.GetAddress(&strPrimaryDns);
|
|
m_ipDnsSecondary.GetAddress(&strSecondDns);
|
|
if (strPrimaryDns == strSecondDns)
|
|
{
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_DUP_SECOND_DNS,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
hWndFocus = (HWND) m_ipDnsSecondary;
|
|
fError = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
// Now, update in memory structure
|
|
if (!fError)
|
|
{
|
|
UpdateInfo();
|
|
|
|
if (m_ConnType != CONNECTION_LAN)
|
|
{
|
|
if (!m_pAdapterInfo->m_fEnableDhcp)
|
|
{
|
|
// simply make sure ip address is not empty for RAS connections
|
|
if (!m_pAdapterInfo->m_vstrIpAddresses.size())
|
|
{
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_NO_IP,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipAddress;
|
|
fError = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DWORD ardwIp[4];
|
|
GetNodeNum(m_pAdapterInfo->m_vstrIpAddresses[0]->c_str(), ardwIp);
|
|
if (ardwIp[0] > c_iIPADDR_FIELD_1_HIGH || ardwIp[0] < c_iIPADDR_FIELD_1_LOW)
|
|
{
|
|
IPAlertPrintf(m_hWnd, IDS_INCORRECT_IP_FIELD_1,
|
|
ardwIp[0],
|
|
c_iIPADDR_FIELD_1_LOW, c_iIPADDR_FIELD_1_HIGH);
|
|
|
|
hWndFocus = (HWND) m_ipAddress;
|
|
fError = TRUE;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else // for Lan connections
|
|
{
|
|
// Check validate IP address and duplication on each card before
|
|
// allowing the page to lose focus
|
|
|
|
IP_VALIDATION_ERR err;
|
|
|
|
// Validate IP Address for adapter used in this connection
|
|
if ((err = ValidateIp(m_pAdapterInfo)) != ERR_NONE)
|
|
{
|
|
switch(err)
|
|
{
|
|
case ERR_HOST_ALL0:
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_HOST_ALL_0,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipAddress;
|
|
break;
|
|
case ERR_HOST_ALL1:
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_HOST_ALL_1,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipAddress;
|
|
break;
|
|
|
|
case ERR_SUBNET_ALL0:
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_SUBNET_ALL_0,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipSubnetMask;
|
|
break;
|
|
case ERR_NO_IP:
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_NO_IP,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipAddress;
|
|
break;
|
|
|
|
case ERR_NO_SUBNET:
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_NOSUBNET,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipSubnetMask;
|
|
break;
|
|
|
|
case ERR_UNCONTIGUOUS_SUBNET:
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_ERROR_UNCONTIGUOUS_SUBNET,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipSubnetMask;
|
|
break;
|
|
|
|
default:
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INCORRECT_IPADDRESS,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hWndFocus = (HWND) m_ipAddress;
|
|
break;
|
|
}
|
|
|
|
fError = TRUE;
|
|
}
|
|
|
|
if ((!fError) && (!m_pAdapterInfo->m_fEnableDhcp))
|
|
{
|
|
// Check ip address duplicates between this adapter and any other
|
|
// enabled LAN adapters in our first memory list
|
|
|
|
// same adapter
|
|
if (FHasDuplicateIp(m_pAdapterInfo))
|
|
{
|
|
// duplicate IP address on same adapter is an error
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_DUPLICATE_IP_ERROR,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
fError = TRUE;
|
|
}
|
|
|
|
// check the IP address and the static gateway are in the same subnet
|
|
// Multip IP and multiple gateways will show up on both general page
|
|
// and the advanced page.
|
|
// To avoid confusing error messages, we only do this validation when
|
|
// there is only one IP address and one gateway.
|
|
if (!fError && !m_fWarnedMismatchIPandGw &&
|
|
1 == m_pAdapterInfo->m_vstrIpAddresses.size() &&
|
|
1 == m_pAdapterInfo->m_vstrDefaultGateway.size() &&
|
|
1 == m_pAdapterInfo->m_vstrSubnetMask.size())
|
|
{
|
|
if (!FIpAndGatewayInSameSubNet(m_pAdapterInfo->m_vstrIpAddresses[0]->c_str(),
|
|
m_pAdapterInfo->m_vstrSubnetMask[0]->c_str(),
|
|
m_pAdapterInfo->m_vstrDefaultGateway[0]->c_str()))
|
|
{
|
|
// duplicate IP address on same adapter is an error
|
|
if (NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_ERROR_IP_GW_MISMATH,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2) == IDNO)
|
|
{
|
|
fError = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_fWarnedMismatchIPandGw = TRUE;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// The pvcard is a readonly version of the first memory state
|
|
const VCARD * pvcard = m_ptcpip->GetConstAdapterInfoVector();
|
|
|
|
// different adapter
|
|
if (!fError)
|
|
{
|
|
int iDupCard;
|
|
|
|
VSTR_ITER iterIpBegin = m_pAdapterInfo->m_vstrIpAddresses.begin();
|
|
VSTR_ITER iterIpEnd = m_pAdapterInfo->m_vstrIpAddresses.end();
|
|
VSTR_ITER iterIp = iterIpBegin;
|
|
|
|
for( ; iterIp != iterIpEnd ; ++iterIp)
|
|
{
|
|
if ((iDupCard=CheckForDuplicates(pvcard, m_pAdapterInfo, **iterIp)) >=0)
|
|
{
|
|
Assert((*pvcard)[iDupCard]->m_guidInstanceId != m_pAdapterInfo->m_guidInstanceId);
|
|
|
|
// duplicate IP address between different adapters is not necessarily an error
|
|
// we raise a warning(requested by bug# 158578)
|
|
if (!FAlreadyWarned(**iterIp))
|
|
{
|
|
UINT uIdMsg = IDS_DUPLICATE_IP_WARNING;
|
|
|
|
if (FIsCardNotPresentOrMalFunctioning(&((*pvcard)[iDupCard]->m_guidInstanceId)))
|
|
{
|
|
// bug 286379, if the dup card is malfunctioning or not physically present,
|
|
// we should give a more specific error
|
|
uIdMsg = IDS_DUP_MALFUNCTION_IP_WARNING;
|
|
}
|
|
|
|
//here is the normal case: both cards are functioning
|
|
if (NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, uIdMsg,
|
|
MB_APPLMODAL | MB_ICONINFORMATION | MB_YESNO,
|
|
(*iterIp)->c_str(),
|
|
(*pvcard)[iDupCard]->m_strDescription.c_str()) == IDYES)
|
|
{
|
|
fError = TRUE; // NOT ok to leave the UI
|
|
}
|
|
else
|
|
{
|
|
// user said the dup is ok, don't warn them again
|
|
m_vstrWarnedDupIpList.push_back(new tstring((*iterIp)->c_str()));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (fError)
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
//if we have static gateway, check whether other cards also have
|
|
//static gateway. If yes, then the computer may not work properly
|
|
//as a router or edge box. Warn user about this configuration
|
|
if (!fError && !m_fWarnedDisjointGw &&
|
|
0 < m_pAdapterInfo->m_vstrDefaultGateway.size())
|
|
{
|
|
for(UINT i = 0; i < pvcard->size(); ++i)
|
|
{
|
|
if (0 < (*pvcard)[i]->m_vstrDefaultGateway.size() &&
|
|
(*pvcard)[i]->m_guidInstanceId != m_pAdapterInfo->m_guidInstanceId &&
|
|
!FIsCardNotPresentOrMalFunctioning(&((*pvcard)[i]->m_guidInstanceId)))
|
|
{
|
|
if (NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_WRN_DISJOINT_NET,
|
|
MB_APPLMODAL | MB_ICONINFORMATION |
|
|
MB_YESNO | MB_DEFBUTTON2) == IDNO)
|
|
{
|
|
fError = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//if the user want to have gateways on multiple nics on purpose,
|
|
//don't warn the user any more
|
|
m_fWarnedDisjointGw = TRUE;
|
|
}
|
|
|
|
//In either case of accepting or not-accepting, there is
|
|
//no need for additional check for this
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fError) // page not going away, we should update the Ui with what's in memory
|
|
SetInfo();
|
|
}
|
|
|
|
//we need to change focus to the control that contains invalidate data
|
|
if (fError && hWndFocus)
|
|
::SetFocus(hWndFocus);
|
|
|
|
::SetWindowLongPtr(m_hWnd, DWLP_MSGRESULT, fError);
|
|
return fError;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnApply(int idCtrl, LPNMHDR pnmh, BOOL& fHandled)
|
|
{
|
|
BOOL nResult = PSNRET_NOERROR;
|
|
|
|
if(m_fLmhostsFileReset) // if lmhosts has been reset
|
|
{
|
|
m_ptcpip->SetSecondMemoryLmhostsFileReset();
|
|
}
|
|
|
|
//IPSec is removed from connection UI
|
|
/*
|
|
if (m_fIpsecPolicySet)
|
|
{
|
|
m_ptcpip->SetSecondMemoryIpsecPolicySet();
|
|
}
|
|
*/
|
|
|
|
//Bug 232011, warning the user that the local IP address will be set as the primary DNS
|
|
// server address if DHCP is disabled and DNS server list is empty, if DNS server service
|
|
// is installed.
|
|
if((!m_pAdapterInfo->m_fEnableDhcp) && (m_pAdapterInfo->m_vstrDnsServerList.size() == 0))
|
|
{
|
|
CServiceManager scm;
|
|
CService svc;
|
|
HRESULT hr = scm.HrOpenService (&svc, c_szSvcDnsServer, NO_LOCK,
|
|
SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_TCPIP_DNS_EMPTY,
|
|
MB_OK | MB_APPLMODAL | MB_ICONEXCLAMATION);
|
|
}
|
|
}
|
|
|
|
if (!IsModified())
|
|
{
|
|
::SetWindowLongPtr(m_hWnd, DWLP_MSGRESULT, nResult);
|
|
return nResult;
|
|
}
|
|
|
|
m_ptcpip->SetSecondMemoryModified();
|
|
SetModifiedTo(FALSE); // this page is no longer modified
|
|
|
|
::SetWindowLongPtr(m_hWnd, DWLP_MSGRESULT, nResult);
|
|
return nResult;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnCancel(int idCtrl, LPNMHDR pnmh, BOOL& fHandled)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnDhcpButton(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
case BN_DOUBLECLICKED:
|
|
|
|
if (!m_pAdapterInfo->m_fEnableDhcp) // if Dhcp was disabled
|
|
{
|
|
// turn on DHCP button and disable the ip and subnet controls
|
|
m_pAdapterInfo->m_fEnableDhcp = TRUE;
|
|
EnableGroup(m_pAdapterInfo->m_fEnableDhcp);
|
|
|
|
PageModified();
|
|
|
|
FreeCollectionAndItem(m_pAdapterInfo->m_vstrIpAddresses);
|
|
m_ipAddress.ClearAddress();
|
|
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
FreeCollectionAndItem(m_pAdapterInfo->m_vstrSubnetMask);
|
|
FreeCollectionAndItem(m_pAdapterInfo->m_vstrDefaultGateway);
|
|
FreeCollectionAndItem(m_pAdapterInfo->m_vstrDefaultGatewayMetric);
|
|
|
|
m_ipSubnetMask.ClearAddress();
|
|
m_ipDefGateway.ClearAddress();
|
|
}
|
|
|
|
} // if !m_pAdapterInfo->m_fEnableDhcp
|
|
|
|
break;
|
|
} // switch
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnFixedButton(WORD wNotifyCode, WORD wID, HWND hWndCtl,
|
|
BOOL& fHandled)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
case BN_DOUBLECLICKED:
|
|
|
|
if (m_pAdapterInfo->m_fEnableDhcp)
|
|
{
|
|
PageModified();
|
|
|
|
// turn off DHCP button and enable the ip and subnet controls
|
|
m_pAdapterInfo->m_fEnableDhcp = FALSE;
|
|
EnableGroup(m_pAdapterInfo->m_fEnableDhcp);
|
|
}
|
|
break;
|
|
} // switch
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnDnsDhcp(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
case BN_DOUBLECLICKED:
|
|
|
|
PageModified();
|
|
|
|
FreeCollectionAndItem(m_pAdapterInfo->m_vstrDnsServerList);
|
|
m_ipDnsPrimary.ClearAddress();
|
|
m_ipDnsSecondary.ClearAddress();
|
|
|
|
EnableStaticDns(FALSE);
|
|
|
|
break;
|
|
} // switch
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnDnsFixed(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
case BN_DOUBLECLICKED:
|
|
|
|
PageModified();
|
|
EnableStaticDns(TRUE);
|
|
|
|
::SetFocus(GetDlgItem(IDC_DNS_PRIMARY));
|
|
|
|
break;
|
|
} // switch
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnAdvancedButton(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch (wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
case BN_DOUBLECLICKED:
|
|
|
|
BOOL fErr = FALSE;
|
|
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
// check inconsistency between ip address & subnet mask
|
|
if (m_ipAddress.IsBlank() && !m_ipSubnetMask.IsBlank())
|
|
{
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_NO_IP,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
::SetFocus(m_ipAddress);
|
|
fErr = TRUE;
|
|
}
|
|
else if (!m_ipAddress.IsBlank() && m_ipSubnetMask.IsBlank())
|
|
{
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_INVALID_NOSUBNET,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
::SetFocus(m_ipSubnetMask);
|
|
fErr = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!m_ipDnsPrimary.IsBlank() && !m_ipDnsSecondary.IsBlank())
|
|
{
|
|
tstring strPrimaryDns;
|
|
tstring strSecondDns;
|
|
|
|
m_ipDnsPrimary.GetAddress(&strPrimaryDns);
|
|
m_ipDnsSecondary.GetAddress(&strSecondDns);
|
|
if (strPrimaryDns == strSecondDns)
|
|
{
|
|
NcMsgBox(m_hWnd, IDS_MSFT_TCP_TEXT, IDS_DUP_SECOND_DNS,
|
|
MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
::SetFocus(m_ipDnsSecondary);
|
|
fErr = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!fErr)
|
|
{
|
|
// update our in memory structure with what's in the controls
|
|
UpdateInfo();
|
|
|
|
// Bring up the advanced pages
|
|
ADAPTER_INFO adapterInfo;
|
|
adapterInfo = *m_pAdapterInfo;
|
|
|
|
GLOBAL_INFO glbInfo;
|
|
glbInfo = *(m_ptcpip->GetGlobalInfo());
|
|
|
|
INT_PTR iRet = DoPropertySheet(&adapterInfo, &glbInfo);
|
|
|
|
if (iRet != -1)
|
|
{
|
|
if (m_fPropShtOk && m_fPropShtModified)
|
|
{
|
|
// Something changed, so mark the page as modified
|
|
PageModified();
|
|
|
|
// Reset values
|
|
m_fPropShtOk = FALSE;
|
|
m_fPropShtModified = FALSE;
|
|
|
|
// Update second memory info structure
|
|
*m_pAdapterInfo = adapterInfo;
|
|
|
|
GLOBAL_INFO * pGlbInfo = m_ptcpip->GetGlobalInfo();
|
|
*pGlbInfo = glbInfo;
|
|
}
|
|
}
|
|
|
|
// Update the controls with new data
|
|
SetInfo();
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//Show or Hide the backup configuration page depend on the
|
|
//current settings of dhcp vs static
|
|
void CTcpAddrPage::ShowOrHideBackupPage()
|
|
{
|
|
if (IsDlgButtonChecked(IDC_IP_DHCP) || IsDlgButtonChecked(IDC_DNS_DHCP))
|
|
{
|
|
//show the backup configuration page
|
|
if (NULL == m_hBackupPage)
|
|
{
|
|
m_hBackupPage = m_pageBackup.CreatePage(IDD_BACK_UP, 0);
|
|
Assert(m_hBackupPage);
|
|
|
|
if (m_hBackupPage)
|
|
{
|
|
::SendMessage(GetParent(), PSM_ADDPAGE, 0, (LPARAM) m_hBackupPage);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//hide the backup configuration page
|
|
if (NULL != m_hBackupPage)
|
|
{
|
|
::SendMessage(GetParent(), PSM_REMOVEPAGE, 1, (LPARAM) m_hBackupPage);
|
|
m_hBackupPage = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
INT_PTR CTcpAddrPage::DoPropertySheet(ADAPTER_INFO * pAdapterDlg,
|
|
GLOBAL_INFO * pGlbDlg)
|
|
{
|
|
Assert(pAdapterDlg);
|
|
Assert(pGlbDlg);
|
|
|
|
HRESULT hr = S_OK;
|
|
INT_PTR iRet = -1;
|
|
|
|
HPROPSHEETPAGE *ahpsp = NULL;
|
|
int cPages = 0;
|
|
|
|
// Create property pages
|
|
// ahpsp is allocated memory by CoTaskMemAlloc
|
|
hr = HrSetupPropPages(pAdapterDlg, pGlbDlg, &ahpsp, &cPages);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Show the property sheet
|
|
PROPSHEETHEADER psh = {0};
|
|
|
|
psh.dwSize = sizeof(PROPSHEETHEADER);
|
|
psh.dwFlags = PSH_NOAPPLYNOW;
|
|
psh.hwndParent = ::GetActiveWindow();
|
|
psh.hInstance = _Module.GetModuleInstance();
|
|
psh.pszIcon = NULL;
|
|
psh.pszCaption = (PWSTR)SzLoadIds(IDS_TCP_ADV_HEADER);
|
|
psh.nPages = cPages;
|
|
psh.phpage = ahpsp;
|
|
|
|
iRet = PropertySheet(&psh);
|
|
|
|
if (-1 == iRet)
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
TraceError("CTcpAddrPage::DoPropertySheet", HRESULT_FROM_WIN32(dwError));
|
|
}
|
|
}
|
|
|
|
if (m_pIpSettingsPage)
|
|
{
|
|
delete m_pIpSettingsPage;
|
|
m_pIpSettingsPage = NULL;
|
|
}
|
|
|
|
if (m_pTcpDnsPage)
|
|
{
|
|
delete m_pTcpDnsPage;
|
|
m_pTcpDnsPage = NULL;
|
|
}
|
|
|
|
if (m_pTcpWinsPage)
|
|
{
|
|
delete m_pTcpWinsPage;
|
|
m_pTcpWinsPage = NULL;
|
|
}
|
|
|
|
if (m_pAtmArpcPage)
|
|
{
|
|
delete m_pAtmArpcPage;
|
|
m_pAtmArpcPage = NULL;
|
|
}
|
|
|
|
if (m_pTcpOptionsPage)
|
|
{
|
|
delete m_pTcpOptionsPage;
|
|
m_pTcpOptionsPage = NULL;
|
|
}
|
|
|
|
if (m_pTcpRasPage)
|
|
{
|
|
delete m_pTcpRasPage;
|
|
m_pTcpRasPage = NULL;
|
|
}
|
|
|
|
if (ahpsp)
|
|
CoTaskMemFree(ahpsp);
|
|
|
|
return iRet;
|
|
}
|
|
|
|
HRESULT CTcpAddrPage::HrSetupPropPages( ADAPTER_INFO * pAdapterDlg,
|
|
GLOBAL_INFO * pGlbDlg,
|
|
HPROPSHEETPAGE ** pahpsp, INT * pcPages)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// initialize output parameters
|
|
int cPages = 0;
|
|
HPROPSHEETPAGE *ahpsp = NULL;
|
|
|
|
// Set up the property pages
|
|
cPages = 4;
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
m_pIpSettingsPage = new CIpSettingsPage(this, pAdapterDlg,
|
|
g_aHelpIDs_IDD_IPADDR_ADV);
|
|
if (m_pIpSettingsPage == NULL)
|
|
{
|
|
CORg(E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pTcpRasPage = new CTcpRasPage(this, pAdapterDlg, g_aHelpIDs_IDD_OPT_RAS);
|
|
|
|
if (m_pTcpRasPage == NULL)
|
|
{
|
|
CORg(E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
|
|
m_pTcpDnsPage = new CTcpDnsPage(this, pAdapterDlg,
|
|
pGlbDlg, g_aHelpIDs_IDD_TCP_DNS);
|
|
|
|
m_pTcpWinsPage = new CTcpWinsPage(m_ptcpip, this, pAdapterDlg,
|
|
pGlbDlg, g_aHelpIDs_IDD_TCP_WINS);
|
|
|
|
if ((m_pTcpDnsPage == NULL) ||
|
|
(m_pTcpWinsPage == NULL))
|
|
{
|
|
CORg(E_OUTOFMEMORY);
|
|
}
|
|
|
|
if (pAdapterDlg->m_fIsAtmAdapter)
|
|
{
|
|
m_pAtmArpcPage = new CAtmArpcPage(this, pAdapterDlg,
|
|
g_aHelpIDs_IDD_ATM_ARPC);
|
|
if (m_pAtmArpcPage == NULL)
|
|
{
|
|
CORg(E_OUTOFMEMORY);
|
|
}
|
|
|
|
cPages++;
|
|
}
|
|
|
|
//After removing the IPSec connection UI, there are no options to
|
|
//put in the option tab. So we just go ahead remove it.
|
|
if (!pAdapterDlg->m_fIsRasFakeAdapter)
|
|
{
|
|
m_pTcpOptionsPage = new CTcpOptionsPage(this, pAdapterDlg, pGlbDlg,
|
|
g_aHelpIDs_IDD_TCP_OPTIONS);
|
|
|
|
if (m_pTcpOptionsPage == NULL)
|
|
{
|
|
CORg(E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//we remove the option tab for the ras connections
|
|
cPages--;
|
|
}
|
|
|
|
// Allocate a buffer large enough to hold the handles to all of our
|
|
// property pages.
|
|
ahpsp = (HPROPSHEETPAGE *)CoTaskMemAlloc(sizeof(HPROPSHEETPAGE)
|
|
* cPages);
|
|
|
|
if (!ahpsp)
|
|
{
|
|
CORg(E_OUTOFMEMORY);
|
|
}
|
|
|
|
cPages =0;
|
|
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
ahpsp[cPages++] = m_pIpSettingsPage->CreatePage(IDD_IPADDR_ADV, 0);
|
|
}
|
|
else
|
|
{
|
|
ahpsp[cPages++] = m_pTcpRasPage->CreatePage(IDD_OPT_RAS, 0);
|
|
}
|
|
|
|
ahpsp[cPages++] = m_pTcpDnsPage->CreatePage(IDD_TCP_DNS, 0);
|
|
ahpsp[cPages++] = m_pTcpWinsPage->CreatePage(IDD_TCP_WINS, 0);
|
|
|
|
if (pAdapterDlg->m_fIsAtmAdapter)
|
|
{
|
|
ahpsp[cPages++] = m_pAtmArpcPage->CreatePage(IDD_ATM_ARPC, 0);
|
|
}
|
|
|
|
if (!pAdapterDlg->m_fIsRasFakeAdapter && m_pTcpOptionsPage)
|
|
{
|
|
ahpsp[cPages++] = m_pTcpOptionsPage->CreatePage(IDD_TCP_OPTIONS, 0);
|
|
}
|
|
|
|
*pahpsp = ahpsp;
|
|
*pcPages = cPages;
|
|
|
|
Error:
|
|
if (FAILED(hr))
|
|
{
|
|
if (m_pIpSettingsPage)
|
|
{
|
|
delete m_pIpSettingsPage;
|
|
m_pIpSettingsPage = NULL;
|
|
}
|
|
|
|
if (m_pTcpDnsPage)
|
|
{
|
|
delete m_pTcpDnsPage;
|
|
m_pTcpDnsPage = NULL;
|
|
}
|
|
|
|
if (m_pTcpWinsPage)
|
|
{
|
|
delete m_pTcpWinsPage;
|
|
m_pTcpWinsPage = NULL;
|
|
}
|
|
|
|
if (m_pAtmArpcPage)
|
|
{
|
|
delete m_pAtmArpcPage;
|
|
m_pAtmArpcPage = NULL;
|
|
}
|
|
|
|
if (m_pTcpOptionsPage)
|
|
{
|
|
delete m_pTcpOptionsPage;
|
|
m_pTcpOptionsPage = NULL;
|
|
}
|
|
|
|
if (m_pTcpRasPage)
|
|
{
|
|
delete m_pTcpRasPage;
|
|
m_pTcpRasPage = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnIpAddrIp(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch (wNotifyCode)
|
|
{
|
|
case EN_CHANGE:
|
|
PageModified();
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnIpAddrSub(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch (wNotifyCode)
|
|
{
|
|
case EN_CHANGE:
|
|
PageModified();
|
|
break;
|
|
|
|
case EN_SETFOCUS:
|
|
|
|
// if the subnet mask is blank, create a mask and insert it into
|
|
// the control
|
|
if (!m_ipAddress.IsBlank() && m_ipSubnetMask.IsBlank())
|
|
{
|
|
tstring strSubnetMask;
|
|
tstring strIpAddress;
|
|
|
|
m_ipAddress.GetAddress(&strIpAddress);
|
|
|
|
// generate the mask and update the control, and internal structure
|
|
GenerateSubnetMask(m_ipAddress, &strSubnetMask);
|
|
m_ipSubnetMask.SetAddress(strSubnetMask.c_str());
|
|
|
|
ReplaceFirstAddress(&(m_pAdapterInfo->m_vstrSubnetMask),
|
|
strSubnetMask.c_str());
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnIpAddrGateway(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch (wNotifyCode)
|
|
{
|
|
case EN_CHANGE:
|
|
PageModified();
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnDnsPrimary(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch (wNotifyCode)
|
|
{
|
|
case EN_CHANGE:
|
|
PageModified();
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnDnsSecondary(WORD wNotifyCode, WORD wID,
|
|
HWND hWndCtl, BOOL& fHandled)
|
|
{
|
|
switch (wNotifyCode)
|
|
{
|
|
case EN_CHANGE:
|
|
PageModified();
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTcpAddrPage::OnIpFieldChange(int idCtrl, LPNMHDR pnmh, BOOL& fHandled)
|
|
{
|
|
LPNMIPADDRESS lpnmipa;
|
|
int iLow = c_iIpLow;
|
|
int iHigh = c_iIpHigh;
|
|
|
|
switch(idCtrl)
|
|
{
|
|
case IDC_IPADDR_IP:
|
|
case IDC_IPADDR_GATE:
|
|
case IDC_DNS_PRIMARY:
|
|
case IDC_DNS_SECONDARY:
|
|
|
|
lpnmipa = (LPNMIPADDRESS) pnmh;
|
|
|
|
if (0==lpnmipa->iField)
|
|
{
|
|
iLow = c_iIPADDR_FIELD_1_LOW;
|
|
iHigh = c_iIPADDR_FIELD_1_HIGH;
|
|
};
|
|
|
|
IpCheckRange(lpnmipa,
|
|
m_hWnd,
|
|
iLow,
|
|
iHigh,
|
|
(IDC_IPADDR_IP == idCtrl || IDC_IPADDR_GATE == idCtrl));
|
|
break;
|
|
|
|
case IDC_IPADDR_SUB:
|
|
|
|
lpnmipa = (LPNMIPADDRESS) pnmh;
|
|
IpCheckRange(lpnmipa, m_hWnd, iLow, iHigh);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CTcpAddrPage::EnableGroup(BOOL fEnableDhcp)
|
|
{
|
|
BOOL fStaticIp = !fEnableDhcp;
|
|
|
|
CheckDlgButton(IDC_IP_DHCP, fEnableDhcp);
|
|
CheckDlgButton(IDC_IP_FIXED, fStaticIp);
|
|
|
|
::EnableWindow(GetDlgItem(IDC_IPADDR_IPTEXT), fStaticIp);
|
|
::EnableWindow(GetDlgItem(IDC_IPADDR_IP), fStaticIp);
|
|
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
::EnableWindow(GetDlgItem(IDC_IPADDR_SUBTEXT), fStaticIp);
|
|
::EnableWindow(GetDlgItem(IDC_IPADDR_SUB), fStaticIp);
|
|
|
|
::EnableWindow(GetDlgItem(IDC_IPADDR_GATE), fStaticIp);
|
|
::EnableWindow(GetDlgItem(IDC_IPADDR_GATETEXT), fStaticIp);
|
|
}
|
|
|
|
if (!fEnableDhcp) // enforce DNS address option
|
|
{
|
|
CheckDlgButton(IDC_DNS_DHCP, FALSE);
|
|
CheckDlgButton(IDC_DNS_FIXED, TRUE);
|
|
|
|
::EnableWindow(GetDlgItem(IDC_DNS_DHCP), FALSE);
|
|
EnableStaticDns(TRUE);
|
|
}
|
|
else
|
|
{
|
|
::EnableWindow(GetDlgItem(IDC_DNS_DHCP), TRUE);
|
|
}
|
|
|
|
if (CONNECTION_LAN == m_ConnType)
|
|
{
|
|
ShowOrHideBackupPage();
|
|
}
|
|
}
|
|
|
|
void CTcpAddrPage::EnableStaticDns(BOOL fUseStaticDns)
|
|
{
|
|
::EnableWindow(GetDlgItem(IDC_DNS_PRIMARY), fUseStaticDns);
|
|
::EnableWindow(GetDlgItem(IDC_DNS_PRIMARY_TEXT), fUseStaticDns);
|
|
::EnableWindow(GetDlgItem(IDC_DNS_SECONDARY), fUseStaticDns);
|
|
::EnableWindow(GetDlgItem(IDC_DNS_SECONDARY_TEXT), fUseStaticDns);
|
|
}
|
|
|
|
// Set info to controls using the data in m_pAdapterInfo
|
|
void CTcpAddrPage::SetInfo()
|
|
{
|
|
Assert(m_pAdapterInfo);
|
|
|
|
// Dhcp Ip address is not allowed when Dhcp server is installed or
|
|
// it is a SLIP connection
|
|
|
|
// const GLOBAL_INFO * pglb = m_ptcpip->GetConstGlobalInfo();
|
|
// if ((pglb->m_fDhcpServerInstalled) || (m_ConnType == CONNECTION_RAS_SLIP))
|
|
|
|
if (m_ConnType == CONNECTION_RAS_SLIP)
|
|
{
|
|
::EnableWindow(GetDlgItem(IDC_IP_DHCP), FALSE);
|
|
m_pAdapterInfo->m_fEnableDhcp = 0;
|
|
}
|
|
|
|
EnableGroup(m_pAdapterInfo->m_fEnableDhcp);
|
|
|
|
// Set Ip address
|
|
if(m_pAdapterInfo->m_fEnableDhcp == 0) //Dhcp disabled, static IP
|
|
{
|
|
tstring strTmp;
|
|
if (fQueryFirstAddress(m_pAdapterInfo->m_vstrIpAddresses, &strTmp))
|
|
m_ipAddress.SetAddress(strTmp.c_str());
|
|
else
|
|
m_ipAddress.ClearAddress();
|
|
}
|
|
else //Dhcp enabled
|
|
{
|
|
m_ipAddress.ClearAddress();
|
|
FreeCollectionAndItem(m_pAdapterInfo->m_vstrIpAddresses);
|
|
}
|
|
|
|
// Set Subnet mask and default gateway if Lan connection
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
if(m_pAdapterInfo->m_fEnableDhcp == 0) //Dhcp disabled, static IP
|
|
{
|
|
tstring strTmp;
|
|
|
|
if (fQueryFirstAddress(m_pAdapterInfo->m_vstrSubnetMask, &strTmp))
|
|
m_ipSubnetMask.SetAddress(strTmp.c_str());
|
|
else
|
|
m_ipSubnetMask.ClearAddress();
|
|
|
|
if (fQueryFirstAddress(m_pAdapterInfo->m_vstrDefaultGateway, &strTmp))
|
|
m_ipDefGateway.SetAddress(strTmp.c_str());
|
|
else
|
|
m_ipDefGateway.ClearAddress();
|
|
}
|
|
else //Dhcp enabled
|
|
{
|
|
m_ipSubnetMask.ClearAddress();
|
|
FreeCollectionAndItem(m_pAdapterInfo->m_vstrSubnetMask);
|
|
|
|
tstring strGateway;
|
|
|
|
if (fQueryFirstAddress(m_pAdapterInfo->m_vstrDefaultGateway, &strGateway))
|
|
m_ipDefGateway.SetAddress(strGateway.c_str());
|
|
else
|
|
m_ipDefGateway.ClearAddress();
|
|
}
|
|
}
|
|
|
|
// Set Dns addresses
|
|
BOOL fUseStaticDns = ((!m_pAdapterInfo->m_fEnableDhcp) ||
|
|
(m_pAdapterInfo->m_vstrDnsServerList.size() >0));
|
|
|
|
CheckDlgButton(IDC_DNS_DHCP, !fUseStaticDns);
|
|
CheckDlgButton(IDC_DNS_FIXED, fUseStaticDns);
|
|
|
|
EnableStaticDns(fUseStaticDns);
|
|
|
|
if (fUseStaticDns)
|
|
{
|
|
tstring strTmp;
|
|
|
|
if (fQueryFirstAddress(m_pAdapterInfo->m_vstrDnsServerList, &strTmp))
|
|
m_ipDnsPrimary.SetAddress(strTmp.c_str());
|
|
else
|
|
m_ipDnsPrimary.ClearAddress();
|
|
|
|
if (fQuerySecondAddress(m_pAdapterInfo->m_vstrDnsServerList, &strTmp))
|
|
m_ipDnsSecondary.SetAddress(strTmp.c_str());
|
|
else
|
|
m_ipDnsSecondary.ClearAddress();
|
|
}
|
|
else
|
|
{
|
|
m_ipDnsPrimary.ClearAddress();
|
|
m_ipDnsSecondary.ClearAddress();
|
|
}
|
|
}
|
|
|
|
// Update info in m_pAdapterInfo with what's in the controls
|
|
void CTcpAddrPage::UpdateInfo()
|
|
{
|
|
Assert(m_pAdapterInfo);
|
|
|
|
if (!m_pAdapterInfo->m_fEnableDhcp) // If DHCP disabled
|
|
{
|
|
tstring strNewAddress;
|
|
|
|
// ip address & subnet mask
|
|
if (!m_ipAddress.IsBlank())
|
|
{
|
|
m_ipAddress.GetAddress(&strNewAddress);
|
|
ReplaceFirstAddress(&(m_pAdapterInfo->m_vstrIpAddresses),
|
|
strNewAddress.c_str());
|
|
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
if (m_ipSubnetMask.IsBlank())
|
|
{
|
|
SendDlgItemMessage(IDC_IPADDR_SUB, WM_SETFOCUS, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
m_ipSubnetMask.GetAddress(&strNewAddress);
|
|
ReplaceFirstAddress(&(m_pAdapterInfo->m_vstrSubnetMask),
|
|
strNewAddress.c_str());
|
|
}
|
|
}
|
|
}
|
|
else // no ip address
|
|
{
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
if (m_ipSubnetMask.IsBlank())
|
|
{
|
|
// delete the first ip address and subnet mask
|
|
if (m_pAdapterInfo->m_vstrIpAddresses.size())
|
|
{
|
|
FreeVectorItem(m_pAdapterInfo->m_vstrIpAddresses, 0);
|
|
|
|
if (!m_pAdapterInfo->m_vstrIpAddresses.empty())
|
|
m_ipAddress.SetAddress(m_pAdapterInfo->m_vstrIpAddresses[0]->c_str());
|
|
|
|
if (m_pAdapterInfo->m_vstrSubnetMask.size())
|
|
{
|
|
FreeVectorItem(m_pAdapterInfo->m_vstrSubnetMask, 0);
|
|
|
|
if (!m_pAdapterInfo->m_vstrSubnetMask.empty())
|
|
m_ipSubnetMask.SetAddress(m_pAdapterInfo->m_vstrSubnetMask[0]->c_str());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AssertSz(FALSE, "No ip address.");
|
|
}
|
|
}
|
|
else // RAS connection, simply delete IP address
|
|
{
|
|
if (m_pAdapterInfo->m_vstrIpAddresses.size())
|
|
{
|
|
FreeVectorItem(m_pAdapterInfo->m_vstrIpAddresses, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// default gateway
|
|
if (m_ConnType == CONNECTION_LAN)
|
|
{
|
|
if (!m_ipDefGateway.IsBlank())
|
|
{
|
|
m_ipDefGateway.GetAddress(&strNewAddress);
|
|
ReplaceFirstAddress(&(m_pAdapterInfo->m_vstrDefaultGateway),
|
|
strNewAddress.c_str());
|
|
int iSize = m_pAdapterInfo->m_vstrDefaultGatewayMetric.size();
|
|
if (m_pAdapterInfo->m_vstrDefaultGatewayMetric.size() == 0)
|
|
{
|
|
WCHAR buf[IP_LIMIT];
|
|
//if there is no default gateway before (that's the reason metric list is
|
|
//empty), we add the default metric for it
|
|
_ltot(c_dwDefaultMetricOfGateway, buf, 10);
|
|
m_pAdapterInfo->m_vstrDefaultGatewayMetric.push_back(new tstring(buf));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_pAdapterInfo->m_vstrDefaultGateway.size() >0)
|
|
{
|
|
FreeVectorItem(m_pAdapterInfo->m_vstrDefaultGateway, 0);
|
|
|
|
if (!m_pAdapterInfo->m_vstrDefaultGateway.empty())
|
|
m_ipDefGateway.SetAddress(m_pAdapterInfo->m_vstrDefaultGateway[0]->c_str());
|
|
|
|
if (m_pAdapterInfo->m_vstrDefaultGatewayMetric.size() >0)
|
|
FreeVectorItem(m_pAdapterInfo->m_vstrDefaultGatewayMetric, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// DNS addresses
|
|
UpdateAddressList(&(m_pAdapterInfo->m_vstrDnsServerList),
|
|
m_ipDnsPrimary, m_ipDnsSecondary);
|
|
}
|
|
|
|
// Update a vector of strings with values from two IP address
|
|
// controls
|
|
void CTcpAddrPage::UpdateAddressList(VSTR * pvstrList,
|
|
IpControl& ipPrimary,
|
|
IpControl& ipSecondary)
|
|
{
|
|
tstring str;
|
|
if (pvstrList->size()<=2) // if the list did not have more than two addresses
|
|
{
|
|
// Free the list
|
|
FreeCollectionAndItem(*pvstrList);
|
|
|
|
// Insert new addresses if any
|
|
if (!ipPrimary.IsBlank())
|
|
{
|
|
ipPrimary.GetAddress(&str);
|
|
pvstrList->push_back(new tstring(str.c_str()));
|
|
}
|
|
|
|
if (!ipSecondary.IsBlank())
|
|
{
|
|
ipSecondary.GetAddress(&str);
|
|
pvstrList->push_back(new tstring(str.c_str()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Replace addresses if they exists
|
|
if (!ipSecondary.IsBlank())
|
|
{
|
|
ipSecondary.GetAddress(&str);
|
|
ReplaceSecondAddress(pvstrList, str.c_str());
|
|
}
|
|
else
|
|
{
|
|
FreeVectorItem(*pvstrList, 1);
|
|
}
|
|
|
|
if (!ipPrimary.IsBlank())
|
|
{
|
|
ipPrimary.GetAddress(&str);
|
|
ReplaceFirstAddress(pvstrList, str.c_str());
|
|
}
|
|
else
|
|
{
|
|
FreeVectorItem(*pvstrList, 0);
|
|
}
|
|
|
|
//fix Bug 425112: Update the UI if either of the IP control
|
|
//is blank because sometimes UpdateInfo get called twice (which
|
|
// will make us delete the address twice if we dont update the UI)
|
|
if (ipPrimary.IsBlank() || ipSecondary.IsBlank())
|
|
{
|
|
if (!pvstrList->empty())
|
|
{
|
|
ipPrimary.SetAddress((*pvstrList)[0]->c_str());
|
|
}
|
|
|
|
if (pvstrList->size() >= 2)
|
|
{
|
|
ipSecondary.SetAddress((*pvstrList)[1]->c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
BOOL CTcpAddrPage::FIsCardNotPresentOrMalFunctioning(GUID * pguidCard)
|
|
{
|
|
Assert(pguidCard);
|
|
BOOL fRet = FALSE;
|
|
FARPROC pfnHrGetPnpDeviceStatus = NULL;
|
|
HMODULE hNetman = NULL;
|
|
|
|
HRESULT hrTmp = S_OK;
|
|
NETCON_STATUS ncStatus = NCS_CONNECTED;
|
|
|
|
hrTmp = HrLoadLibAndGetProc(L"netman.dll", "HrGetPnpDeviceStatus",
|
|
&hNetman, &pfnHrGetPnpDeviceStatus);
|
|
|
|
if (SUCCEEDED(hrTmp))
|
|
{
|
|
hrTmp = (*(PHRGETPNPDEVICESTATUS)pfnHrGetPnpDeviceStatus)(
|
|
pguidCard,
|
|
&ncStatus);
|
|
FreeLibrary(hNetman);
|
|
}
|
|
|
|
if (SUCCEEDED(hrTmp) &&
|
|
(NCS_HARDWARE_MALFUNCTION == ncStatus ||
|
|
NCS_HARDWARE_NOT_PRESENT == ncStatus))
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|