windows-server-2003/net/mmc/dhcp/optcfg.cpp

/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation                **/
/**********************************************************************/

/*
   optcfg.cpp
      Individual option property page
   
   FILE HISTORY:

*/

#include "stdafx.h"
#include "optcfg.h"
#include "listview.h"
#include "server.h"
#include "nodes.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define MAX_COLUMNS 2

UINT COLUMN_HEADERS[MAX_COLUMNS] =
{
    IDS_OPTCFG_NAME,
    IDS_OPTCFG_COMMENT
};

int COLUMN_WIDTHS[MAX_COLUMNS] =
{
    150, 175
};

const DWORD * OPTION_CONTROL_HELP_ARRAYS[] =
{
    g_aHelpIDs_IDD_DATA_ENTRY_DWORD,
    g_aHelpIDs_IDD_DATA_ENTRY_IPADDRESS,
    g_aHelpIDs_IDD_DATA_ENTRY_IPADDRESS_ARRAY,
    g_aHelpIDs_IDD_DATA_ENTRY_BINARY,
    g_aHelpIDs_IDD_DATA_ENTRY_BINARY_ARRAY,
    g_aHelpIDs_IDD_DATA_ENTRY_STRING,
    g_aHelpIDs_IDD_DATA_ENTRY_ROUTE_ARRAY,
    g_aHelpIDs_IDD_DATA_ENTRY_STRING_ARRAY
};


// class CHelpMap
CHelpMap::CHelpMap()
{
    m_pdwHelpMap = NULL;
}

CHelpMap::~CHelpMap()
{
    ResetMap();
}

void
CHelpMap::BuildMap(DWORD pdwParentHelpMap[])
{
    int i, j, nPos;
    int nSize = 0;
    int nCurSize;

    ResetMap();

    // calculate the size of the map
    // subtract off the terminators
    nSize += CountMap(pdwParentHelpMap); 

    for (i = 0; i < ARRAYLEN(OPTION_CONTROL_HELP_ARRAYS); i++)
    {
        nSize += CountMap(OPTION_CONTROL_HELP_ARRAYS[i]);
    }

    nSize += 2; // for terminator

    m_pdwHelpMap = new DWORD[nSize];
    memset(m_pdwHelpMap, 0, sizeof(*m_pdwHelpMap));

    // fill in the parent help map
    nPos = 0;
    nCurSize = CountMap(pdwParentHelpMap);
    for (i = 0; i < nCurSize; i++)
    {
        m_pdwHelpMap[nPos++] = pdwParentHelpMap[i++];
        m_pdwHelpMap[nPos++] = pdwParentHelpMap[i];
    }

    // now add all of the possible option control help maps
    for (i = 0; i < ARRAYLEN(OPTION_CONTROL_HELP_ARRAYS); i++)
    {
        nCurSize = CountMap(OPTION_CONTROL_HELP_ARRAYS[i]);
        for (j = 0; j < nCurSize; j++)
        {
            m_pdwHelpMap[nPos++] = (OPTION_CONTROL_HELP_ARRAYS[i])[j++];
            m_pdwHelpMap[nPos++] = (OPTION_CONTROL_HELP_ARRAYS[i])[j];
        }
    }
}

DWORD * CHelpMap::GetMap()
{
    return m_pdwHelpMap;
}

int CHelpMap::CountMap(const DWORD * pdwHelpMap)
{
    int i = 0;

    while (pdwHelpMap[i] != 0)
    {
        i++;
    }

    return i++;
}

void CHelpMap::ResetMap()
{
    if (m_pdwHelpMap)
    {
        delete m_pdwHelpMap;
        m_pdwHelpMap = NULL;
    }
}

DEBUG_DECLARE_INSTANCE_COUNTER(COptionsConfig);

/////////////////////////////////////////////////////////////////////////////
//
// COptionsConfig holder
//
/////////////////////////////////////////////////////////////////////////////
COptionsConfig::COptionsConfig
(
   ITFSNode *              pNode,
   ITFSNode *              pServerNode,
   IComponentData *        pComponentData,
   ITFSComponentData *        pTFSCompData,
   COptionValueEnum *          pOptionValueEnum,
   LPCTSTR                 pszSheetName,
    CDhcpOptionItem *           pSelOption
) : CPropertyPageHolderBase(pNode, pComponentData, pszSheetName)
{
    DEBUG_INCREMENT_INSTANCE_COUNTER(COptionsConfig);

    //ASSERT(pFolderNode == GetContainerNode());

   m_bAutoDeletePages = FALSE; // we have the pages as embedded members

   AddPageToList((CPropertyPageBase*) &m_pageGeneral);

    LARGE_INTEGER liServerVersion;
    CDhcpServer * pServer = GETHANDLER(CDhcpServer, pServerNode);
    
    pServer->GetVersion(m_liServerVersion);
    if (m_liServerVersion.QuadPart >= DHCP_NT5_VERSION)
    {
        AddPageToList((CPropertyPageBase*) &m_pageAdvanced);
    }

   Assert(pTFSCompData != NULL);
   m_spTFSCompData.Set(pTFSCompData);
   m_spServerNode.Set(pServerNode);

   // get all of the active options for this node
   SPITFSNode spNode;
   spNode = GetNode();

   m_bInitialized = FALSE;

    m_pOptionValueEnum = pOptionValueEnum;

    if (pSelOption)
    {
        m_strStartVendor = pSelOption->GetVendor();
        m_strStartClass = pSelOption->GetClassName();
        m_dhcpStartId = pSelOption->GetOptionId();
    }
    else
    {
        m_dhcpStartId = 0xffffffff;
    }
}

COptionsConfig::~COptionsConfig()
{
    DEBUG_DECREMENT_INSTANCE_COUNTER(COptionsConfig);

   RemovePageFromList((CPropertyPageBase*) &m_pageGeneral, FALSE);
   RemovePageFromList((CPropertyPageBase*) &m_pageAdvanced, FALSE);
}

DWORD
COptionsConfig::InitData()
{
   DWORD dwErr = NO_ERROR;

   if (m_bInitialized)
      return dwErr;

    CDhcpServer * pServer = GETHANDLER(CDhcpServer, m_spServerNode);
    CClassInfoArray ClassInfoArray;

    pServer->GetClassInfoArray(ClassInfoArray);

    // create a standard DHCP options vendor tracker and a set of default class options
    CVendorTracker * pVendorTracker = AddVendorTracker(_T(""));
    AddClassTracker(pVendorTracker, _T(""));

    // walk the list of classes.  For each vendor class, add a default user class.
    for (int i = 0; i < ClassInfoArray.GetSize(); i++)
    {
        if (ClassInfoArray[i].bIsVendor)
        {
            // create a vendor tracker and a set of default class options
            pVendorTracker = AddVendorTracker(ClassInfoArray[i].strName);
            AddClassTracker(pVendorTracker, _T(""));
        }
    }

    // now walk the list of vendor classes and add User class option lists 
    POSITION pos = m_listVendorClasses.GetHeadPosition();
    while (pos)
    {
        pVendorTracker = m_listVendorClasses.GetNext(pos);

        // now build option sets for each user class in each vendor
        for (int j = 0; j < ClassInfoArray.GetSize(); j++)
        {
            if (!ClassInfoArray[j].bIsVendor)
                AddClassTracker(pVendorTracker, ClassInfoArray[j].strName);
        }
    }

    // now we need to update any active options with their current values
    UpdateActiveOptions();

    m_bInitialized = TRUE;

    return dwErr;
}

void
COptionsConfig::SetTitle()
{
    HWND hSheet = GetSheetWindow();
    ::SetWindowText(hSheet, m_stSheetTitle);
}

LPWSTR COptionsConfig::GetServerAddress()
{
    CDhcpServer * pServer = GETHANDLER(CDhcpServer, m_spServerNode);
    return (LPWSTR) pServer->GetIpAddress();
}

CVendorTracker *
COptionsConfig::AddVendorTracker(LPCTSTR pClassName)
{
    CVendorTracker * pVendorTracker = new CVendorTracker();
    pVendorTracker->SetClassName(pClassName);

    m_listVendorClasses.AddTail(pVendorTracker);

    return pVendorTracker;
}

void COptionsConfig::AddClassTracker(CVendorTracker * pVendorTracker, LPCTSTR pClassName)
{
    SPITFSNode spServerNode;
    
    spServerNode = GetServerNode();
    CDhcpServer * pServer = GETHANDLER(CDhcpServer, spServerNode);
    
    CClassTracker * pClassTracker = new CClassTracker();
    pClassTracker->SetClassName(pClassName);
    
    // add the new class tracker to the list.
    pVendorTracker->m_listUserClasses.AddTail(pClassTracker);
    
    // Get a pointer to the list of options on the server.  We use this
    // to build our list of available options for this class
    CDhcpOption * pCurOption;
    CDhcpDefaultOptionsOnServer * pDefOptions = pServer->GetDefaultOptionsList();
    
    CString strVendor = pVendorTracker->GetClassName();
    CString strUserClass = pClassName;
    
    pCurOption = pDefOptions->First();
    while (pCurOption) {
   DHCP_OPTION_ID id = pCurOption->QueryId();
   
        // we filter out some options:
        // 1 - standard options with no user class call FilterOption
        // 2 - standard options with a user class call FilterUserClassOptions
        if ( (strVendor.IsEmpty() && !FilterOption(id) && !pCurOption->IsVendor()) ||
             (strVendor.IsEmpty() && !pCurOption->IsVendor() &&
         !strUserClass.IsEmpty() && !FilterUserClassOption(id)) ||
             (pCurOption->GetVendor() && strVendor.Compare(pCurOption->GetVendor()) == 0) )
       {
         // create an option item for this entry. We do this because 
      // these options are stored in the server node, but since this is a modeless
      // dialog the values could change, so we'll take a snapshot of the data
      // we can just use the copy constructor of the CDhcpOption
      COptionTracker * pOptionTracker = new COptionTracker;
      CDhcpOption * pNewOption = new CDhcpOption(*pCurOption);
      
      pOptionTracker->m_pOption = pNewOption;
      
      // add the option to the class tracker
      pClassTracker->m_listOptions.AddTail(pOptionTracker);
       }
   
   pCurOption = pDefOptions->Next();
    }
}

void COptionsConfig::UpdateActiveOptions()
{
    // Now the known options are in the correct locations.  We need to see
    // what options are enabled for this node.  We querried the server to make
    // sure we have the latest information about active options.
    m_pOptionValueEnum->Reset();
    CDhcpOption * pOption;
    
    while (pOption = m_pOptionValueEnum->Next()) {
   DHCP_OPTION_ID optionId = pOption->QueryId();
   
   // search all vendors options
   POSITION pos = m_listVendorClasses.GetHeadPosition();
   while (pos) {
       // search all vendor classes
       CVendorTracker * pVendorTracker = m_listVendorClasses.GetNext(pos);
       CString strVendor = pOption->GetVendor();
       
       if (pVendorTracker->m_strClassName.Compare(strVendor) == 0)   {
      // ok, the vendor class matches so lets check user classes
      POSITION pos2 = pVendorTracker->m_listUserClasses.GetHeadPosition();
      while (pos2) {
          CClassTracker * pClassTracker = pVendorTracker->m_listUserClasses.GetNext(pos2);
          
          // check to see if this option belongs to this class
          if ( (pClassTracker->m_strClassName.IsEmpty()) &&
          (!pOption->IsClassOption()) ) {
                        // both are empty... match.
                    }
                    else if (( pClassTracker->m_strClassName.IsEmpty() && pOption->IsClassOption()) ||
              ( !pClassTracker->m_strClassName.IsEmpty() && !pOption->IsClassOption())) {
                        // either the current option or the current class is null...
                        continue;
                    }
                    else if (pClassTracker->m_strClassName.CompareNoCase(pOption->GetClassName()) != 0) {
                        // both names are non-null and they don't match... keep looking
                        continue;
                    }
          
                    // Ok, the class the option belong to is the same as the one we are currently
                    // looking at.  Loop through the default options for this class and update it's 
                    // state and value.
                    POSITION posOption = pClassTracker->m_listOptions.GetHeadPosition();
          while (posOption) {
         COptionTracker * pCurOptTracker = pClassTracker->m_listOptions.GetNext(posOption);
         CDhcpOption * pCurOption = pCurOptTracker->m_pOption;
         
         if (( pCurOption->QueryId() == pOption->QueryId()) &&
                             (( pCurOption->IsVendor() && pOption->IsVendor()) ||
               ( !pCurOption->IsVendor() && !pOption->IsVendor()))) {
             // update this option
             CDhcpOptionValue OptValue = pOption->QueryValue();
             pCurOption->Update(OptValue);
             pCurOptTracker->SetInitialState(OPTION_STATE_ACTIVE);
             pCurOptTracker->SetCurrentState(OPTION_STATE_ACTIVE);
             
                            break;
         } // if
                    } // while option list
                } // while User class list
            } // endif vendor class name compre
        } // while list of vendor classes
    } // while

} // COptionsConfig::UpdateActiveOptions()

