archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/printscan/faxsrv/admin/mmc/dlgnewdevice.cpp

826 lines
21 KiB
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
// FILE : DlgNewDevice.cpp //
// //
// DESCRIPTION : The CDlgNewFaxOutboundDevice class implements the //
// dialog for additon of new Group. //
// //
// AUTHOR : yossg //
// //
// HISTORY : //
// Jan 3 2000 yossg Create //
// //
// Copyright (C) 2000 Microsoft Corporation All Rights Reserved //
/////////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "dlgNewDevice.h"
#include "FaxServer.h"
#include "FaxServerNode.h"
#include "dlgutils.h"
/////////////////////////////////////////////////////////////////////////////
// CDlgNewFaxOutboundDevice
CDlgNewFaxOutboundDevice::CDlgNewFaxOutboundDevice(CFaxServer * pFaxServer)
{
m_lpdwAllDeviceID = NULL;
m_dwNumOfAllDevices = 0;
m_lpdwAssignedDeviceID = NULL;
m_dwNumOfAssignedDevices = 0;
ATLASSERT(pFaxServer);
m_pFaxServer = pFaxServer;
}
CDlgNewFaxOutboundDevice::~CDlgNewFaxOutboundDevice()
{
if (NULL != m_lpdwAllDeviceID)
delete[] m_lpdwAllDeviceID;
if (NULL != m_lpdwAssignedDeviceID)
delete[] m_lpdwAssignedDeviceID;
}
/*
- CDlgNewFaxOutboundDevice::initDevices
-
* Purpose:
* Initiates the configuration structure from RPC get Call,
* and current assined devices own parameters
*
* Arguments:
*
* Return:
* OLE error code
*/
HRESULT CDlgNewFaxOutboundDevice::InitDevices(DWORD dwNumOfDevices, LPDWORD lpdwDeviceID, BSTR bstrGroupName)
{
DEBUG_FUNCTION_NAME( _T("CDlgNewFaxOutboundDevice::InitDevices"));
HRESULT hRc = S_OK;
m_bstrGroupName = bstrGroupName;
if (!m_bstrGroupName )
{
DebugPrintEx(DEBUG_ERR,
_T("Out of memory - Failed to Init m_bstrGroupName. (ec: %0X8)"), hRc);
//MsgBox by Caller Function
hRc = E_OUTOFMEMORY;
goto Exit;
}
hRc = InitAssignedDevices(dwNumOfDevices, lpdwDeviceID);
if (FAILED(hRc))
{
DebugPrintEx(DEBUG_ERR,
_T("Failed to InitAssignDevices. (ec: %0X8)"), hRc);
//MsgBox by Caller Function
goto Exit;
}
hRc = InitAllDevices( );
if (FAILED(hRc))
{
DebugPrintEx(DEBUG_ERR,
_T("Failed to InitRPC. (ec: %0X8)"), hRc);
//MsgBox by Caller Function
goto Exit;
}
if ( m_dwNumOfAllDevices < m_dwNumOfAssignedDevices)
{
DebugPrintEx(DEBUG_MSG,
_T("+++m_dwNumOfAllDevices <m_dwNumOfAssignedDevices.+++ (ec: %0X8)"), hRc);
hRc = E_UNEXPECTED;
//MsgBox by Caller Function
goto Exit;
}
ATLASSERT(S_OK == hRc);
Exit:
return hRc;
}
/*
- CDlgNewFaxOutboundDevice::initAllDevices
-
* Purpose:
* Initiates the configuration structure from RPC get Call.
*
* Arguments:
*
* Return:
* OLE error code
*/
HRESULT CDlgNewFaxOutboundDevice::InitAllDevices( )
{
DEBUG_FUNCTION_NAME( _T("CDlgNewFaxOutboundDevice::InitAllDevices"));
HRESULT hRc = S_OK;
DWORD ec = ERROR_SUCCESS;
PFAX_OUTBOUND_ROUTING_GROUP pFaxGroupsConfig;
DWORD dwNumOfGroups;
DWORD i; //index
BOOL fFound = FALSE;
//
// get Fax Handle
//
if (!m_pFaxServer->GetFaxServerHandle())
{
ec= GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Failed to GetFaxServerHandle. (ec: %ld)"),
ec);
goto Error;
}
//
// Retrieve the Outbound Groups configuration
//
if (!FaxEnumOutboundGroups(m_pFaxServer->GetFaxServerHandle(),
&pFaxGroupsConfig,
&dwNumOfGroups))
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Fail to get groups configuration. (ec: %ld)"),
ec);
if (IsNetworkError(ec))
{
DebugPrintEx(
DEBUG_ERR,
_T("Network Error was found. (ec: %ld)"),
ec);
m_pFaxServer->Disconnect();
}
goto Error;
}
//For max verification
ATLASSERT(pFaxGroupsConfig);
for ( i =0; i < dwNumOfGroups; i++ )
{
ATLASSERT(NULL != pFaxGroupsConfig);
if(0 == wcscmp(ROUTING_GROUP_ALL_DEVICES, pFaxGroupsConfig->lpctstrGroupName) )
{
fFound = TRUE;
}
else
{
pFaxGroupsConfig++;
}
}
if(fFound)
{
//
// init m_dwNumOfAllDevices
//
m_dwNumOfAllDevices = pFaxGroupsConfig->dwNumDevices;
//
// init m_lpdwAllDeviceID
//
if (0 < m_dwNumOfAllDevices)
{
m_lpdwAllDeviceID = new DWORD[m_dwNumOfAllDevices];
if (NULL == m_lpdwAllDeviceID)
{
DebugPrintEx(
DEBUG_ERR,
_T("Error allocating %ld device ids"),
m_dwNumOfAllDevices);
ec = ERROR_NOT_ENOUGH_MEMORY;
goto Error;
}
memcpy(m_lpdwAllDeviceID, pFaxGroupsConfig->lpdwDevices, sizeof(DWORD)*m_dwNumOfAllDevices) ;
}
else
{
DebugPrintEx( DEBUG_MSG, _T("++Empty List++ List of All Devices found to be currrently empty."));
m_lpdwAllDeviceID = NULL;
}
}
else
{
DebugPrintEx(
DEBUG_ERR,
_T("UNEXPECTED ERROR - ALL DEVICES group was not found."));
ec = ERROR_BAD_UNIT;
goto Error;
}
ATLASSERT(S_OK == hRc);
DebugPrintEx( DEBUG_MSG,
_T("Succeed to init all devices list."));
goto Exit;
Error:
ATLASSERT(ERROR_SUCCESS != ec);
hRc = HRESULT_FROM_WIN32(ec);
//DlgMsgBox -- NodeMsgBox(GetFaxServerErrorMsg(ec));
Exit:
return (hRc);
}
/*
- CDlgNewFaxOutboundDevice::initAssignedDevices
-
* Purpose:
* Initiates the list from given params.
*
* Arguments:
*
* Return:
* OLE error code
*/
HRESULT CDlgNewFaxOutboundDevice::InitAssignedDevices(DWORD dwNumOfDevices, LPDWORD lpdwDeviceID)
{
DEBUG_FUNCTION_NAME( _T("CDlgNewFaxOutboundDevice::InitAssignedDevices"));
HRESULT hRc = S_OK;
//
// init m_dwNumOfAssignedDevices
//
m_dwNumOfAssignedDevices = dwNumOfDevices;
//
// init m_lpdwAssignedDeviceID
//
if (0 < m_dwNumOfAssignedDevices)
{
m_lpdwAssignedDeviceID = new DWORD[m_dwNumOfAssignedDevices];
if (NULL == m_lpdwAssignedDeviceID)
{
DebugPrintEx(
DEBUG_ERR,
_T("Error allocating %ld device ids"),
m_dwNumOfAssignedDevices);
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
}
memcpy(m_lpdwAssignedDeviceID, lpdwDeviceID, sizeof(DWORD)*m_dwNumOfAssignedDevices) ;
}
else
{
DebugPrintEx( DEBUG_MSG, _T("List of Assigned devices found to be empty."));
m_lpdwAssignedDeviceID = NULL;
}
return hRc;
}
/*
+ CDlgNewFaxOutboundDevice::OnInitDialog
+
* Purpose:
* Initiate all dialog controls.
*
* Arguments:
* [in] uMsg : Value identifying the event.
* [in] lParam : Message-specific value.
* [in] wParam : Message-specific value.
* [in] bHandled : bool value.
*
- Return:
- 0 or 1
*/
LRESULT
CDlgNewFaxOutboundDevice::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
DEBUG_FUNCTION_NAME( _T("CDlgNewFaxOutboundDevice::OnInitDialog"));
HRESULT hRc = S_OK;
BOOL fAssignedDeviceFound;
BOOL fAllAssignedDevicesFound;
LPDWORD lpdwDevice;
LPDWORD lpdwAssignedDevice;
DWORD tmp;
UINT uiFoundIndex;
RECT Rect;
//
// Attach controls
//
m_DeviceList.Attach(GetDlgItem(IDC_DEVICE_LISTVIEW));
m_DeviceList.GetClientRect(&Rect);
m_DeviceList.InsertColumn(1, NULL, LVCFMT_LEFT, (Rect.right-Rect.left), 0);
//
// Fill the Availble Device List
//
fAllAssignedDevicesFound = FALSE;
uiFoundIndex = 0;
lpdwDevice = &m_lpdwAllDeviceID[0];
for ( DWORD i = 0; i < m_dwNumOfAllDevices; i++ )
{
if(!fAllAssignedDevicesFound)
{
fAssignedDeviceFound =FALSE;
lpdwAssignedDevice = &m_lpdwAssignedDeviceID[0];
tmp =0;
for ( DWORD j = 0; j < m_dwNumOfAssignedDevices; j++ )
{
// TO DO create more incremental search here also
ATLASSERT(NULL != lpdwDevice);
ATLASSERT(NULL != lpdwAssignedDevice);
if( *lpdwDevice == *lpdwAssignedDevice )
{
fAssignedDeviceFound = TRUE;
//Skip this device - It was already assigned
lpdwDevice++;
if ( ++tmp == m_dwNumOfAssignedDevices )
fAllAssignedDevicesFound = TRUE;
break;
}
else
{
lpdwAssignedDevice++;
}
}
if (!fAssignedDeviceFound)
{
InsertDeviceToList(uiFoundIndex++ , *lpdwDevice);
lpdwDevice++;
}
}
else //all assigned devices found
{
ATLASSERT(lpdwDevice);
//insert the rest of all devices to list
InsertDeviceToList(uiFoundIndex++ , *lpdwDevice);
lpdwDevice++;
}
}
EnableOK(FALSE);
return 1; // Let the system set the focus
}
/*
- CDlgNewFaxOutboundDevice::InsertDeviceToList
-
* Purpose:
* Populate Avaliable devices list and discovers the devices names
*
* Arguments:
* [in] uiIndex - index
* [in] dwDeviceID - device ID
*
* Return:
* OLE error code
*/
HRESULT CDlgNewFaxOutboundDevice::InsertDeviceToList(UINT uiIndex, DWORD dwDeviceID)
{
DEBUG_FUNCTION_NAME( _T("CDlgNewFaxOutboundDevice::InsertDeviceToList"));
HRESULT hRc = S_OK;
CComBSTR bstrDeviceName = NULL;
//
// Discover Device Name
//
hRc = InitDeviceNameFromID(dwDeviceID, &bstrDeviceName);
if (FAILED(hRc))
{
//DebugPrint by Called Func.
goto Exit;
}
//
// Insert New line in the list
//
m_DeviceList.InsertItem(uiIndex, bstrDeviceName);
m_DeviceList.SetItemData(uiIndex, dwDeviceID);
Exit:
return hRc;
}
/*
- CDlgNewFaxOutboundDevice::InitDeviceNameFromID
-
* Purpose:
* Transslate Device ID to Device Name and insert the data to
* m_bstrDeviceName
*
* Arguments:
* [in] dwDeviceID - device ID
* [out] bstrDeviceName - device Name
*
* Return:
* OLE error message
*/
HRESULT CDlgNewFaxOutboundDevice::InitDeviceNameFromID(DWORD dwDeviceID, BSTR * pbstrDeviceName)
{
DEBUG_FUNCTION_NAME( _T("CFaxOutboundRoutingRuleNode::GetDeviceNameFromID"));
DWORD ec = ERROR_SUCCESS;
HRESULT hRc = S_OK;
PFAX_PORT_INFO_EX pFaxDeviceConfig = NULL ;
if (!m_pFaxServer->GetFaxServerHandle())
{
ec= GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Failed to GetFaxServerHandle. (ec: %ld)"),
ec);
goto Error;
}
//
// Retrieve the Device configuration
//
if (!FaxGetPortEx(m_pFaxServer->GetFaxServerHandle(),
dwDeviceID,
&pFaxDeviceConfig))
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Fail to get device configuration. (ec: %ld)"),
ec);
if (IsNetworkError(ec))
{
DebugPrintEx(
DEBUG_ERR,
_T("Network Error was found. (ec: %ld)"),
ec);
m_pFaxServer->Disconnect();
}
goto Error;
}
//For max verification
ATLASSERT(pFaxDeviceConfig);
//
// Main thing - retrieve the Device Name
//
*pbstrDeviceName = SysAllocString(pFaxDeviceConfig->lpctstrDeviceName);
if ( !(*pbstrDeviceName) )
{
ec = ERROR_NOT_ENOUGH_MEMORY;
goto Error;
}
ATLASSERT(ec == ERROR_SUCCESS);
DebugPrintEx( DEBUG_MSG,
_T("Succeed to get device name."));
goto Exit;
Error:
ATLASSERT(ERROR_SUCCESS != ec);
pFaxDeviceConfig = NULL;
if (ERROR_BAD_UNIT != ec)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Device Not Found - Fail to discover device name from device ID."));
}
else
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Fail to discover device name from device ID. (ec: %ld)"),
ec);
}
hRc = HRESULT_FROM_WIN32(ec);
Exit:
if (NULL != pFaxDeviceConfig)
{
FaxFreeBuffer(pFaxDeviceConfig);
}
return hRc;
}
/*
+ CDlgNewFaxOutboundDevice::OnOK
+
* Purpose:
* Initiate all dialog controls.
*
* Arguments:
* [in] uMsg : Value identifying the event.
* [in] lParam : Message-specific value.
* [in] wParam : Message-specific value.
* [in] bHandled : bool value.
*
- Return:
- 0 or 1
*/
LRESULT
CDlgNewFaxOutboundDevice::OnOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
DEBUG_FUNCTION_NAME( _T("CDlgNewFaxOutboundDevice::OnOK"));
HRESULT hRc = S_OK;
DWORD ec = ERROR_SUCCESS;
DWORD dwIndex;
UINT uiSelectedCount;
int nItem;
LPDWORD lpdwNewDeviceID;
LPDWORD lpdwTmp;
FAX_OUTBOUND_ROUTING_GROUP FaxGroupConfig;
//
// Step 1: Create the new devices combined list
//
ATLASSERT( m_DeviceList.GetSelectedCount() > 0);
ATLASSERT( m_dwNumOfAssignedDevices >= 0);
uiSelectedCount = m_DeviceList.GetSelectedCount();
m_dwNumOfAllAssignedDevices = (DWORD)uiSelectedCount
+ m_dwNumOfAssignedDevices;
lpdwNewDeviceID = new DWORD[m_dwNumOfAllAssignedDevices];
if (NULL == lpdwNewDeviceID)
{
DebugPrintEx(
DEBUG_ERR,
_T("Error allocating %ld device ids"),
m_dwNumOfAllAssignedDevices);
ec = ERROR_NOT_ENOUGH_MEMORY;
goto Error;
}
lpdwTmp = &lpdwNewDeviceID[0];
DebugPrintEx( DEBUG_MSG,
_T(" NumOfAllAssignedDevices = %ld \n"), m_dwNumOfAllAssignedDevices);
//
// Already assigned part (can be zero size)
//
if (m_dwNumOfAssignedDevices > 0)
{
memcpy( lpdwNewDeviceID, m_lpdwAssignedDeviceID, sizeof(DWORD)*m_dwNumOfAssignedDevices) ;
lpdwTmp = lpdwTmp + (int)m_dwNumOfAssignedDevices;
}
//
// New devices to assign part (cannot be zero size)
//
if (uiSelectedCount > 0)
{
nItem = -1;
for (dwIndex = m_dwNumOfAssignedDevices; dwIndex < m_dwNumOfAllAssignedDevices; dwIndex++)
{
nItem = m_DeviceList.GetNextItem(nItem, LVNI_SELECTED);
ATLASSERT(nItem != -1);
*lpdwTmp = (DWORD)m_DeviceList.GetItemData(nItem);
DebugPrintEx( DEBUG_MSG,
_T(" NewDeviceID = %ld. DeviceOrder=%ld \n"), *lpdwTmp, (dwIndex+1));
++lpdwTmp;
}
}
else
{
ATLASSERT(0); //Never reach here
DlgMsgBox(this, IDS_SELECT_ITEM);
return 0;
}
//
// Step 2: insert the new Id list into the group via RPC call
//
//
// init the group fields and insert the new DeviceIdList
//
ZeroMemory (&FaxGroupConfig, sizeof(FAX_OUTBOUND_ROUTING_GROUP));
FaxGroupConfig.dwSizeOfStruct = sizeof(FAX_OUTBOUND_ROUTING_GROUP);
FaxGroupConfig.lpctstrGroupName = m_bstrGroupName;
FaxGroupConfig.dwNumDevices = m_dwNumOfAllAssignedDevices;
//FaxGroupConfig.Status - actually neglected by the service
FaxGroupConfig.Status = FAX_GROUP_STATUS_ALL_DEV_VALID;
FaxGroupConfig.lpdwDevices = lpdwNewDeviceID;
//
// get RPC Handle
//
if (!m_pFaxServer->GetFaxServerHandle())
{
ec= GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Failed to GetFaxServerHandle. (ec: %ld)"),
ec);
goto Error;
}
//
// inject the new device list
//
if (!FaxSetOutboundGroup(
m_pFaxServer->GetFaxServerHandle(),
&FaxGroupConfig))
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Fail to set the group with new device list. (ec: %ld)"),
ec);
if (IsNetworkError(ec))
{
DebugPrintEx(
DEBUG_ERR,
_T("Network Error was found. (ec: %ld)"),
ec);
m_pFaxServer->Disconnect();
}
goto Error;
}
//
// Step 3: Close the dialog
//
ATLASSERT(S_OK == hRc && ERROR_SUCCESS == ec);
DebugPrintEx( DEBUG_MSG,
_T("The group was added successfully."));
EndDialog(wID);
goto Exit;
Error:
ATLASSERT(ERROR_SUCCESS != ec);
hRc = HRESULT_FROM_WIN32(ec);
PageErrorEx(IDS_FAIL_ADD_DEVICE, GetFaxServerErrorMsg(ec), m_hWnd);
EnableOK(FALSE);
Exit:
return FAILED(hRc) ? 0 : 1;
}
/*
- CDlgNewFaxOutboundDevice::OnListViewItemChanged
-
* Purpose:
* Enable/Disable the submit button.
*
* Arguments:
*
* Return:
* 1
*/
LRESULT
CDlgNewFaxOutboundDevice::OnListViewItemChanged(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
DEBUG_FUNCTION_NAME( _T("CDlgNewFaxOutboundDevice::OnListViewItemChanged"));
EnableOK( m_DeviceList.GetSelectedCount() > 0 );
return 0;
}
/*
- CDlgNewFaxOutboundDevice::EnableOK
-
* Purpose:
* Enable (disable) apply button.
*
* Arguments:
* [in] fEnable - the value to enable the button
*
* Return:
* void
*/
VOID
CDlgNewFaxOutboundDevice::EnableOK(BOOL fEnable)
{
HWND hwndOK = GetDlgItem(IDOK);
::EnableWindow(hwndOK, fEnable);
}
/*
- CDlgNewFaxOutboundDevice::OnCancel
-
* Purpose:
* End dialog OnCancel.
*
* Arguments:
*
* Return:
* 0
*/
LRESULT
CDlgNewFaxOutboundDevice::OnCancel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
DEBUG_FUNCTION_NAME( _T("CDlgNewFaxOutboundDevice::OnCancel"));
EndDialog(wID);
return 0;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CDlgNewFaxOutboundDevice::OnHelpRequest
This is called in response to the WM_HELP Notify
message and to the WM_CONTEXTMENU Notify message.
WM_HELP Notify message.
This message is sent when the user presses F1 or <Shift>-F1
over an item or when the user clicks on the ? icon and then
presses the mouse over an item.
WM_CONTEXTMENU Notify message.
This message is sent when the user right clicks over an item
and then clicks "What's this?"
--*/
/////////////////////////////////////////////////////////////////////////////
LRESULT
CDlgNewFaxOutboundDevice::OnHelpRequest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
{
DEBUG_FUNCTION_NAME(_T("CDlgNewFaxOutboundDevice::OnHelpRequest"));
switch (uMsg)
{
case WM_HELP:
WinContextHelp(((LPHELPINFO)lParam)->dwContextId, m_hWnd);
break;
case WM_CONTEXTMENU:
WinContextHelp(::GetWindowContextHelpId((HWND)wParam), m_hWnd);
break;
}
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////