void COptionsConfig::FillOptions(LPCTSTR pVendorName, LPCTSTR pUserClassName, CMyListCtrl & ListCtrl)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   // look for the requested class and fill in the listbox
   // with all options for that class
    CString strVendorStandard, strClassStandard, strTargetVendor, strTargetClass;
    CString strTypeVendor, strTypeStandard;
    strVendorStandard.LoadString(IDS_INFO_NAME_DHCP_DEFAULT);
   strClassStandard.LoadString(IDS_USER_STANDARD);

    if (strVendorStandard.Compare(pVendorName) != 0)
        strTargetVendor = pVendorName;

    if (strClassStandard.Compare(pUserClassName) != 0)
        strTargetClass = pUserClassName;

   POSITION posv = m_listVendorClasses.GetHeadPosition();
    while (posv)
    {
        // find the right vendor
        CVendorTracker * pVendorTracker = m_listVendorClasses.GetNext(posv);
        if (pVendorTracker->m_strClassName.Compare(strTargetVendor) == 0)
        {
            POSITION pos = NULL;
           pos = pVendorTracker->m_listUserClasses.GetHeadPosition();
           while (pos)
           {
              // now find the right user class
                CClassTracker * pClassTracker = pVendorTracker->m_listUserClasses.GetNext(pos);
              if (pClassTracker->m_strClassName.Compare(strTargetClass) == 0)
              {
                 // this is the class, add all of the options to the listbox
                 CString strDisplay, strType, strComment;

                 POSITION posOption = NULL;
                 posOption = pClassTracker->m_listOptions.GetHeadPosition();
                 while (posOption)
                 {
                    COptionTracker * pOptionTracker = pClassTracker->m_listOptions.GetNext(posOption);

                    pOptionTracker->m_pOption->QueryDisplayName(strDisplay);
                    strComment = pOptionTracker->m_pOption->QueryComment();
                    strType = pOptionTracker->m_pOption->IsVendor() ? strTypeVendor : strTypeStandard;

                    int nIndex = ListCtrl.AddItem(strDisplay, strComment, LISTVIEWEX_NOT_CHECKED);

                    ListCtrl.SetItemData(nIndex, (LPARAM) pOptionTracker);

                    if (pOptionTracker->GetCurrentState() == OPTION_STATE_ACTIVE)
                       ListCtrl.CheckItem(nIndex);
                 }

                 break;
              }
      } // while
   } // if 
    } // while

    // Finally, Set the column widths so that all items are visible.
    // Set the default column widths to the width of the widest column
    int aColWidth[ MAX_COLUMNS];

    int nRow, nCol;
    CString strTemp;
    
    ZeroMemory(aColWidth, MAX_COLUMNS * sizeof(int));
    CopyMemory(aColWidth, &COLUMN_WIDTHS, sizeof(MAX_COLUMNS * sizeof(int)));

    // for each item, loop through each column and calculate the correct width
    for (nRow = 0; nRow < ListCtrl.GetItemCount(); nRow++)
    {
        for (nCol = 0; nCol < MAX_COLUMNS; nCol++)
        {
            strTemp = ListCtrl.GetItemText(nRow, nCol);
            if (aColWidth[nCol] < ListCtrl.GetStringWidth(strTemp))
                aColWidth[nCol] = ListCtrl.GetStringWidth(strTemp);
        }
    }
    
    // now update the column widths based on what we calculated
    for (nCol = 0; nCol < MAX_COLUMNS; nCol++)
    {
        // GetStringWidth doesn't seem to report the right thing,
        // so we have to add a fudge factor of 15.... oh well.
        if (aColWidth[nCol] > 0)
            ListCtrl.SetColumnWidth(nCol, aColWidth[nCol] + 15);
    }

} // COptionsConfig::FillOptions()

/////////////////////////////////////////////////////////////////////////////
// COptionsCfgBasic property page

IMPLEMENT_DYNCREATE(COptionsCfgPropPage, CPropertyPageBase)

COptionsCfgPropPage::COptionsCfgPropPage() : 
   CPropertyPageBase(COptionsCfgPropPage::IDD),
   m_bInitialized(FALSE)
{
    LoadBitmaps();

    m_helpMap.BuildMap(DhcpGetHelpMap(COptionsCfgPropPage::IDD));
}

COptionsCfgPropPage::COptionsCfgPropPage(UINT nIDTemplate, UINT nIDCaption) : 
   CPropertyPageBase(nIDTemplate, nIDCaption),
   m_bInitialized(FALSE)
{
   //{{AFX_DATA_INIT(COptionsCfgPropPage)
   //}}AFX_DATA_INIT
    
    LoadBitmaps();

    m_helpMap.BuildMap(DhcpGetHelpMap(COptionsCfgPropPage::IDD));
}

COptionsCfgPropPage::~COptionsCfgPropPage()
{
}

void
COptionsCfgPropPage::LoadBitmaps()
{
}

void COptionsCfgPropPage::DoDataExchange(CDataExchange* pDX)
{
    CPropertyPageBase::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(COptionsCfgPropPage)
    DDX_Control(pDX, IDC_LIST_OPTIONS, m_listctrlOptions);
    //}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(COptionsCfgPropPage, CPropertyPageBase)
    //{{AFX_MSG_MAP(COptionsCfgPropPage)
    ON_WM_DESTROY()
    ON_NOTIFY(LVN_ITEMCHANGED, IDC_LIST_OPTIONS, OnItemchangedListOptions)
    //}}AFX_MSG_MAP
    
    ON_MESSAGE(WM_SELECTOPTION, OnSelectOption)
    
    // Binary array controls
    ON_EN_CHANGE(IDC_EDIT_VALUE, OnChangeEditValue)
    ON_BN_CLICKED(IDC_BUTTON_VALUE_UP, OnButtonValueUp)
    ON_BN_CLICKED(IDC_BUTTON_VALUE_DOWN, OnButtonValueDown)
    ON_BN_CLICKED(IDC_BUTTON_VALUE_ADD, OnButtonValueAdd)
    ON_BN_CLICKED(IDC_BUTTON_VALUE_DELETE, OnButtonValueDelete)
    ON_BN_CLICKED(IDC_RADIO_DECIMAL, OnClickedRadioDecimal)
    ON_BN_CLICKED(IDC_RADIO_HEX, OnClickedRadioHex)
    ON_LBN_SELCHANGE(IDC_LIST_VALUES, OnSelchangeListValues)
    
    // Byte, WORD and Long edit control
    ON_EN_CHANGE(IDC_EDIT_DWORD, OnChangeEditDword)
    
    // string edit control
    ON_EN_CHANGE(IDC_EDIT_STRING_VALUE, OnChangeEditString)
    
    // IP Address control
    ON_EN_CHANGE(IDC_IPADDR_ADDRESS, OnChangeIpAddress)
    
    // IP Address array controls
    ON_EN_CHANGE(IDC_EDIT_SERVER_NAME, OnChangeEditServerName)
    ON_EN_CHANGE(IDC_IPADDR_SERVER_ADDRESS, OnChangeIpAddressArray)
    ON_BN_CLICKED(IDC_BUTTON_RESOLVE, OnButtonResolve)
    ON_BN_CLICKED(IDC_BUTTON_IPADDR_UP, OnButtonIpAddrUp)
    ON_BN_CLICKED(IDC_BUTTON_IPADDR_DOWN, OnButtonIpAddrDown)
    ON_BN_CLICKED(IDC_BUTTON_IPADDR_ADD, OnButtonIpAddrAdd)
    ON_BN_CLICKED(IDC_BUTTON_IPADDR_DELETE, OnButtonIpAddrDelete)
    ON_LBN_SELCHANGE(IDC_LIST_IP_ADDRS, OnSelchangeListIpAddrs)
    
    // binary and encapsulated data
    ON_EN_CHANGE(IDC_VALUEDATA, OnChangeValueData)
    
    // route array controls
    ON_BN_CLICKED(IDC_BUTTON_ROUTE_ADD, OnButtonAddRoute)
    ON_BN_CLICKED(IDC_BUTTON_ROUTE_DEL, OnButtonDelRoute)

    // string array controls
    ON_EN_CHANGE(IDC_EDIT_STRING, OnChangeStringArrayValue)
    ON_LBN_SELCHANGE(IDC_LIST_STRING_ARRAY, OnSelChangeStringArrayList)
    ON_BN_CLICKED(IDC_BUTTON_STRING_ARRAY_ADD, OnButtonStringArrayAdd)
    ON_BN_CLICKED(IDC_BUTTON_STRING_ARRAY_REMOVE, OnButtonStringArrayRemove)
    ON_BN_CLICKED(IDC_BUTTON_STRING_ARRAY_UP, OnButtonStringArrayUp)
    ON_BN_CLICKED(IDC_BUTTON_STRING_ARRAY_DOWN, OnButtonStringArrayDown)
    
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// COptionsCfgPropPage message handlers
afx_msg long COptionsCfgPropPage::OnSelectOption(UINT wParam, LONG lParam) 
{
    COptionsConfig * pOptionsConfig = (COptionsConfig *) GetHolder();

    if (wParam != NULL)
    {
        CDhcpOptionItem * pOptItem = (CDhcpOptionItem *) ULongToPtr(wParam);
        HWND hWnd = NULL;

        pOptionsConfig->m_strStartVendor = pOptItem->GetVendor();
        pOptionsConfig->m_strStartClass = pOptItem->GetClassName();
        pOptionsConfig->m_dhcpStartId = pOptItem->GetOptionId();

        if ( (!pOptionsConfig->m_strStartVendor.IsEmpty() ||
              !pOptionsConfig->m_strStartClass.IsEmpty()) &&
              GetWindowLongPtr(GetSafeHwnd(), GWLP_ID) != IDP_OPTION_ADVANCED)
        {
            // we're on the basic page, need to switch to advanced
            ::PostMessage(pOptionsConfig->GetSheetWindow(), PSM_SETCURSEL, (WPARAM)1, NULL);
            hWnd = pOptionsConfig->m_pageAdvanced.GetSafeHwnd();
            ::PostMessage(hWnd, WM_SELECTCLASSES, (WPARAM) &pOptionsConfig->m_strStartVendor, (LPARAM) &pOptionsConfig->m_strStartClass);
        }
        else
        if ( (pOptionsConfig->m_strStartVendor.IsEmpty() &&
              pOptionsConfig->m_strStartClass.IsEmpty()) &&
              GetWindowLongPtr(GetSafeHwnd(), GWLP_ID) != IDP_OPTION_BASIC)
        {
            // we're on the advanced page, need to switch to basic
            ::PostMessage(pOptionsConfig->GetSheetWindow(), PSM_SETCURSEL, (WPARAM)0, NULL);
            hWnd = pOptionsConfig->m_pageGeneral.GetSafeHwnd();
        }

        ::PostMessage(hWnd, WM_SELECTOPTION, 0, 0);
        return 0;
    }
    
    for (int i = 0; i < m_listctrlOptions.GetItemCount(); i++)
    {
      COptionTracker * pCurOptTracker = 
         reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(i));
        if (pCurOptTracker->m_pOption->QueryId() == pOptionsConfig->m_dhcpStartId)
        {
            BOOL bDirty = IsDirty();

            m_listctrlOptions.SelectItem(i);
            m_listctrlOptions.EnsureVisible(i, FALSE);
            
            SetDirty(bDirty);

            break;
        }
    }

    // reset this variable since we don't need it anymore
    pOptionsConfig->m_dhcpStartId = -1;

    return 0;
}


/*---------------------------------------------------------------------------
   Handlers for the IP Array controls
 ---------------------------------------------------------------------------*/
void COptionsCfgPropPage::OnButtonIpAddrAdd() 
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   CWndIpAddress * pIpAddr = reinterpret_cast<CWndIpAddress *>(GetDlgItem(IDC_IPADDR_SERVER_ADDRESS));

   DWORD dwIpAddress;

   pIpAddr->GetAddress(&dwIpAddress);
   if (dwIpAddress)
   {
      int nSelectedItem = m_listctrlOptions.GetSelectedItem();
      // make sure that sometime is selected
      Assert(nSelectedItem > -1);

      if (nSelectedItem > -1)
      {
         CListBox * pListBox = reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_IP_ADDRS));
         CEdit * pServerName = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_SERVER_NAME));
      
         COptionTracker * pOptTracker = 
            reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedItem));

         // fill in the information in the option struct
         CDhcpOption * pOption = pOptTracker->m_pOption;
         CDhcpOptionValue & optValue = pOption->QueryValue();
         
         // check to see if we need to grow the array or not
         int nOldUpperBound = optValue.QueryUpperBound();

         if ((nOldUpperBound == 1) &&
            (optValue.QueryIpAddr() == 0))
         {
            // this array is empty.  Don't need to grow it
            nOldUpperBound -= 1;
         }
         else
         {
            // Set that the array is growing by 1
            optValue.SetUpperBound(nOldUpperBound + 1);
         }

         optValue.SetIpAddr((DHCP_IP_ADDRESS) dwIpAddress, nOldUpperBound);

         pOptTracker->SetDirty(TRUE);

         // add to the list box
         CString strAddress;
         ::UtilCvtIpAddrToWstr(dwIpAddress, &strAddress);

         pListBox->AddString(strAddress);

         // clear the server edit field and ip address
         pServerName->SetWindowText(_T(""));
         pIpAddr->ClearAddress();
            pIpAddr->SetFocusField(0);

         // finally, mark the page as dirty
         SetDirty(TRUE);
      }
   }
   else
   {
      ::DhcpMessageBox(IDS_ERR_DLL_INVALID_ADDRESS);
   }
}

void COptionsCfgPropPage::OnButtonIpAddrDelete() 
{
   int nSelectedOption = m_listctrlOptions.GetSelectedItem();

   CEdit * pServerName = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_SERVER_NAME));
   CWndIpAddress * pIpAddr = reinterpret_cast<CWndIpAddress *>(GetDlgItem(IDC_IPADDR_SERVER_ADDRESS));
   CListBox * pListBox = reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_IP_ADDRS));

   DWORD dwIpAddress;
   CString strIpAddress;
   int nSelectedIndex = pListBox->GetCurSel();

   // get the currently selected item
   pListBox->GetText(nSelectedIndex, strIpAddress);
   dwIpAddress = UtilCvtWstrToIpAddr(strIpAddress);

   // remove from the option
   COptionTracker * pOptTracker = 
      reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedOption));

   // pOptTracker can be null when the context moves to another option.
   // However, this is not disabled, so the user can still try to delete
   // an IP since it is active. 
   //
   // Add a null check

   if (0 != pOptTracker ) {
       // fill in the information in the option struct
       CDhcpOption * pOption = pOptTracker->m_pOption;
       CDhcpOptionValue & optValue = pOption->QueryValue();
       
       // the listbox should match our array, so we'll remove the same index
       optValue.RemoveIpAddr(nSelectedIndex);
       optValue.SetUpperBound(optValue.QueryUpperBound() - 1);
       
       // remove from list box
       pListBox->DeleteString(nSelectedIndex);
       pIpAddr->SetAddress(dwIpAddress);
       
       pServerName->SetWindowText(_T(""));
       
       // mark the option and the page as dirty
       pOptTracker->SetDirty(TRUE);
       SetDirty(TRUE);
       
       HandleActivationIpArray();
   } // if 
} // COptionsCfgPropPage::OnButtonIpAddrDelete()

void COptionsCfgPropPage::OnSelchangeListIpAddrs() 
{
   HandleActivationIpArray();
}

void COptionsCfgPropPage::OnChangeIpAddressArray() 
{
   HandleActivationIpArray();
}

void COptionsCfgPropPage::OnButtonResolve() 
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   CEdit * pServerName = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_SERVER_NAME));

   CString strServer;
   DHCP_IP_ADDRESS dhipa = 0;
   DWORD err = 0;

   pServerName->GetWindowText(strServer);

    //
    //  See what type of name it is.
    //
    switch (UtilCategorizeName(strServer))
    {
        case HNM_TYPE_IP:
            dhipa = ::UtilCvtWstrToIpAddr( strServer ) ;
            break ;

        case HNM_TYPE_NB:
        case HNM_TYPE_DNS:
            err = ::UtilGetHostAddress( strServer, & dhipa ) ;
         if (!err)
            UtilCvtIpAddrToWstr(dhipa, &strServer);
         break ;

        default:
            err = IDS_ERR_BAD_HOST_NAME ;
            break ;
    }

   if (err)
   {
      ::DhcpMessageBox(err);
   }
   else
   {
      CWndIpAddress * pIpAddr = reinterpret_cast<CWndIpAddress *>(GetDlgItem(IDC_IPADDR_SERVER_ADDRESS));
      pIpAddr->SetAddress(dhipa);   
   }
}
void COptionsCfgPropPage::OnChangeEditServerName() 
{
   HandleActivationIpArray();
}

void COptionsCfgPropPage::OnButtonIpAddrDown() 
{
    CButton * pIpAddrDown = 
        reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_IPADDR_DOWN));
    CButton * pIpAddrUp = 
        reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_IPADDR_UP));

   MoveValue(FALSE, FALSE);
    if (pIpAddrDown->IsWindowEnabled())
        pIpAddrDown->SetFocus();
    else
        pIpAddrUp->SetFocus();
}

void COptionsCfgPropPage::OnButtonIpAddrUp() 
{
    CButton * pIpAddrDown = 
        reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_IPADDR_DOWN));
    CButton * pIpAddrUp = 
        reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_IPADDR_UP));

    MoveValue(FALSE, TRUE);
    if (pIpAddrUp->IsWindowEnabled())
        pIpAddrUp->SetFocus();
    else
        pIpAddrDown->SetFocus();
}

/*---------------------------------------------------------------------------
   Handlers for the number array controls
 ---------------------------------------------------------------------------*/
void COptionsCfgPropPage::OnButtonValueAdd() 
{
   int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
   COptionTracker * pOptTracker = 
   reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedIndex));
   CEdit * pValue = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_VALUE));
   CListBox * pListBox = reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_VALUES));

   // Get the OptionValue object
   CDhcpOption * pOption = pOptTracker->m_pOption;
   CDhcpOptionValue & optValue = pOption->QueryValue();

   DWORD       dwValue;
   DWORD_DWORD dwdwValue;
   DWORD       dwMask = 0xFFFFFFFF ;

   switch ( optValue.QueryDataType()) 
   {
   case DhcpBinaryDataOption :
   case DhcpByteOption:
      dwMask = 0xFF ;
      break ;
   
   case DhcpWordOption:
      dwMask = 0xFFFF ;
      break ;
    } // switch
    
   if (optValue.QueryDataType() == DhcpDWordDWordOption) 
   {
      CString strValue;
      pValue->GetWindowText(strValue);
      UtilConvertStringToDwordDword(strValue, &dwdwValue);
   }
   else 
   {
      if (!FGetCtrlDWordValue(pValue->GetSafeHwnd(), &dwValue, 0, dwMask))
         return;
   }

   DWORD err = 0 ;

   CATCH_MEM_EXCEPTION 
   {
      // Set that the array is growing by 1
      int nOldUpperBound = optValue.QueryUpperBound();
      optValue.SetUpperBound(nOldUpperBound + 1);  

      // now insert the new item as the last item in the array
      (optValue.QueryDataType() == DhcpDWordDWordOption)
         ? optValue.SetDwordDword(dwdwValue, nOldUpperBound)
         : optValue.SetNumber(dwValue, nOldUpperBound);
   }
   END_MEM_EXCEPTION(err)

   if ( err ) 
   {
      ::DhcpMessageBox( err ) ;
   }
   else 
   {
      pOptTracker->SetDirty(TRUE);
      SetDirty(TRUE);
   }

   //
   // update controls. clear the edit control
   //
   pValue->SetWindowText(_T(""));
   pValue->SetFocus();
   FillDataEntry(pOption);
   HandleActivationValueArray();
} // COptionsCfgPropPage::OnButtonValueAdd()
 
void COptionsCfgPropPage::OnButtonValueDelete() 
{
    int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
        
    COptionTracker * pOptTracker = 
   reinterpret_cast<COptionTracker *>( m_listctrlOptions.GetItemData( nSelectedIndex ));
    CEdit * pValue = reinterpret_cast<CEdit *>( GetDlgItem( IDC_EDIT_VALUE ));
    CListBox * pListBox = 
   reinterpret_cast<CListBox *>( GetDlgItem( IDC_LIST_VALUES ));

    // Get the OptionValue object
    CDhcpOption * pOption = pOptTracker->m_pOption;
    CDhcpOptionValue & optValue = pOption->QueryValue();

    CString strValue;
    int nListBoxIndex = pListBox->GetCurSel();

    // get the currently selected item
    pListBox->GetText(nListBoxIndex, strValue);

    //if (!FGetCtrlDWordValue(pValue->GetSafeHwnd(), &dwValue, 0, dwMask))
    //    return;

    // the listbox should match our array, so we'll remove the same index
    (optValue.QueryDataType() == DhcpDWordDWordOption) ?
        optValue.RemoveDwordDword(nListBoxIndex) : optValue.RemoveNumber(nListBoxIndex);
        
    optValue.SetUpperBound(optValue.QueryUpperBound() - 1);

    // remove from list box
    pListBox->DeleteString( nListBoxIndex );
    nListBoxIndex--;
    if ( nListBoxIndex < 0 ) {
   nListBoxIndex = 0;
    }
    pListBox->SetCurSel( nListBoxIndex );
    pValue->SetWindowText(strValue);

    // mark the option and the page as dirty
    pOptTracker->SetDirty(TRUE);
    SetDirty(TRUE);

    HandleActivationValueArray();
}

void COptionsCfgPropPage::OnButtonValueDown() 
{
    CButton * pValueDown = 
        reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_VALUE_DOWN));
    CButton * pValueUp = 
        reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_VALUE_UP));

    MoveValue(TRUE, FALSE);
    if (pValueDown->IsWindowEnabled())
        pValueDown->SetFocus();
    else
        pValueUp->SetFocus();
}

void COptionsCfgPropPage::OnButtonValueUp() 
{
    CButton * pValueDown = 
        reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_VALUE_DOWN));
    CButton * pValueUp = 
        reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_VALUE_UP));

    MoveValue(TRUE, TRUE);
    if (pValueUp->IsWindowEnabled())
        pValueUp->SetFocus();
    else
        pValueDown->SetFocus();
}

void COptionsCfgPropPage::MoveValue(BOOL bValues, BOOL bUp)
{
    int nSelectedOption = m_listctrlOptions.GetSelectedItem();

    // Get the option that describes this
    COptionTracker * pOptTracker = 
        reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedOption));
    if ( 0 == pOptTracker ) {
        return;
    }
    CDhcpOption * pOption = pOptTracker->m_pOption;
    if ( 0 == pOption ) {
        return;
    }

    CDhcpOptionValue & optValue = pOption->QueryValue();

    // Get the correct listbox
    CListBox * pListBox;
    if (bValues)
    {
        // this is for values
        pListBox = reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_VALUES));
    }
    else
    {
        // this is for IpAddrs
        pListBox = reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_IP_ADDRS));
    }

    if ( 0 == pListBox ) {
        return;
    }

    // now get which item is selected in the listbox
    int cFocus = pListBox->GetCurSel();

    // make sure it's valid for this operation
    if ( (bUp && cFocus <= 0) ||
         (!bUp && cFocus >= pListBox->GetCount()) )
    {
        return;
    }

    DWORD       dwValue;
    DWORD_DWORD dwdwValue;
    DWORD       err = 0 ;

    // move the value up/down
    CATCH_MEM_EXCEPTION
    {
        if (optValue.QueryDataType() == DhcpDWordDWordOption)
        {
            DWORD_DWORD dwUpValue;
            DWORD_DWORD dwDownValue;

            if (bUp)
            {
                dwdwValue = dwUpValue = optValue.QueryDwordDword(cFocus);
                dwDownValue = optValue.QueryDwordDword(cFocus - 1);

                optValue.SetDwordDword(dwUpValue, cFocus - 1);
                optValue.SetDwordDword(dwDownValue, cFocus);
            }
            else
            {
                dwdwValue = dwDownValue = optValue.QueryDwordDword(cFocus);
                dwUpValue = optValue.QueryDwordDword(cFocus + 1);

                optValue.SetDwordDword(dwDownValue, cFocus + 1);
                optValue.SetDwordDword(dwUpValue, cFocus);
            }
        }
        else
        {
            DWORD dwUpValue;
            DWORD dwDownValue;

            if (bUp)
            {
                dwValue = dwUpValue = optValue.QueryNumber(cFocus);
                dwDownValue = optValue.QueryNumber(cFocus - 1);

                optValue.SetNumber(dwUpValue, cFocus - 1);
                optValue.SetNumber(dwDownValue, cFocus);
            }
            else
            {
                dwValue = dwDownValue = optValue.QueryNumber(cFocus);
                dwUpValue = optValue.QueryNumber(cFocus + 1);

                optValue.SetNumber(dwDownValue, cFocus + 1);
                optValue.SetNumber(dwUpValue, cFocus);
            }
        }
    }
    END_MEM_EXCEPTION(err)

    if ( err )
    {
        ::DhcpMessageBox( err ) ;
    }
    else
    {
        // everything is ok, mark this option and the prop sheet
        pOptTracker->SetDirty(TRUE);
        SetDirty(TRUE);
    }

    // update the data.
    FillDataEntry(pOption);

    // Set the selection correctly
    pListBox->SetCurSel( bUp ? cFocus - 1 : cFocus + 1 );

    // update the controls
    if (bValues)
    {
        HandleActivationValueArray();
    }
    else
    {
        HandleActivationIpArray();
    }
} // COptionsCfgPropPage::MoveValue()

void COptionsCfgPropPage::OnChangeEditValue() 
{
   HandleActivationValueArray();
}

void COptionsCfgPropPage::OnClickedRadioDecimal() 
{
   int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
   
   COptionTracker * pOptTracker = 
      reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedIndex));

   CDhcpOption * pOption = pOptTracker->m_pOption;

   FillDataEntry(pOption);
}

void COptionsCfgPropPage::OnClickedRadioHex() 
{
   int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
   
   COptionTracker * pOptTracker = 
      reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedIndex));

   CDhcpOption * pOption = pOptTracker->m_pOption;

   FillDataEntry(pOption);
}

void COptionsCfgPropPage::OnSelchangeListValues() 
{
   HandleActivationValueArray();
}

/*---------------------------------------------------------------------------
   Handlers for the binary and encapsulated data
 ---------------------------------------------------------------------------*/
void COptionsCfgPropPage::OnChangeValueData() 
{
   int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
   
   COptionTracker * pOptTracker = 
      reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedIndex));
   CEdit * pValue = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_VALUE));
   CListBox * pListBox = reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_VALUES));

   // Get the OptionValue object
   CDhcpOption * pOption = pOptTracker->m_pOption;
   CDhcpOptionValue & optValue = pOption->QueryValue();

    // get the info from the control
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(GetDlgItem(IDC_VALUEDATA)->GetSafeHwnd(), GWLP_USERDATA);

    DWORD err = 0;

    CATCH_MEM_EXCEPTION
    {
        // size we don't know what changed, we just have to copy all of the data
        optValue.RemoveAll();
        for (int i = 0; i < pHexEditData->cbBuffer; i++)
        {   
            DWORD dwValue = (BYTE) pHexEditData->pBuffer[i];
            optValue.SetNumber(dwValue, i);
        }
    }
    END_MEM_EXCEPTION(err)

    // mark the option and the page as dirty
   pOptTracker->SetDirty(TRUE);
   SetDirty(TRUE);
}

/*---------------------------------------------------------------------------
   Handlers for the single number entry controls
 ---------------------------------------------------------------------------*/
void COptionsCfgPropPage::OnChangeEditDword() 
{
   HandleValueEdit();
}

/*---------------------------------------------------------------------------
   Handlers for the single IP Address entry controls
 ---------------------------------------------------------------------------*/
void COptionsCfgPropPage::OnChangeIpAddress() 
{
   HandleValueEdit();
}

/*---------------------------------------------------------------------------
   Handlers for the string entry controls
 ---------------------------------------------------------------------------*/
void COptionsCfgPropPage::OnChangeEditString() 
{
   HandleValueEdit();
}

/////////////////////////////////////////////////////////////////////////////
// CAddRoute dialog

CAddRoute::CAddRoute( CWnd *pParent)
    : CBaseDialog( CAddRoute::IDD, pParent )
{
    m_ipaDest.ClearAddress();
    m_ipaMask.ClearAddress();
    m_ipaRouter.ClearAddress();
    m_bChange = FALSE;
}

void CAddRoute::DoDataExchange(CDataExchange* pDX)
{
    CBaseDialog::DoDataExchange(pDX);
   //{{AFX_DATA_MAP(CAddRoute)
   //}}AFX_DATA_MAP

    DDX_Control(pDX, IDC_IPADDR_ADDRESS, m_ipaDest);
    DDX_Control(pDX, IDC_IPADDR_ADDRESS2, m_ipaMask);
    DDX_Control(pDX, IDC_IPADDR_ADDRESS3, m_ipaRouter);
}

BEGIN_MESSAGE_MAP(CAddRoute, CBaseDialog)
   //{{AFX_MSG_MAP(CAddRoute)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAddReservation message handlers

BOOL CAddRoute::OnInitDialog() 
{
   CBaseDialog::OnInitDialog();

    // set focus on the destination..
    CWnd *pWnd = GetDlgItem(IDC_IPADDR_ADDRESS);
    if( NULL != pWnd )
    {
        pWnd->SetFocus();
        return FALSE;
    }
    
    return TRUE;  // return TRUE unless you set the focus to a control
                 // EXCEPTION: OCX Property Pages should return FALSE
}

void CAddRoute::OnOK() 
{
   DWORD err = 0;
    
    UpdateData();

    m_ipaDest.GetAddress( &Dest );
    m_ipaMask.GetAddress( &Mask );
    m_ipaRouter.GetAddress( &Router );

    // validate the ip addresses
    if( 0 == Router || (0 != Mask && 0 == Dest) ||
        0 != ((~Mask) & Dest) ||
        (0 != ((~Mask) & ((~Mask)+1)) ) )
    {
        ::DhcpMessageBox( IDS_ERR_INVALID_ROUTE_ENTRY );
    }
    else
    {
        m_bChange = TRUE;
        
        CBaseDialog::OnOK();
    }
   //CBaseDialog::OnOK();
}
    
/*--------------------------------------------------------------------------
        Handlers for String Array Editor
 ---------------------------------------------------------------------------*/

void COptionsCfgPropPage::OnSelChangeStringArrayList()
{
    HandleActivationStringArray();
} // COptionsCfgPropPage::OnSelChangeStringArrayList()

void COptionsCfgPropPage::OnChangeStringArrayValue()
{
    // Get the string edit box control
    CEdit *pEdit = reinterpret_cast<CEdit *>( GetDlgItem( IDC_EDIT_STRING ));
    
    CString str;

    pEdit->GetWindowText( str );
    if ( !str.IsEmpty()) 
    {
      CButton *pAdd = reinterpret_cast<CButton *>( GetDlgItem( IDC_BUTTON_STRING_ARRAY_ADD ));
      pAdd->EnableWindow( TRUE );
    }
    HandleActivationStringArray();
} // COptionsCfgPropPage::OnChangeStringArrayValue()

void COptionsCfgPropPage::OnButtonStringArrayAdd()
{
    int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
    COptionTracker * pOptTracker = 
      reinterpret_cast<COptionTracker *>( m_listctrlOptions.GetItemData( nSelectedIndex ));

    // Get the OptionValue object
    CDhcpOption * pOption = pOptTracker->m_pOption;
    CDhcpOptionValue & optValue = pOption->QueryValue();

    // Get the strings list control
    CListBox *pList = reinterpret_cast<CListBox *>( GetDlgItem( IDC_LIST_STRING_ARRAY ));
    
    // Get the string edit box control
    CEdit *pEdit = reinterpret_cast<CEdit *>( GetDlgItem( IDC_EDIT_STRING ));

    CString strValue;
    pEdit->GetWindowText( strValue );

    // Do not add empty strings
    if ( !strValue.IsEmpty()) 
    {
      pList->InsertString( 0, strValue );
      pList->SetCurSel( 0 );
      pEdit->SetWindowText( L"" );
    } // if

    HandleActivationStringArray();

    // set the focus back to the edit box
    pEdit->SetFocus();
    pOptTracker->SetDirty( TRUE );
    SetDirty( TRUE );

} // COptionsCfgPropPage::OnButtonStringArrayAdd()
    
void COptionsCfgPropPage::OnButtonStringArrayRemove()
{
    int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
    COptionTracker * pOptTracker = 
      reinterpret_cast<COptionTracker *>( m_listctrlOptions.GetItemData( nSelectedIndex ));

    // Get the OptionValue object
    CDhcpOption * pOption = pOptTracker->m_pOption;
    CDhcpOptionValue & optValue = pOption->QueryValue();


    // Get the strings list control
    CListBox *pList = reinterpret_cast<CListBox *>( GetDlgItem( IDC_LIST_STRING_ARRAY ));
    CEdit *pEdit = reinterpret_cast<CEdit *>( GetDlgItem( IDC_EDIT_STRING ));

    CString str;
    int nItem = pList->GetCurSel();

    pList->GetText( nItem, str );
    pEdit->SetWindowText( str );

    optValue.RemoveString( nItem );
    pList->DeleteString( nItem );

    nItem--;
    if ( nItem < 0 ) 
    {
      nItem = 0;
    }
    pList->SetCurSel( nItem );
    pList->SetFocus();
    HandleActivationStringArray();

    pOptTracker->SetDirty( TRUE );
    SetDirty( TRUE );

} // COptionsCfgPropPage::OnButtonStringArrayRemove()
    
void COptionsCfgPropPage::OnButtonStringArrayUp()
{

    int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
    COptionTracker * pOptTracker = 
   reinterpret_cast<COptionTracker *>( m_listctrlOptions.GetItemData( nSelectedIndex ));

    // Get the strings list control
    CListBox *pList = reinterpret_cast<CListBox *>( GetDlgItem( IDC_LIST_STRING_ARRAY ));
    
    int nItem = pList->GetCurSel();
    CString str; 

    if ( nItem > 0 ) 
    {
      pList->GetText( nItem, str );
      pList->DeleteString( nItem );
      pList->InsertString( nItem - 1, str );

      pList->SetCurSel( nItem - 1 );
      pOptTracker->SetDirty( TRUE );
      SetDirty( TRUE );
    } // if
    HandleActivationStringArray();
} // COptionsCfgPropPage::OnButtonStringArrayUp()
    
void COptionsCfgPropPage::OnButtonStringArrayDown()
{
    int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
    COptionTracker * pOptTracker = 
      reinterpret_cast<COptionTracker *>( m_listctrlOptions.GetItemData( nSelectedIndex ));

    // Get the strings list control
    CListBox *pList = reinterpret_cast<CListBox *>( GetDlgItem( IDC_LIST_STRING_ARRAY ));
    
    int nItem = pList->GetCurSel();
    CString str; 
    int nCount = pList->GetCount();
    if ( nItem < nCount - 1 ) 
    {
      pList->GetText( nItem, str );
      pList->DeleteString( nItem );
      if ( nItem <  nCount - 1 ) 
      {
         nItem++;
      }
      pList->InsertString( nItem, str );
      pList->SetCurSel( nItem );
      pOptTracker->SetDirty( TRUE );
      SetDirty( TRUE );
    } // ifs 

    HandleActivationStringArray();
} // COptionsCfgPropPage::OnButtonStringArrayDown()
    
/*---------------------------------------------------------------------------
   Handlers for the route add data entry controls
 ---------------------------------------------------------------------------*/
void COptionsCfgPropPage::OnButtonAddRoute()
{
   int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
   
   COptionTracker * pOptTracker = 
      reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedIndex));

   // Get the OptionValue object
   CDhcpOption * pOption = pOptTracker->m_pOption;
   CDhcpOptionValue & optValue = pOption->QueryValue();

    // get the routes list control
    CListCtrl *pList = reinterpret_cast<CListCtrl *>(
        GetDlgItem( IDC_LIST_OF_ROUTES ) );

    // get the add and remove buttons
    CButton *pAdd = reinterpret_cast<CButton *>(
        GetDlgItem(IDC_BUTTON_ROUTE_ADD) );
    CButton *pRemove = reinterpret_cast<CButton *>(
            GetDlgItem(IDC_BUTTON_ROUTE_DEL) );
    

    // throw the add route UI
    CAddRoute NewRoute(NULL);

    NewRoute.DoModal();

    if( NewRoute.m_bChange ) {
   CString strDest, strMask, strRouter;
   
   // obtain the three strings..
   ::UtilCvtIpAddrToWstr(NewRoute.Dest, &strDest);
   ::UtilCvtIpAddrToWstr(NewRoute.Mask, &strMask);
   ::UtilCvtIpAddrToWstr(NewRoute.Router, &strRouter);
        
   LV_ITEM lvi;
        
   lvi.mask = LVIF_TEXT;
   lvi.iItem = pList->GetItemCount();
   lvi.iSubItem = 0;
   lvi.pszText = (LPTSTR)(LPCTSTR)strDest;
   lvi.iImage = 0;
   lvi.stateMask = 0;
   int nItem = pList->InsertItem(&lvi);
   pList->SetItemText(nItem, 1, strMask);
   pList->SetItemText(nItem, 2, strRouter);

   // Unselect other items
   for ( int i = 0; i < pList->GetItemCount(); i++ ) {
       pList->SetItemState( i, 0, LVIS_SELECTED );
   }
   
   // Select this item 
   pList->SetItemState( nItem, LVIS_SELECTED, LVIS_SELECTED );
   
   pOptTracker->SetDirty(TRUE);
   SetDirty(TRUE);
    } // if
    
    // now walk through the list control and get the values and
    // put them back onto the optValue    

    HandleActivationRouteArray( &optValue );
} // COptionsCfgPropPage::OnButtonAddRoute()

void COptionsCfgPropPage::OnButtonDelRoute()
{
    int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
    int nDelItem = 0;
    int nItems;

    COptionTracker * pOptTracker = 
   reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedIndex));

    // Get the OptionValue object
    CDhcpOption * pOption = pOptTracker->m_pOption;
    CDhcpOptionValue & optValue = pOption->QueryValue();

    // get the routes list control
    CListCtrl *pList = reinterpret_cast<CListCtrl *>
   ( GetDlgItem( IDC_LIST_OF_ROUTES ));

    // get the add and remove buttons
    CButton *pAdd = reinterpret_cast<CButton *>
   ( GetDlgItem( IDC_BUTTON_ROUTE_ADD ));
    CButton *pRemove = reinterpret_cast<CButton *>
   ( GetDlgItem( IDC_BUTTON_ROUTE_DEL ));
    
    // get the selected column and delete it
    int nItem = pList->GetNextItem(-1, LVNI_SELECTED);
    while( nItem != -1 ) {
        pList->DeleteItem( nItem ) ;
   nDelItem = nItem;

        nItem = pList->GetNextItem(-1, LVNI_SELECTED);

        pOptTracker->SetDirty(TRUE);
        SetDirty(TRUE);        
    } // while
    
    // Select an item
    nItems = pList->GetItemCount();
    if ( nItems > 0 ) {
   if ( nDelItem >= nItems ) {
       nDelItem = nItems - 1;
   }
   pList->SetItemState( nDelItem, LVIS_SELECTED, LVIS_SELECTED );
    } // if

    // now walk through the list control and get the values and
    // put them back onto the optValue

    HandleActivationRouteArray( &optValue );
} // COptionsCfgPropPage::OnButtonDelRoute()


BOOL COptionsCfgPropPage::OnInitDialog() 
{
    CPropertyPageBase::OnInitDialog();
    
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    
    // set the title   
    ((COptionsConfig *) GetHolder())->SetTitle();
    
    // initialize the list control
    InitListCtrl();
    
    // initialize the option data
    DWORD dwErr = ((COptionsConfig *) GetHolder())->InitData();
    if (dwErr != ERROR_SUCCESS)  {
   // CODEWORK:  need to exit gracefull if this happens     
   ::DhcpMessageBox(dwErr);
    }
    else {
   // Fill the options for this page type - basic, advanced, custom
   ((COptionsConfig *) GetHolder())->FillOptions(_T(""), _T(""), m_listctrlOptions);
    }
    
    // Create the type control switcher
    m_cgsTypes.Create(this,IDC_DATA_ENTRY_ANCHOR,cgsPreCreateAll);
    
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_NONE, IDD_DATA_ENTRY_NONE, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_DWORD, IDD_DATA_ENTRY_DWORD,  NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_IPADDRESS, IDD_DATA_ENTRY_IPADDRESS,   NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_IPADDRESS_ARRAY, IDD_DATA_ENTRY_IPADDRESS_ARRAY, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_STRING, IDD_DATA_ENTRY_STRING, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_BINARY_ARRAY, IDD_DATA_ENTRY_BINARY_ARRAY, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_BINARY, IDD_DATA_ENTRY_BINARY, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_ROUTE_ARRAY, IDD_DATA_ENTRY_ROUTE_ARRAY, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_STRING_ARRAY, IDD_DATA_ENTRY_STRING_ARRAY, NULL);
    
    m_hexData.SubclassDlgItem(IDC_VALUEDATA, this);
    
    SwitchDataEntry(-1, -1, 0, TRUE);
    
    SetDirty(FALSE);
    
    m_bInitialized = TRUE;
    
    return TRUE;  // return TRUE unless you set the focus to a control
    // EXCEPTION: OCX Property Pages should return FALSE
} // COptionsCfgPropPage::OnInitDialog()

void COptionsCfgPropPage::SelectOption(CDhcpOption * pOption)
{
    for (int i = 0; i < m_listctrlOptions.GetItemCount(); i++)
   {
       COptionTracker * pCurOptTracker = 
      reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(i));
        
       if (pOption->QueryId() == pCurOptTracker->m_pOption->QueryId())
      {
          m_listctrlOptions.SelectItem(i);
          m_listctrlOptions.EnsureVisible(i, FALSE);
      }
   }
}


void COptionsCfgPropPage::SwitchDataEntry(
    int datatype,
    int optiontype,
    BOOL fRouteArray,
    BOOL bEnable
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    CString strType;
   
    if( fRouteArray )
   {
       // ignore any other types passed and use route_array type
       m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_ROUTE_ARRAY);
   }
    else {
   switch(datatype) {
   case DhcpByteOption:
   case DhcpWordOption:
   case DhcpDWordOption:
   case DhcpDWordDWordOption:
       {
      // build our string for the type of data
      if ( (datatype == DhcpByteOption) || 
           (datatype == DhcpEncapsulatedDataOption) )
          {
         strType.LoadString(IDS_INFO_TYPOPT_BYTE);
          }
      else
          if (datatype == DhcpWordOption)
         {
             strType.LoadString(IDS_INFO_TYPOPT_WORD);
         }
          else
         if (datatype == DhcpDWordOption)
             {
            strType.LoadString(IDS_INFO_TYPOPT_DWORD);
             }
         else
             {
            strType.LoadString(IDS_INFO_TYPOPT_DWDW);
             }

      if (optiontype == DhcpArrayTypeOption)
          {
         m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_BINARY_ARRAY);
         CButton * pRadioDecimal = 
             reinterpret_cast<CButton *>(GetDlgItem(IDC_RADIO_DECIMAL));
         CButton * pRadioHex = 
             reinterpret_cast<CButton *>( GetDlgItem( IDC_RADIO_HEX ));

         if ( !( pRadioHex->GetCheck() ^ pRadioDecimal->GetCheck())) {
             pRadioDecimal->SetCheck( 1 );
         }

         // set some information text
         CString strFrameText;
         strFrameText.LoadString(IDS_DATA_ENTRY_FRAME);
         strFrameText += _T(" ") + strType;

         CWnd * pWnd = GetDlgItem(IDC_STATIC_BINARY_ARRAY_FRAME);
         pWnd->SetWindowText(strFrameText);
          }
      else
          {
         m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_DWORD);
         CWnd * pWnd = GetDlgItem(IDC_STATIC_TYPE);

         pWnd->SetWindowText(strType);
          }
       }
       break;

   case DhcpBinaryDataOption:
   case DhcpEncapsulatedDataOption:
       {
      m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_BINARY);
       }
            break;

        case DhcpIpAddressOption:
       if (optiontype == DhcpArrayTypeOption)
      {
          strType.LoadString(IDS_INFO_TYPOPT_BYTE);
          m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_IPADDRESS_ARRAY);

          CButton * pRadioDecimal = 
         reinterpret_cast<CButton *>(GetDlgItem(IDC_RADIO_DECIMAL));

          pRadioDecimal->SetCheck(1);

          // set some information text
          CString strFrameText;
          strFrameText.LoadString(IDS_DATA_ENTRY_FRAME);
          strFrameText += _T(" ") + strType;

          CWnd * pWnd = GetDlgItem(IDC_STATIC_BINARY_ARRAY_FRAME);
          pWnd->SetWindowText(strFrameText);
      }
       else
      m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_IPADDRESS);
       break;

   case DhcpStringDataOption:
       if (optiontype == DhcpArrayTypeOption)
      m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_STRING_ARRAY);
       else
      m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_STRING);
       break;

   default:

       m_cgsTypes.ShowGroup(IDC_DATA_ENTRY_NONE);
       break;
   } // switch 
    } // else

    // enable/disable the current group
    m_cgsTypes.EnableGroup(-1, bEnable);

} // COptionsCfgPropPage::SwitchDataEntry()

const int ROUTE_LIST_COL_WIDTHS[3] = {
    100, 100, 100
};

const int ROUTE_LIST_COL_HEADERS[3] = {
    IDS_ROUTE_LIST_COL_DEST,
    IDS_ROUTE_LIST_COL_MASK,
    IDS_ROUTE_LIST_COL_ROUTER
};

void COptionsCfgPropPage::FillDataEntry(CDhcpOption * pOption)
{
   CDhcpOptionValue & optValue = pOption->QueryValue();

   int datatype = pOption->QueryDataType();
   int optiontype = pOption->QueryOptType();
   BOOL fRouteArray = ( !pOption->IsClassOption() &&
         (DHCP_OPTION_ID_CSR == pOption->QueryId()) &&
         optiontype == DhcpUnaryElementTypeOption &&
         datatype == DhcpBinaryDataOption
         );
   CButton * pRadioHex = 
      reinterpret_cast<CButton *>(GetDlgItem(IDC_RADIO_HEX));
   BOOL bUseHex = pRadioHex->GetCheck();

   if( fRouteArray ) 
   {
      const CByteArray * pbaData = optValue.QueryBinaryArray();
      int nDataSize = (int)pbaData->GetSize();
      LPBYTE pData = (LPBYTE) pbaData->GetData();
      
      // initialize the list control view with data
           
      CListCtrl *pList =
         reinterpret_cast<CListCtrl *>(GetDlgItem(IDC_LIST_OF_ROUTES));
      Assert(pList);
      pList->DeleteAllItems();
      pList->SetExtendedStyle(LVS_EX_FULLROWSELECT);
      pList->DeleteColumn(2);
      pList->DeleteColumn(1);
      pList->DeleteColumn(0);
      
      LV_COLUMN lvc;
      CString strColHeader;
           
      for( int i = 0; i < 3; i ++ ) 
      {
         lvc.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH ;
         lvc.iSubItem = i;
         lvc.fmt = LVCFMT_LEFT;
         lvc.cx = ROUTE_LIST_COL_WIDTHS[i];
         strColHeader.LoadString(ROUTE_LIST_COL_HEADERS[i]);
         lvc.pszText = (LPTSTR)(LPCTSTR)strColHeader;
          
         pList->InsertColumn( i, &lvc );
      } // for 
      
      // convert pData to list of ip addresses as per RFC
      while( nDataSize > sizeof(DWORD) ) 
      {
         // first 1 byte contains the # of bits in subnetmask
         nDataSize --;
         BYTE nBitsMask = *pData ++;
         DWORD Mask = (~0);
         if( nBitsMask < 32 ) Mask <<= (32-nBitsMask);
          
         // based on the # of bits, the next few bytes contain
         // the subnet address for the 1-bits of subnet mask
         int nBytesDest = (nBitsMask+7)/8;
         if( nBytesDest > 4 ) nBytesDest = 4;
          
         DWORD Dest = 0;
         memcpy( &Dest, pData, nBytesDest );
         pData += nBytesDest;
         nDataSize -= nBytesDest;
               
         // subnet address is obviously in network order.
         Dest = ntohl(Dest);
          
         // now the four bytes would be the router address
         DWORD Router = 0;
         if( nDataSize < sizeof(DWORD) ) 
         {
            Assert( FALSE ); break;
         }
          
         memcpy(&Router, pData, sizeof(DWORD));
         Router = ntohl( Router );
          
         pData += sizeof(DWORD);
         nDataSize -= sizeof(DWORD);
          
         // now fill the list box..
         CString strDest, strMask, strRouter;
          
         ::UtilCvtIpAddrToWstr(Dest, &strDest);
         ::UtilCvtIpAddrToWstr(Mask, &strMask);
         ::UtilCvtIpAddrToWstr(Router, &strRouter);
          
         LV_ITEM lvi;
               
         lvi.mask = LVIF_TEXT;
         lvi.iItem = pList->GetItemCount();
         lvi.iSubItem = 0;
         lvi.pszText = (LPTSTR)(LPCTSTR) strDest;
         lvi.iImage = 0;
         lvi.stateMask = 0;
         int nItem = pList->InsertItem(&lvi);
         pList->SetItemText(nItem, 1, strMask);
         pList->SetItemText(nItem, 2, strRouter);

      } // while 

      // select the first item
      if ( pList->GetItemCount() > 0 ) 
      {
         pList->SetItemState( 0, LVIS_SELECTED, LVIS_SELECTED );
      }
           
      HandleActivationRouteArray();
   } // if route array 
   else 
   {
      switch(datatype) 
      {
      case DhcpByteOption:
      case DhcpWordOption:
      case DhcpDWordOption:
         {
            if (optiontype == DhcpArrayTypeOption) 
            {
               CListBox * pListBox = 
                  reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_VALUES));

               CEdit *pValue = reinterpret_cast<CEdit *>
                  ( GetDlgItem( IDC_EDIT_VALUE ));
               CString strValue;
               long lValue;

               Assert(pListBox);
               pListBox->ResetContent();

               for (int i = 0; i < optValue.QueryUpperBound(); i++) {
                  lValue = optValue.QueryNumber(i);
                  if (bUseHex) 
                  {
                     strValue.Format(_T("0x%x"), lValue);
                  }
                  else 
                  {
                     strValue.Format(_T("%lu"), lValue);
                  }

                  pListBox->AddString(strValue);
               } // for 

               if ( pListBox->GetCount() > 0 ) 
               {
                  pListBox->SetCurSel( 0 );
               }

               // Convert the number in the edit box

               pValue->GetWindowText( strValue );
               if ( !strValue.IsEmpty()) 
               {
                  DWORD maxVal;

                  if ( DhcpByteOption == datatype ) 
                  {
                     maxVal = 0xff;
                  }
                  else  if ( DhcpWordOption == datatype ) 
                  {
                     maxVal = 0xffff;
                  }
                  else 
                  {
                     maxVal = 0xffffffff;
                  }

                  FGetCtrlDWordValue( pValue->GetSafeHwnd(),
                        ( DWORD * )&lValue, 0, maxVal );
                     
                  if ( bUseHex ) 
                  {
                     strValue.Format( _T("0x%x"), lValue );
                  }
                  else 
                  {
                     strValue.Format( _T("%lu"), lValue );
                  }
                  pValue->SetWindowText( strValue );
               } // if 
               HandleActivationValueArray();
         } // if array type
         else 
         {
            CString strValue;
            optValue.QueryDisplayString(strValue);
            CWnd * pWnd = GetDlgItem(IDC_EDIT_DWORD);
            Assert(pWnd);
            pWnd->SetWindowText(strValue);
         } // else single valued

         break;
      }
          
      case DhcpIpAddressOption:
         {
            if (optiontype == DhcpArrayTypeOption) 
            {
               CListBox * pListBox = 
                  reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_IP_ADDRS));

               Assert(pListBox);
               pListBox->ResetContent();

               for (int i = 0; i < optValue.QueryUpperBound(); i++) 
               {
                  CString strValue;
                  DHCP_IP_ADDRESS ipAddress = optValue.QueryIpAddr(i);
                              
                  if (ipAddress) 
                  {
                     ::UtilCvtIpAddrToWstr(ipAddress, &strValue);
                     pListBox->AddString(strValue);
                  }
               } // for

               HandleActivationIpArray();
            } // if array type
            else 
            {
               CWndIpAddress * pIpAddr = 
                  reinterpret_cast<CWndIpAddress *>(GetDlgItem(IDC_IPADDR_ADDRESS));
               
               DHCP_IP_ADDRESS ipAddress = optValue.QueryIpAddr();
               if (ipAddress)
                  pIpAddr->SetAddress(ipAddress);
               else
                  pIpAddr->ClearAddress();
            } // else single valued
          
            break;
         }  

      case DhcpStringDataOption:
         {
         if (optiontype == DhcpArrayTypeOption) 
         {
            CListBox * pListBox = 
            reinterpret_cast<CListBox *>( GetDlgItem( IDC_LIST_STRING_ARRAY ));
             
            Assert(pListBox);
            pListBox->ResetContent();
            CString str;
            for (int i = 0; i < optValue.QueryUpperBound(); i++) 
            {
               str = optValue.QueryString( i );
               if ( !str.IsEmpty()) 
               {
                  pListBox->AddString( optValue.QueryString( i ));
               }
               str = L"";
            } // for 

            if ( pListBox->GetCount() > 0 ) 
            {
               pListBox->SetCurSel( 0 );
            }
            HandleActivationStringArray();
         } // if array type
         else 
         {
            CWnd * pWnd = GetDlgItem(IDC_EDIT_STRING_VALUE);
            pWnd->SetWindowText(optValue.QueryString());
         } // else single valued
         break;
      }

      case DhcpDWordDWordOption:
         {
            if (optiontype == DhcpArrayTypeOption) 
            {
               CListBox * pListBox = 
                  reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_VALUES));
               CEdit *pValue = 
                  reinterpret_cast<CEdit *>( GetDlgItem( IDC_EDIT_VALUE ));
               CString strValue;
               DWORD_DWORD value;
               ULARGE_INTEGER ulValue;

               Assert(pListBox);
               pListBox->ResetContent();

               for (int i = 0; i < optValue.QueryUpperBound(); i++) 
               {
                  DWORD_DWORD dwdwValue = optValue.QueryDwordDword(i);
                  ::UtilConvertDwordDwordToString(&dwdwValue, &strValue, !bUseHex);
                  pListBox->AddString(strValue);
               } // for 

               if ( pListBox->GetCount() > 0 ) 
               {
                  pListBox->SetCurSel( 0 );
               }

               pValue->GetWindowText( strValue );
               if ( !strValue.IsEmpty()) 
               {
                  UtilConvertStringToDwordDword( strValue, &value );
                  UtilConvertDwordDwordToString( &value, &strValue, !bUseHex );
                  pValue->SetWindowText( strValue );
               } // if

               HandleActivationValueArray();
            } // if array type 
            else  
            {
               CString strValue;
               optValue.QueryDisplayString(strValue);
                
               CWnd * pWnd = GetDlgItem(IDC_EDIT_DWORD);
                
               Assert(pWnd);
               pWnd->SetWindowText(strValue);
            } // else single valued
            break;
         }
         
      case DhcpBinaryDataOption:
      case DhcpEncapsulatedDataOption: 
         {
            const CByteArray * pbaData = optValue.QueryBinaryArray();
            int nDataSize = (int)pbaData->GetSize();
            LPBYTE pData = (LPBYTE) pbaData->GetData();

            memset(m_BinaryBuffer, 0, sizeof(m_BinaryBuffer));

            if (pData) 
            {
               memcpy(m_BinaryBuffer, pData, nDataSize);
            }

            SendDlgItemMessage(IDC_VALUEDATA, HEM_SETBUFFER, (WPARAM)
               nDataSize, (LPARAM) m_BinaryBuffer);

            break;
      } // case ..
          
      default:
         {
            Assert(FALSE);
            break;
         }
      } // switch
   }
} // COptionsCfgPropPage::FillDataEntry()

void COptionsCfgPropPage::InitListCtrl()
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   // set image lists
   m_StateImageList.Create(IDB_LIST_STATE, 16, 1, RGB(255, 0, 0));

   m_listctrlOptions.SetImageList(NULL, LVSIL_NORMAL);
   m_listctrlOptions.SetImageList(NULL, LVSIL_SMALL);
   m_listctrlOptions.SetImageList(&m_StateImageList, LVSIL_STATE);

   // insert a column so we can see the items
   LV_COLUMN lvc;
    CString strColumnHeader;

    for (int i = 0; i < MAX_COLUMNS; i++)
    {
        lvc.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH;
        lvc.iSubItem = i;
        lvc.fmt = LVCFMT_LEFT;
        lvc.cx = COLUMN_WIDTHS[i];
        strColumnHeader.LoadString(COLUMN_HEADERS[i]);
        lvc.pszText = (LPTSTR) (LPCTSTR) strColumnHeader;

        m_listctrlOptions.InsertColumn(i, &lvc);
    }

    m_listctrlOptions.SetFullRowSel(TRUE);
}

void COptionsCfgPropPage::OnDestroy() 
{
   CImageList * pStateImageList = NULL;

   // if the control has been initialized, we need to cleanup
   if (m_listctrlOptions.GetSafeHwnd() != NULL)
   {
      pStateImageList = m_listctrlOptions.SetImageList(NULL, LVSIL_STATE);

      if (pStateImageList) {
                    //pStateImageList->DeleteImageList();
                }

      // The OptionTrackers get delete in the destructor
      m_listctrlOptions.DeleteAllItems();
   }
   m_listctrlOptions.DestroyWindow();

   CPropertyPageBase::OnDestroy();
}

void COptionsCfgPropPage::OnItemchangedListOptions(NMHDR* pNMHDR, LRESULT* pResult) 
{
   NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;

   if (pNMListView->uChanged & LVIF_STATE)
   {
      BOOL bUpdate = FALSE, bEnable = FALSE;
      UINT uFlags = pNMListView->uOldState ^ pNMListView->uNewState;

      COptionTracker* pCurOptTracker = 
         reinterpret_cast<COptionTracker *>
         (m_listctrlOptions.GetItemData(pNMListView->iItem));
      CDhcpOption* pCurOption = pCurOptTracker->m_pOption;

      BOOL bOldSelected = pNMListView->uOldState & LVIS_SELECTED;
      BOOL bNewSelected = pNMListView->uNewState & LVIS_SELECTED;

      BOOL bStateImageChanged =
         (pNMListView->uOldState & LVIS_STATEIMAGEMASK) !=
         (pNMListView->uNewState & LVIS_STATEIMAGEMASK);

      BOOL bIsSelected = m_listctrlOptions.IsSelected(pNMListView->iItem);

      // has this item been selected?
      if (!bOldSelected && bNewSelected)
      {
         // check to see if this item is checked
         bEnable = m_listctrlOptions.GetCheck(pNMListView->iItem);
         bUpdate = TRUE;
      }

      // has item been checked/unchecked?
      if (bStateImageChanged && m_bInitialized)
      {
         // mark this as dirty and enable apply button
         pCurOptTracker->SetDirty(TRUE);
         SetDirty(TRUE);

         // update the state in the option tracker
         UINT uCurrentState = m_listctrlOptions.GetCheck(pNMListView->iItem)
            ? OPTION_STATE_ACTIVE
            : OPTION_STATE_INACTIVE;
         pCurOptTracker->SetCurrentState(uCurrentState);

         // we force the the selection of an item if the user changes it's checkbox state
         if (!bIsSelected) 
         {
            m_listctrlOptions.SelectItem(pNMListView->iItem);
         }
      } // if 

      // if we are changing the check box on a selected item, then update
      if ((bStateImageChanged && bIsSelected))
      {
         bEnable = (pNMListView->uNewState & 
               INDEXTOSTATEIMAGEMASK(LISTVIEWEX_CHECKED)) > 0;
         bUpdate = TRUE;
      }

      // item needs to be updated
      if (bUpdate)
      {
         BOOL fRouteArray = ( !pCurOption->IsClassOption() &&
               (DHCP_OPTION_ID_CSR == pCurOption->QueryId()) &&
               DhcpUnaryElementTypeOption == pCurOption->QueryOptType() &&
               DhcpBinaryDataOption == pCurOption->QueryDataType());

         SwitchDataEntry( pCurOption->QueryDataType(),
               pCurOption->QueryOptType(), fRouteArray, bEnable); 
         FillDataEntry(pCurOption);
      } // if

   } // if 

   *pResult = 0;
} // COptionsCfgPropPage::OnItemchangedListOptions()

BOOL COptionsCfgPropPage::OnSetActive() 
{
   return CPropertyPageBase::OnSetActive();
}

void COptionsCfgPropPage::HandleActivationStringArray()
{
    int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
    if (nSelectedIndex == -1)
    {
       // Nothing selected
       return;
    }
    
    COptionTracker* pOptTracker = 
      reinterpret_cast<COptionTracker *>( m_listctrlOptions.GetItemData( nSelectedIndex ));
    _ASSERT(pOptTracker);

    // Get the OptionValue object
    CDhcpOption * pOption = pOptTracker->m_pOption;
    CDhcpOptionValue & optValue = pOption->QueryValue();

    CListBox *pList = reinterpret_cast<CListBox *>( GetDlgItem( IDC_LIST_STRING_ARRAY ));
    CButton *pAdd = reinterpret_cast<CButton *>( GetDlgItem( IDC_BUTTON_STRING_ARRAY_ADD ));
    CButton *pRemove = reinterpret_cast<CButton *>( GetDlgItem( IDC_BUTTON_STRING_ARRAY_REMOVE ));
    CButton *pUp = reinterpret_cast<CButton *>( GetDlgItem( IDC_BUTTON_STRING_ARRAY_UP ));
    CButton *pDown = reinterpret_cast<CButton *>( GetDlgItem( IDC_BUTTON_STRING_ARRAY_DOWN ));
    CEdit *pEdit = reinterpret_cast<CEdit *>( GetDlgItem( IDC_EDIT_STRING ));

    bool enableAllowed = (pList->IsWindowEnabled() == TRUE)?true:false;

    CString strValue;
    pEdit->GetWindowText( strValue );
    pAdd->EnableWindow( (!strValue.IsEmpty()) && enableAllowed);

    // Fill optionvalue with list entries.

    optValue.SetUpperBound( pList->GetCount());
    
    CString str;
    for ( int i = 0; i < pList->GetCount(); i++ ) 
    {
      pList->GetText( i, str );
      optValue.SetString( str, i );
    } // for 

    if ( pList->GetCount() == 0 ) 
    {
      pRemove->EnableWindow( FALSE );
      pUp->EnableWindow( FALSE );
      pDown->EnableWindow( FALSE );
      return;
    }
    int nSel = pList->GetCurSel();
    if ( LB_ERR != nSel ) 
    {
      pRemove->EnableWindow(enableAllowed);
      pUp->EnableWindow( (nSel > 0) && enableAllowed);
      pDown->EnableWindow( (pList->GetCount() > ( nSel + 1 )) && enableAllowed);
    } // if

    // check if the focus in on a disabled control
    // If yes, put the focus back to list box
    if ( !::IsWindowEnabled( ::GetFocus())) {
        pList->SetFocus();
    }

} // COptionsCfgPropPage::HandleActivationStringArray()

void COptionsCfgPropPage::HandleActivationIpArray()
{
   CString strServerName;
   CWndIpAddress * pIpAddr = reinterpret_cast<CWndIpAddress *>(GetDlgItem(IDC_IPADDR_SERVER_ADDRESS));
   CButton * pResolve = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_RESOLVE));
   CButton * pAdd = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_IPADDR_ADD));
   CButton * pRemove = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_IPADDR_DELETE));
   CButton * pUp = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_IPADDR_UP));
   CButton * pDown = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_IPADDR_DOWN));
   CEdit * pServerName = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_SERVER_NAME));
   CListBox * pListBox = reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_IP_ADDRS));

   bool enableAllowed = (pListBox->IsWindowEnabled() == TRUE)?true:false;

   // set the resolve button
   pServerName->GetWindowText(strServerName);
   pResolve->EnableWindow((strServerName.GetLength() > 0) && enableAllowed);

   // the add button
   DWORD dwIpAddr = 0;
   pIpAddr->GetAddress(&dwIpAddr);

   if (GetFocus() == pAdd &&
      dwIpAddr == 0)
   {
      pIpAddr->SetFocus();
      SetDefID(IDOK);
   }
   pAdd->EnableWindow((dwIpAddr != 0) && enableAllowed);

   // Make sure something in listbox is selected
   if ( pListBox->GetCount() > 0 ) {
       if ( LB_ERR == pListBox->GetCurSel()) {
           pListBox->SetCurSel( 0 ); // select the first one
       }
   }

   // the remove button
   if (GetFocus() == pRemove &&
      pListBox->GetCurSel() < 0)
   {
      pIpAddr->SetFocus();
      SetDefID(IDOK);
   }
   pRemove->EnableWindow((pListBox->GetCurSel() >= 0) && enableAllowed);

   // up and down buttons
   BOOL bEnableUp = (pListBox->GetCurSel() >= 0) && (pListBox->GetCurSel() != 0);
   pUp->EnableWindow(bEnableUp && enableAllowed);

   BOOL bEnableDown = (pListBox->GetCurSel() >= 0) && (pListBox->GetCurSel() < pListBox->GetCount() - 1);
   pDown->EnableWindow(bEnableDown && enableAllowed);

} // COptionsCfgPropPage::HandleActivationIpArray()

void COptionsCfgPropPage::HandleActivationValueArray()
{
   CButton * pAdd = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_VALUE_ADD));
   CButton * pRemove = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_VALUE_DELETE));
   CButton * pUp = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_VALUE_UP));
   CButton * pDown = reinterpret_cast<CButton *>(GetDlgItem(IDC_BUTTON_VALUE_DOWN));
   CButton * pRadioDecimal = reinterpret_cast<CButton *>(GetDlgItem(IDC_RADIO_DECIMAL));
   CEdit * pValue = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_VALUE));
   CListBox * pListBox = reinterpret_cast<CListBox *>(GetDlgItem(IDC_LIST_VALUES));
   
   bool enableAllowed = (pListBox->IsWindowEnabled() == TRUE)?true:false;

   CString strValue;
      
   pValue->GetWindowText( strValue );
   pAdd->EnableWindow( !strValue.IsEmpty() && enableAllowed);

   if ( pListBox->GetCount() == 0 ) 
   {
      pRemove->EnableWindow( FALSE );
      pUp->EnableWindow( FALSE );
      pDown->EnableWindow( FALSE );
      return;
   }

   int nSel = pListBox->GetCurSel();
   if ( LB_ERR != nSel ) 
   {
      pRemove->EnableWindow( enableAllowed );
      pUp->EnableWindow( (nSel > 0) && enableAllowed );
      pDown->EnableWindow( (pListBox->GetCount() > ( nSel + 1 ))
                           && enableAllowed);
   }
} // COptionsCfgPropPage::HandleActivationValueArray()

void COptionsCfgPropPage::HandleActivationRouteArray(
    CDhcpOptionValue *optValue
    )
{
   // this route will enable the right dialog items and also set
   // focus correctly.

   // get the routes list control
   CListCtrl *pList = reinterpret_cast<CListCtrl *>(
      GetDlgItem( IDC_LIST_OF_ROUTES ) );

   bool enableAllowed = (pList->IsWindowEnabled() == TRUE)?true:false;

   // get the add and remove buttons
   CButton *pAdd = reinterpret_cast<CButton *>(
      GetDlgItem(IDC_BUTTON_ROUTE_ADD) );
   CButton *pRemove = reinterpret_cast<CButton *>(
         GetDlgItem(IDC_BUTTON_ROUTE_DEL) );
   
   if( optValue )
   {
      // also, format the whole list of ip addresses into
      // binary type..  allocate large enough buffer

      int nItems = pList->GetItemCount();
      LPBYTE Buffer = new BYTE [sizeof(DWORD)*4 * nItems];
      if( NULL != Buffer )
      {
         int BufSize = 0;
         for( int i = 0 ; i < nItems ; i ++ )
         {
               DHCP_IP_ADDRESS Dest, Mask, Router;
               Dest = UtilCvtWstrToIpAddr(pList->GetItemText(i, 0));
               Mask = UtilCvtWstrToIpAddr(pList->GetItemText(i, 1));
               Router = UtilCvtWstrToIpAddr(pList->GetItemText(i, 2));

               Dest = htonl(Dest);
               Router = htonl(Router);

               int nBitsInMask = 0;
               while( Mask != 0 ) {
                  nBitsInMask ++; Mask = (Mask << 1);
               }

               // first add destination descriptor
               // first byte contains # of bits in mask
               // next few bytes contain the dest address for only
               // the significant octets
               Buffer[BufSize++] = (BYTE)nBitsInMask;
               memcpy(&Buffer[BufSize], &Dest, (nBitsInMask+7)/8);
               BufSize += (nBitsInMask+7)/8;

               // now just copy the router address
               memcpy(&Buffer[BufSize], &Router, sizeof(Router));
               BufSize += sizeof(Router);
         } // for

         // now write back the option value
         DHCP_OPTION_DATA_ELEMENT DataElement = {DhcpBinaryDataOption };
         DHCP_OPTION_DATA Data = { 1, &DataElement };
         DataElement.Element.BinaryDataOption.DataLength = BufSize;
         DataElement.Element.BinaryDataOption.Data = Buffer;
         
         optValue->SetData( &Data );
         delete[] Buffer;
      } // if
   } // if 
   
   // enable the remove button only if there are any
   // elements at all
   pRemove->EnableWindow( (pList->GetItemCount() > 0) && enableAllowed );

   // Set the focus on Add
   pAdd->SetFocus();

} // COptionsCfgPropPage::HandleActivationRouteArray()

BOOL COptionsCfgPropPage::OnApply() 
{
    BOOL bErrors = FALSE;
    DWORD err = 0;
    LPCTSTR pClassName;
    COptionsConfig * pOptConfig = reinterpret_cast<COptionsConfig *>(GetHolder());
    
    LPWSTR pszServerAddr = pOptConfig->GetServerAddress();
    
    if (IsDirty()) {
        BEGIN_WAIT_CURSOR;
   
        // loop through all vendors first
        POSITION posv = ((COptionsConfig *)
          GetHolder())->m_listVendorClasses.GetHeadPosition();
        while (posv) {
            CVendorTracker * pVendorTracker =
      ((COptionsConfig *) GetHolder())->m_listVendorClasses.GetNext(posv);
       
            // loop through all classes and see if we have any options we need to update
            POSITION pos = pVendorTracker->m_listUserClasses.GetHeadPosition();
            while (pos) {
      CClassTracker * pClassTracker =
          pVendorTracker->m_listUserClasses.GetNext(pos);
      
                pClassName = pClassTracker->m_strClassName.IsEmpty() 
          ? NULL
          : (LPCTSTR) pClassTracker->m_strClassName;
      
                POSITION posOption = pClassTracker->m_listOptions.GetHeadPosition();
                while (posOption) {
                    COptionTracker * pCurOptTracker = 
         pClassTracker->m_listOptions.GetNext(posOption);
          
                    if (pCurOptTracker->IsDirty()) {
         // we need to update this option
         CDhcpOption * pCurOption = pCurOptTracker->m_pOption;
         CDhcpOptionValue & optValue = pCurOption->QueryValue();

         // check to see if the option has changed
                        if ((pCurOptTracker->GetInitialState() == OPTION_STATE_INACTIVE) &&
             (pCurOptTracker->GetCurrentState() == OPTION_STATE_INACTIVE)) {
             // the state hasn't changed, the user must have changed the
             // state and then restored it to its original value
             err = ERROR_SUCCESS;
         }
         else if ((pCurOptTracker->GetInitialState() == OPTION_STATE_ACTIVE) &&
             (pCurOptTracker->GetCurrentState() == OPTION_STATE_INACTIVE)) {
                            // if it is a vendor specific or class ID option, call the V5 api
                            if ( pOptConfig->m_liServerVersion.QuadPart >= DHCP_NT5_VERSION) {
            err = ::DhcpRemoveOptionValueV5(pszServerAddr,
                                                                pCurOption->IsVendor() ? DHCP_FLAGS_OPTION_IS_VENDOR : 0,
                        pCurOption->QueryId(),
                                                                (LPTSTR) pClassName,
                                                                (LPTSTR) pCurOption->GetVendor(),
                        &pOptConfig->m_pOptionValueEnum->m_dhcpOptionScopeInfo ) ;
                            }
                            else {
                                // need to remove this option for either global, scope or res client
            err = ::DhcpRemoveOptionValue(pszServerAddr,
                           pCurOption->QueryId(),
                           &pOptConfig->m_pOptionValueEnum->m_dhcpOptionScopeInfo ) ;
                            }
         } // elseif 
         else {
                            // check option 33
                            if ((pCurOption->QueryId() == 33 || pCurOption->QueryId() == 21) &&
                                ( !pCurOption->IsVendor()) &&
                                (pCurOption->QueryValue().QueryUpperBound()) % 2 != 0) {
                                // special case for option 33 & 21.  Make sure it is a set of IP addres pairs
                                // and make sure we pick the right page to select
                                int nId = pClassName ? 1 : 0;
                                PropSheet_SetCurSel(GetHolder()->GetSheetWindow(), GetSafeHwnd(), nId);
                                SelectOption(pCurOption);

                                ::DhcpMessageBox(IDS_ERR_OPTION_ADDR_PAIRS);
                                m_listctrlOptions.SetFocus();
                                return 0;
                            } // if 

             // we are just updating this option
             DHCP_OPTION_DATA * pOptData;
             err = optValue.CreateOptionDataStruct(&pOptData);
             if (err) {
            ::DhcpMessageBox(err);
                                RESTORE_WAIT_CURSOR;

            bErrors = TRUE;
            continue;
             }

                            // if it is a vendor specific or class ID option, call the V5 api
                            if ( ((COptionsConfig *)GetHolder())->m_liServerVersion.QuadPart >= DHCP_NT5_VERSION ) {
            err = ::DhcpSetOptionValueV5(pszServerAddr,
                                                             pCurOption->IsVendor() ? DHCP_FLAGS_OPTION_IS_VENDOR : 0,
                                                             pCurOption->QueryId(),
                                                             (LPTSTR) pClassName,
                                                             (LPTSTR) pCurOption->GetVendor(),
                          &pOptConfig->m_pOptionValueEnum->m_dhcpOptionScopeInfo,
                          pOptData);
                            }
                            else {
            err = ::DhcpSetOptionValue(pszServerAddr,
                        pCurOption->QueryId(),
                        &pOptConfig->m_pOptionValueEnum->m_dhcpOptionScopeInfo,
                        pOptData);
                            }
         } // else

         if (err) {
             ::DhcpMessageBox(err);
                            RESTORE_WAIT_CURSOR;
             
             bErrors = TRUE;
         }
         else {
             // all done with this option.  Mark as clean and update
                            // the new initial state to the current state.
                            pCurOptTracker->SetDirty(FALSE);
             pCurOptTracker->SetInitialState(pCurOptTracker->GetCurrentState());
             
         }
                    } // endif option->IsDirty()
                } // while user class options
            } // while User class loop
        } // while Vendor loop
   
        END_WAIT_CURSOR;
    }// endif IsDirty()

    if (bErrors) {
        return 0;
    }
    else {
        BOOL bRet = CPropertyPageBase::OnApply();
   
   if (bRet == FALSE) {
       // Something bad happened... grab the error code
       AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
       ::DhcpMessageBox(GetHolder()->GetError());
   }
   
        return bRet;
    } // else
} // COptionsCfgPropPage::OnApply()

// need to refresh the UI on the main app thread...
BOOL COptionsCfgPropPage::OnPropertyChange(BOOL bScope, LONG_PTR *ChangeMask)
{
    SPITFSNode spNode;
    spNode = GetHolder()->GetNode();
    
    CMTDhcpHandler * pMTHandler = GETHANDLER(CMTDhcpHandler, spNode);
    
    pMTHandler->OnRefresh(spNode, NULL, 0, 0, 0);
    
    return FALSE;
}

//
//  See if any of the edit fields have been changed and perform the alteration.
//  Return TRUE if the value was changed.
//
BOOL COptionsCfgPropPage::HandleValueEdit()
{
   LONG err = 0;
   int nSelectedIndex = m_listctrlOptions.GetSelectedItem();
   
   if (nSelectedIndex > -1)
   {
      COptionTracker * pOptTracker = 
         reinterpret_cast<COptionTracker *>(m_listctrlOptions.GetItemData(nSelectedIndex));
      CEdit * pDwordEdit = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_DWORD));
      CWndIpAddress * pIpAddr = reinterpret_cast<CWndIpAddress *>(GetDlgItem(IDC_IPADDR_ADDRESS));
      CEdit * pString = reinterpret_cast<CEdit *>(GetDlgItem(IDC_EDIT_STRING_VALUE));

      CDhcpOptionValue & dhcValue = pOptTracker->m_pOption->QueryValue();
      DHCP_OPTION_DATA_TYPE dhcType = dhcValue.QueryDataType();
      DHCP_IP_ADDRESS dhipa ;
      CString strEdit;
      BOOL bModified = FALSE;

      switch ( dhcType )
      {
      case DhcpByteOption:
      case DhcpWordOption:
      case DhcpDWordOption:
      case DhcpBinaryDataOption:
         {
            DWORD dwResult;
            DWORD dwMask = 0xFFFFFFFF;
            if (dhcType == DhcpByteOption)
            {
               dwMask = 0xFF;
            }
            else if (dhcType == DhcpWordOption)
            {
               dwMask = 0xFFFF;
            }
            
            if (!FGetCtrlDWordValue(pDwordEdit->GetSafeHwnd(), &dwResult, 0, dwMask))
            {
               return FALSE;
            }
            
            // only mark this dirty if the value has changed as we may just
            // be updating the UI
            if (dwResult != (DWORD) dhcValue.QueryNumber(0))
            {
               bModified = TRUE ;
               (void)dhcValue.SetNumber(dwResult, 0); 
               ASSERT(err == FALSE);
            }
            break;
         }

      case DhcpDWordDWordOption: 
         {
            DWORD_DWORD     dwdw;
            CString         strValue;
         
            pDwordEdit->GetWindowText(strValue);
      
            UtilConvertStringToDwordDword(strValue, &dwdw);
                  
            // only mark this dirty if the value has changed as we may just
            // be updating the UI
            if (( dwdw.DWord1 != dhcValue.QueryDwordDword(0).DWord1 ) ||
                ( dwdw.DWord2 != dhcValue.QueryDwordDword(0).DWord2 )) 
            {
               bModified = TRUE;
               dhcValue.SetDwordDword(dwdw, 0);
            }
            break;
         }

      case DhcpStringDataOption:
         {
            pString->GetWindowText( strEdit );

            // only mark this dirty if the value has changed as we may just
            // be updating the UI
            if (strEdit.Compare(dhcValue.QueryString(0)) != 0)
            {
               bModified = TRUE;
               err = dhcValue.SetString( strEdit, 0 );
            }

            break ;
         }

      case DhcpIpAddressOption:
         {
            if (!pIpAddr->GetModify()) 
            {
               break ;
            }
            
            if ( !pIpAddr->IsBlank() )
            {
               if ( !pIpAddr->GetAddress(&dhipa) )
               {
                  err = ERROR_INVALID_PARAMETER;
                  break; 
               }

               // only mark this dirty if the value has changed as we may just
               // be updating the UI
               if (dhipa != dhcValue.QueryIpAddr(0))
               {
               bModified = TRUE ;
               err = dhcValue.SetIpAddr( dhipa, 0 ); 
               }
            }
            break;
         }

      default:
         {
            Trace0("invalid value type in HandleValueEdit");
            Assert( FALSE );
            err = ERROR_INVALID_PARAMETER;
            break;
         }
      }

      if (err)
      {
         ::DhcpMessageBox(err);
      }
      else if (bModified)
      {
         pOptTracker->SetDirty(TRUE);
         SetDirty(TRUE);
      }
   }

    return err == 0 ;
}


/////////////////////////////////////////////////////////////////////////////
//
// COptionCfgGeneral page
//
/////////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(COptionCfgGeneral, COptionsCfgPropPage)
   //{{AFX_MSG_MAP(COptionCfgGeneral)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

IMPLEMENT_DYNCREATE(COptionCfgGeneral, COptionsCfgPropPage)

COptionCfgGeneral::COptionCfgGeneral() 
    : COptionsCfgPropPage(IDP_OPTION_BASIC) 
{
   //{{AFX_DATA_INIT(COptionCfgGeneral)
   //}}AFX_DATA_INIT
}

COptionCfgGeneral::COptionCfgGeneral(UINT nIDTemplate, UINT nIDCaption) 
    : COptionsCfgPropPage(nIDTemplate, nIDCaption) 
{
}

COptionCfgGeneral::~COptionCfgGeneral()
{
}

void COptionCfgGeneral::DoDataExchange(CDataExchange* pDX)
{
   COptionsCfgPropPage::DoDataExchange(pDX);
   //{{AFX_DATA_MAP(COptionCfgGeneral)
   //}}AFX_DATA_MAP
}

BOOL COptionCfgGeneral::OnInitDialog() 
{
   COptionsCfgPropPage::OnInitDialog();
   
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

    // check to see if we should focus on a particular option
    COptionsConfig * pOptionsConfig = (COptionsConfig *) GetHolder();
   if (pOptionsConfig->m_dhcpStartId != 0xffffffff)
    {
        // check to see if this option is on the advanced page
        if (!pOptionsConfig->m_strStartVendor.IsEmpty() ||
            !pOptionsConfig->m_strStartClass.IsEmpty()) 
        {
            // this option is on the advanced page
            ::PostMessage(pOptionsConfig->GetSheetWindow(), PSM_SETCURSEL, (WPARAM)1, NULL);
            return TRUE;
        }

        // find the option to select
        OnSelectOption(0,0);
    }

    SetDirty(FALSE);

    return TRUE;  // return TRUE unless you set the focus to a control
                 // EXCEPTION: OCX Property Pages should return FALSE
}


/////////////////////////////////////////////////////////////////////////////
//
// COptionCfgAdvanced page
//
/////////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(COptionCfgAdvanced, COptionsCfgPropPage)
   //{{AFX_MSG_MAP(COptionCfgAdvanced)
   ON_CBN_SELENDOK(IDC_COMBO_USER_CLASS, OnSelendokComboUserClass)
   ON_CBN_SELENDOK(IDC_COMBO_VENDOR_CLASS, OnSelendokComboVendorClass)
   //}}AFX_MSG_MAP

    ON_MESSAGE(WM_SELECTCLASSES, OnSelectClasses)

END_MESSAGE_MAP()

IMPLEMENT_DYNCREATE(COptionCfgAdvanced, COptionsCfgPropPage)

COptionCfgAdvanced::COptionCfgAdvanced() 
    : COptionsCfgPropPage(IDP_OPTION_ADVANCED) 
{
   //{{AFX_DATA_INIT(COptionCfgAdvanced)
   //}}AFX_DATA_INIT

    m_helpMap.BuildMap(DhcpGetHelpMap(IDP_OPTION_ADVANCED));
}

COptionCfgAdvanced::COptionCfgAdvanced(UINT nIDTemplate, UINT nIDCaption) 
    : COptionsCfgPropPage(nIDTemplate, nIDCaption) 
{
    m_helpMap.BuildMap(DhcpGetHelpMap(IDP_OPTION_ADVANCED));
}

COptionCfgAdvanced::~COptionCfgAdvanced()
{
}

void COptionCfgAdvanced::DoDataExchange(CDataExchange* pDX)
{
   COptionsCfgPropPage::DoDataExchange(pDX);
   //{{AFX_DATA_MAP(COptionCfgAdvanced)
   DDX_Control(pDX, IDC_COMBO_USER_CLASS, m_comboUserClasses);
   DDX_Control(pDX, IDC_COMBO_VENDOR_CLASS, m_comboVendorClasses);
   //}}AFX_DATA_MAP
}

BOOL COptionCfgAdvanced::OnInitDialog() 
{
   CPropertyPageBase::OnInitDialog();
   
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   // initialize the list control
   InitListCtrl();

   // initialize the option data
    // this gets done in the general page init, only needs 
    // to be done once
    /*
   DWORD dwErr = ((COptionsConfig *) GetHolder())->InitData();
   if (dwErr != ERROR_SUCCESS)
   {
      // CODEWORK:  need to exit gracefull if this happens     
      ::DhcpMessageBox(dwErr);
   }
    */
    
    // add the standard vendor class name
    int nSel;
    CString strVendor, strClass;
    
    strVendor.LoadString(IDS_INFO_NAME_DHCP_DEFAULT);
    nSel = m_comboVendorClasses.AddString(strVendor);
    m_comboVendorClasses.SetCurSel(nSel);

    // add the default user class name
    strClass.LoadString(IDS_USER_STANDARD);
    nSel = m_comboUserClasses.AddString(strClass);
    m_comboUserClasses.SetCurSel(nSel);

    // now add all the other classes
    SPITFSNode spNode;
    spNode = ((COptionsConfig *) GetHolder())->GetServerNode();

    CDhcpServer * pServer = GETHANDLER(CDhcpServer, spNode);
    CClassInfoArray ClassInfoArray;

    // add all the classes to the appropriate classes to the dropdown
    pServer->GetClassInfoArray(ClassInfoArray);
    for (int i = 0; i < ClassInfoArray.GetSize(); i++)
    {
        if (!ClassInfoArray[i].bIsVendor)
            m_comboUserClasses.AddString(ClassInfoArray[i].strName);
        else
            m_comboVendorClasses.AddString(ClassInfoArray[i].strName);
    }

    // now fill the options listbox with whatever class is selected
    ((COptionsConfig *) GetHolder())->FillOptions(strVendor, strClass, m_listctrlOptions);
    m_bNoClasses = FALSE;

    // Create the type control switcher
    m_cgsTypes.Create(this,IDC_DATA_ENTRY_ANCHOR,cgsPreCreateAll);
    
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_NONE, IDD_DATA_ENTRY_NONE, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_DWORD, IDD_DATA_ENTRY_DWORD, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_IPADDRESS, IDD_DATA_ENTRY_IPADDRESS, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_IPADDRESS_ARRAY, IDD_DATA_ENTRY_IPADDRESS_ARRAY,   NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_STRING, IDD_DATA_ENTRY_STRING, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_BINARY_ARRAY, IDD_DATA_ENTRY_BINARY_ARRAY, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_BINARY, IDD_DATA_ENTRY_BINARY, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_ROUTE_ARRAY, IDD_DATA_ENTRY_ROUTE_ARRAY, NULL);
    m_cgsTypes.AddGroup(IDC_DATA_ENTRY_STRING_ARRAY, IDD_DATA_ENTRY_STRING_ARRAY, NULL);
    
    SwitchDataEntry(-1, -1, 0, TRUE);
    
    m_bInitialized = TRUE;

    // check to see if we should focus on a particular option
    COptionsConfig * pOptionsConfig = (COptionsConfig *) GetHolder();
   if (pOptionsConfig->m_dhcpStartId != 0xffffffff)
    {
        // yes, first select the appropriate vendor/ user class
        Assert(!pOptionsConfig->m_strStartVendor.IsEmpty() ||
               !pOptionsConfig->m_strStartClass.IsEmpty());

        if (!pOptionsConfig->m_strStartVendor.IsEmpty())
            m_comboVendorClasses.SelectString(-1, pOptionsConfig->m_strStartVendor);

        if (!pOptionsConfig->m_strStartClass.IsEmpty())
            m_comboUserClasses.SelectString(-1, pOptionsConfig->m_strStartClass);

        // update the list of options
        OnSelendokComboVendorClass();

        // now find the option
        OnSelectOption(0,0);
    }

    SetDirty(FALSE); 

    return TRUE;  // return TRUE unless you set the focus to a control
                 // EXCEPTION: OCX Property Pages should return FALSE
}

void COptionCfgAdvanced::OnSelendokComboUserClass() 
{
    OnSelendokComboVendorClass();
}

void COptionCfgAdvanced::OnSelendokComboVendorClass() 
{
    // If we have classes defined then its time to switch up the list ctrl
    if (m_bNoClasses == FALSE)
    {
        CString strSelectedVendor, strSelectedClass;
        int nSelVendorIndex = m_comboVendorClasses.GetCurSel();
        int nSelClassIndex = m_comboUserClasses.GetCurSel();

        m_comboVendorClasses.GetLBText(nSelVendorIndex, strSelectedVendor);
        m_comboUserClasses.GetLBText(nSelClassIndex, strSelectedClass);

        // mark the page as not initiailzed while we redo the options
        m_bInitialized = FALSE;

        m_listctrlOptions.DeleteAllItems();
        ((COptionsConfig *) GetHolder())->FillOptions(strSelectedVendor, strSelectedClass, m_listctrlOptions);

        m_bInitialized = TRUE;

        SwitchDataEntry( -1, -1, 0, TRUE );
    }
}

long COptionCfgAdvanced::OnSelectClasses(UINT wParam, LONG lParam)
{
    CString * pstrVendor = (CString *) ULongToPtr(wParam);
    CString * pstrClass = (CString *) ULongToPtr(lParam);

    if (pstrVendor->IsEmpty())
        pstrVendor->LoadString(IDS_INFO_NAME_DHCP_DEFAULT);

    if (pstrClass->IsEmpty())
       pstrClass->LoadString(IDS_USER_STANDARD);

    m_comboVendorClasses.SelectString(-1, *pstrVendor);
    m_comboUserClasses.SelectString(-1, *pstrClass);

    // update the list of options
    OnSelendokComboVendorClass();

    return 0;
}