windows-nt/Source/XPSP1/NT/admin/snapin/filemgmt/fpnw.cpp

// fpnw.cpp : FPNW shares, sessions and open resources

#include "stdafx.h"
#include "cmponent.h"
#include "safetemp.h"
#include "FileSvc.h"
#include "DynamLnk.h"    // DynamicDLL
#include "fpnw.h"
#include "ShrProp.h"    // Share Properties Pages
#include "permpage.h"       // CSecurityInformation
#include "compdata.h"

#define DONT_WANT_SHELLDEBUG
#include "shlobjp.h"     // LPITEMIDLIST
#include "wraps.h"       // Wrap_ILCreateFromPath   

extern "C"
{
  #include <ntseapi.h>    // PSECURITY_DESCRIPTOR
}

// CODEWORK We should be more sophisticated about
//   determining whether FPNW is installed.
// This API should appear in fpnwapi:
//   BOOL IsNetWareInstalled( VOID );

#include "macros.h"
USE_HANDLE_MACROS("FILEMGMT(fpnw.cpp)")

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

class CFPNWSecurityInformation : public CShareSecurityInformation
{
    STDMETHOD(GetSecurity) (SECURITY_INFORMATION RequestedInformation,
                            PSECURITY_DESCRIPTOR *ppSecurityDescriptor,
                            BOOL fDefault );
    STDMETHOD(SetSecurity) (SECURITY_INFORMATION SecurityInformation,
                            PSECURITY_DESCRIPTOR pSecurityDescriptor );
public:
  FPNWVOLUMEINFO_2* m_pvolumeinfo;
  PSECURITY_DESCRIPTOR m_pDefaultDescriptor;
  CFPNWSecurityInformation();
  ~CFPNWSecurityInformation();
};

typedef enum _FpnwApiIndex
{
  FPNW_VOLUME_ENUM = 0,
  FPNW_CONNECTION_ENUM,
  FPNW_FILE_ENUM,
  FPNW_API_BUFFER_FREE,
  FPNW_VOLUME_DEL,
  FPNW_CONNECTION_DEL,
  FPNW_FILE_CLOSE,
  FPNW_VOLUME_GET_INFO,
  FPNW_VOLUME_SET_INFO
};

// not subject to localization
static LPCSTR g_apchFunctionNames[] = {
  "FpnwVolumeEnum",
  "FpnwConnectionEnum",
  "FpnwFileEnum",
  "FpnwApiBufferFree",
  "FpnwVolumeDel",
  "FpnwConnectionDel",
  "FpnwFileClose",
  "FpnwVolumeGetInfo",
  "FpnwVolumeSetInfo",
  NULL
};

// not subject to localization
DynamicDLL g_FpnwDLL( _T("FPNWCLNT.DLL"), g_apchFunctionNames );

typedef DWORD (*APIBUFFERFREEPROC) (LPVOID);

VOID FPNWFreeData(PVOID* ppv)
{
  if (*ppv != NULL)
  {
    ASSERT( NULL != g_FpnwDLL[FPNW_API_BUFFER_FREE] );
    (void) ((APIBUFFERFREEPROC)g_FpnwDLL[FPNW_API_BUFFER_FREE])( *ppv );
    *ppv = NULL;
  }
}

FpnwFileServiceProvider::FpnwFileServiceProvider( CFileMgmtComponentData* pFileMgmtData )
  : FileServiceProvider( pFileMgmtData )
{
    VERIFY( m_strTransportFPNW.LoadString( IDS_TRANSPORT_FPNW ) );
}


/*
DWORD
FpnwVolumeEnum(
    IN  LPWSTR pServerName OPTIONAL,
    IN  DWORD  dwLevel,
    OUT LPBYTE *ppVolumeInfo,
    OUT PDWORD pEntriesRead,
    IN OUT PDWORD resumeHandle OPTIONAL
);
*/

typedef DWORD (*VOLUMEENUMPROC) (LPWSTR,DWORD,LPBYTE*,PDWORD,PDWORD);

HRESULT FpnwFileServiceProvider::PopulateShares(
  IResultData* pResultData,
  CFileMgmtCookie* pcookie)
{
  TEST_NONNULL_PTR_PARAM(pcookie);

  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

    FPNWVOLUMEINFO* pvolumeinfo = NULL;
    DWORD dwEntriesRead = 0;
    DWORD hEnumHandle = 0;
    NET_API_STATUS retval = NERR_Success;
    do {
        retval = ((VOLUMEENUMPROC)g_FpnwDLL[FPNW_VOLUME_ENUM])(
            const_cast<LPTSTR>(pcookie->QueryTargetServer()),
      1,
      (PBYTE*)&pvolumeinfo,
      &dwEntriesRead,
      &hEnumHandle );
        if (NERR_Success == retval)
        {
            AddFPNWShareItems( pResultData, pcookie, pvolumeinfo, dwEntriesRead );
            pvolumeinfo = NULL;
            break;
        } else if (ERROR_MORE_DATA == retval) {
            ASSERT( NULL != hEnumHandle );
            AddFPNWShareItems( pResultData, pcookie, pvolumeinfo, dwEntriesRead );
            pvolumeinfo = NULL;
            continue;
        } else if (RPC_S_SERVER_UNAVAILABLE == retval && 0 == hEnumHandle) {
      // FPNW just isn't installed, don't worry about it
            retval = NERR_Success;  
            break;
        } else {
      (void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, retval, IDS_POPUP_FPNW_SHARES, pcookie->QueryNonNULLMachineName() );
            break;
        }
    } while (TRUE);

    return HRESULT_FROM_WIN32(retval);
}

/*
typedef struct _FPNWVolumeInfo
{
    LPWSTR    lpVolumeName;
    DWORD     dwType;
    DWORD     dwMaxUses;

    DWORD     dwCurrentUses;
    LPWSTR    lpPath;

} FPNWVOLUMEINFO, *PFPNWVOLUMEINFO;
*/

HRESULT FpnwFileServiceProvider::AddFPNWShareItems(
    IResultData* pResultData,
    CFileMgmtCookie* pParentCookie,
    PVOID pinfo,
    DWORD nItems)
{
  TEST_NONNULL_PTR_PARAM(pParentCookie);
  TEST_NONNULL_PTR_PARAM(pinfo);

  if (0 >= nItems)
    return S_OK;

    RESULTDATAITEM tRDItem;
  ::ZeroMemory( &tRDItem, sizeof(tRDItem) );
  tRDItem.nCol = COLNUM_SHARES_SHARED_FOLDER;
  // CODEWORK should use MMC_ICON_CALLBACK here
  tRDItem.nImage = iIconFPNWShare;
  tRDItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
  tRDItem.str = MMC_CALLBACK;

  FPNWVOLUMEINFO* pvolumeinfo = (FPNWVOLUMEINFO*)pinfo;

  DWORD nItemsToAdd = 0;
  for (DWORD i = 0; i < nItems; i++ )
  {
      if (!IsInvalidSharename(pvolumeinfo[i].lpVolumeName))
          nItemsToAdd++;
  }

  CFpnwShareCookie* pcookiearray = new CFpnwShareCookie[nItemsToAdd];
  CFpnwCookieBlock* pCookieBlock = new CFpnwCookieBlock(
    pcookiearray,nItemsToAdd,pParentCookie->QueryNonNULLMachineName(),pinfo );
  pParentCookie->m_listResultCookieBlocks.AddHead( pCookieBlock );

    for ( ; nItems > 0; nItems--, pvolumeinfo++, pcookiearray++ )
    {
        if (IsInvalidSharename(pvolumeinfo->lpVolumeName))
            continue;

    pcookiearray->m_pobject = pvolumeinfo;
    // WARNING cookie cast
    tRDItem.lParam = reinterpret_cast<LPARAM>((CCookie*)pcookiearray);
        HRESULT hr = pResultData->InsertItem(&tRDItem);
        ASSERT(SUCCEEDED(hr));
    }

    return S_OK;
}


typedef DWORD (*CONNECTIONENUMPROC) (LPWSTR,DWORD,LPBYTE*,PDWORD,PDWORD);

//   if pResultData is not NULL, add sessions/resources to the listbox
//   if pResultData is NULL, delete all sessions/resources
//   if pResultData is NULL, return SUCCEEDED(hr) to continue or
//     FAILED(hr) to abort
HRESULT FpnwFileServiceProvider::EnumerateSessions(
  IResultData* pResultData,
  CFileMgmtCookie* pcookie,
  bool bAddToResultPane)
{
  TEST_NONNULL_PTR_PARAM(pcookie);

  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

    FPNWCONNECTIONINFO* pconninfo = NULL;
    DWORD dwEntriesRead = 0;
    DWORD hEnumHandle = 0;
    HRESULT hr = S_OK;
    NET_API_STATUS retval = NERR_Success;
    do {
        retval = ((CONNECTIONENUMPROC)g_FpnwDLL[FPNW_CONNECTION_ENUM])(
            const_cast<LPTSTR>(pcookie->QueryTargetServer()),
      1,
      (PBYTE*)&pconninfo,
      &dwEntriesRead,
      &hEnumHandle );
        if (NERR_Success == retval)
        {
            hr = HandleFPNWSessionItems( pResultData, pcookie, pconninfo, dwEntriesRead,
          bAddToResultPane);
            pconninfo = NULL;
            break;
        } else if (ERROR_MORE_DATA == retval) {
            ASSERT( NULL != hEnumHandle );
            hr = HandleFPNWSessionItems( pResultData, pcookie, pconninfo, dwEntriesRead,
          bAddToResultPane);
            pconninfo = NULL;
            continue;
        } else if (RPC_S_SERVER_UNAVAILABLE == retval && 0 == hEnumHandle) {
      // FPNW just isn't installed, don't worry about it
            retval = NERR_Success;  
            break;
        } else {
      (void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, retval, IDS_POPUP_FPNW_SESSIONS, pcookie->QueryNonNULLMachineName() );
            break;
        }
    } while (S_OK == hr);

    return HRESULT_FROM_WIN32(retval);
}


/*
typedef enum _COLNUM_SESSIONS {
  COLNUM_SESSIONS_USERNAME = 0,
  COLNUM_SESSIONS_COMPUTERNAME,
  COLNUM_SESSIONS_NUM_FILES,
  COLNUM_SESSIONS_CONNECTED_TIME,
  COLNUM_SESSIONS_IDLE_TIME,
  COLNUM_SESSIONS_IS_GUEST
} COLNUM_SESSIONS;

typedef  struct  _FPNWConnectionInfo
{
    DWORD     dwConnectionId;
    FPNWSERVERADDR WkstaAddress;

    DWORD     dwAddressType;
    LPWSTR    lpUserName;

    DWORD     dwOpens;
    DWORD     dwLogonTime;
    BOOL      fLoggedOn;
    DWORD     dwForcedLogoffTime;
    BOOL      fAdministrator;
} FPNWCONNECTIONINFO;
*/


CString g_strFpnwNotLoggedIn;
BOOL g_fFpnwStringsLoaded = FALSE;


// returns S_FALSE if enumeration should stop
HRESULT FpnwFileServiceProvider::HandleFPNWSessionItems(
    IResultData* pResultData,
    CFileMgmtCookie* pParentCookie,
    PVOID pinfo,
    DWORD nItems,
    BOOL bAddToResultPane)
{
  TEST_NONNULL_PTR_PARAM(pParentCookie);
  TEST_NONNULL_PTR_PARAM(pinfo);

  if (0 >= nItems)
    return S_OK;

  BOOL fDeleteAllItems = (NULL == pResultData);

    RESULTDATAITEM tRDItem;
  ::ZeroMemory( &tRDItem, sizeof(tRDItem) );
  tRDItem.nCol = COLNUM_SESSIONS_USERNAME;
  tRDItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
  tRDItem.str = MMC_CALLBACK;
  tRDItem.nImage = iIconFPNWSession;
  // CODEWORK should use MMC_ICON_CALLBACK here
#ifndef UNICODE
#error
#endif

  FPNWCONNECTIONINFO* pconninfo = (FPNWCONNECTIONINFO*)pinfo;

  CFpnwSessionCookie* pcookiearray = new CFpnwSessionCookie[nItems];
  CFpnwCookieBlock* pCookieBlock = new CFpnwCookieBlock(
    pcookiearray,nItems,pParentCookie->QueryNonNULLMachineName(),pinfo );
  bool  bAdded = false;
  if ( !fDeleteAllItems || !bAddToResultPane )
  {
    pParentCookie->m_listResultCookieBlocks.AddHead( pCookieBlock );
    bAdded = true;
  }


  for ( ; nItems > 0; nItems--, pconninfo++, pcookiearray++ )
  {
    pcookiearray->m_pobject = pconninfo;

    if ( bAddToResultPane )
    {
      if (fDeleteAllItems)
      {
        DWORD dwApiResult = CloseSession( pcookiearray );
        if (0L != dwApiResult)
        {
          (void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, dwApiResult,
            IDS_POPUP_FPNW_DISCONNECTALLSESSION_ERROR);
          //return S_FALSE;
        }
        continue;
      }

      // WARNING cookie cast
      tRDItem.lParam = reinterpret_cast<LPARAM>((CCookie*)pcookiearray);
      HRESULT hr = pResultData->InsertItem(&tRDItem);
      ASSERT(SUCCEEDED(hr));
    }
  }

  if ( !bAdded ) // they were not added to the parent cookie's list
    delete pCookieBlock;

    return S_OK;
}


/*
DWORD
FpnwFileEnum(
    IN LPWSTR pServerName OPTIONAL,
    IN DWORD  dwLevel,
    IN LPWSTR pPathName OPTIONAL,
    OUT LPBYTE *ppFileInfo,
    OUT PDWORD pEntriesRead,
    IN OUT PDWORD resumeHandle OPTIONAL
);
*/

typedef DWORD (*FILEENUMPROC) (LPWSTR,DWORD,LPWSTR,LPBYTE*,PDWORD,PDWORD);

//   if pResultData is not NULL, add sessions/resources to the listbox
//   if pResultData is NULL, delete all sessions/resources
//   if pResultData is NULL, return SUCCEEDED(hr) to continue or
//     FAILED(hr) to abort
HRESULT FpnwFileServiceProvider::EnumerateResources(
  IResultData* pResultData,
  CFileMgmtCookie* pcookie)
{
  TEST_NONNULL_PTR_PARAM(pcookie);

  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

    FPNWFILEINFO* pfileinfo = NULL;
    DWORD dwEntriesRead = 0;
    DWORD hEnumHandle = 0;
    HRESULT hr = S_OK;
    NET_API_STATUS retval = NERR_Success;
    do {
        retval = ((FILEENUMPROC)g_FpnwDLL[FPNW_FILE_ENUM])(
            const_cast<LPTSTR>(pcookie->QueryTargetServer()),
      1,
      NULL, // basepath
      (PBYTE*)&pfileinfo,
      &dwEntriesRead,
      &hEnumHandle );
        if (NERR_Success == retval)
        {
            hr = HandleFPNWResourceItems( pResultData, pcookie, pfileinfo, dwEntriesRead );
            pfileinfo = NULL;
            break;
        } else if (ERROR_MORE_DATA == retval) {
            ASSERT( NULL != hEnumHandle );
            hr = HandleFPNWResourceItems( pResultData, pcookie, pfileinfo, dwEntriesRead );
            pfileinfo = NULL;
            continue;
        } else if (RPC_S_SERVER_UNAVAILABLE == retval && 0 == hEnumHandle) {
      // FPNW just isn't installed, don't worry about it
            retval = NERR_Success;  
            break;
        } else {
      (void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, retval, IDS_POPUP_FPNW_RESOURCES, pcookie->QueryNonNULLMachineName() );
            break;
        }
    } while (S_OK == hr);

    return HRESULT_FROM_WIN32(retval);
}


/*
typedef enum _COLNUM_RESOURCES {
  COLNUM_RESOURCES_FILENAME = 0,
  COLNUM_RESOURCES_USERNAME,
  COLNUM_RESOURCES_NUM_LOCKS,  // we don't try to display sharename for now, since
                // only FPNW has this information
  COLNUM_RESOURCES_OPEN_MODE
} COLNUM_RESOURCES;

typedef  struct _FPNWFileInfo
{
    DWORD     dwFileId;
    LPWSTR    lpPathName;
    LPWSTR    lpVolumeName;
    DWORD     dwPermissions;


    DWORD     dwLocks;
    LPWSTR    lpUserName;

    FPNWSERVERADDR WkstaAddress;
    DWORD     dwAddressType;

} FPNWFILEINFO, *PFPNWFILEINFO;
*/

HRESULT FpnwFileServiceProvider::HandleFPNWResourceItems(
    IResultData* pResultData,
    CFileMgmtCookie* pParentCookie,
    PVOID pinfo,
    DWORD nItems)
{
  TEST_NONNULL_PTR_PARAM(pParentCookie);
  TEST_NONNULL_PTR_PARAM(pinfo);

  if (0 >= nItems)
    return S_OK;

  BOOL fDeleteAllItems = (NULL == pResultData);

    RESULTDATAITEM tRDItem;
  ::ZeroMemory( &tRDItem, sizeof(tRDItem) );
  tRDItem.nCol = COLNUM_RESOURCES_FILENAME;
  tRDItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
  tRDItem.str = MMC_CALLBACK;
  tRDItem.nImage = iIconFPNWResource;
  // CODEWORK should use MMC_ICON_CALLBACK here

  FPNWFILEINFO* pfileinfo = (FPNWFILEINFO*)pinfo;

  CFpnwResourceCookie* pcookiearray = new CFpnwResourceCookie[nItems];
  CFpnwCookieBlock* pCookieBlock = new CFpnwCookieBlock(
    pcookiearray,nItems,pParentCookie->QueryNonNULLMachineName(),pinfo );
  if (!fDeleteAllItems)
  {
    pParentCookie->m_listResultCookieBlocks.AddHead( pCookieBlock );
  }

  CString str;
    for ( ; nItems > 0; nItems--, pfileinfo++, pcookiearray++ )
    {
    pcookiearray->m_pobject = pfileinfo;

    if (fDeleteAllItems)
    {
      DWORD dwApiResult = CloseResource( pcookiearray );
      if (0L != dwApiResult)
      {
        (void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, dwApiResult,
          IDS_POPUP_FPNW_DISCONNECTALLRESOURCE_ERROR,
          pfileinfo->lpPathName );
        return S_FALSE;
      }
      continue;
    }

    // WARNING cookie cast
    tRDItem.lParam = reinterpret_cast<LPARAM>((CCookie*)pcookiearray);
    HRESULT hr = pResultData->InsertItem(&tRDItem);
    ASSERT(SUCCEEDED(hr));
    }

  if (fDeleteAllItems) // they were not added to the parent cookie's list
    delete pCookieBlock;

  return S_OK;
}


/*
DWORD
FpnwVolumeDel(
    IN  LPWSTR pServerName OPTIONAL,
    IN  LPWSTR pVolumeName
);
*/

typedef DWORD (*VOLUMEDELPROC) (LPTSTR,LPTSTR);

NET_API_STATUS FpnwFileServiceProvider::DeleteShare( LPCTSTR lpcszServerName, LPCTSTR lpcszShareName )
{
  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

  NET_API_STATUS dwRet = ((VOLUMEDELPROC)g_FpnwDLL[FPNW_VOLUME_DEL])(
    const_cast<LPTSTR>(lpcszServerName),
    const_cast<LPTSTR>(lpcszShareName) );

  return (NERR_NetNameNotFound == dwRet ? NERR_Success : dwRet);
}

/*
DWORD FpnwConnectionDel(
    IN LPWSTR pServerName OPTIONAL,
    IN DWORD  dwConnectionId
);
*/

typedef DWORD (*CONNECTIONDELPROC) (LPWSTR,DWORD);

DWORD FpnwFileServiceProvider::CloseSession(CFileMgmtResultCookie* pcookie)
{
  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

  ASSERT( FILEMGMT_SESSION == pcookie->QueryObjectType() );
  FPNWCONNECTIONINFO* pconninfo = (FPNWCONNECTIONINFO*)pcookie->m_pobject;
  ASSERT( NULL != pconninfo );

  DWORD dwRet = ((CONNECTIONDELPROC)g_FpnwDLL[FPNW_CONNECTION_DEL])(
    const_cast<LPWSTR>(pcookie->QueryTargetServer()),
    pconninfo->dwConnectionId );

  return (NERR_ClientNameNotFound == dwRet ? NERR_Success : dwRet);
}

/*
DWORD
FpnwFileClose(
    IN LPWSTR pServerName OPTIONAL,
    IN DWORD  nFileId
);
*/

typedef DWORD (*FILECLOSEPROC) (LPWSTR,DWORD);

DWORD FpnwFileServiceProvider::CloseResource(CFileMgmtResultCookie* pcookie)
{
  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

  ASSERT( FILEMGMT_RESOURCE == pcookie->QueryObjectType() );
  FPNWFILEINFO* pfileinfo = (FPNWFILEINFO*)pcookie->m_pobject;
  ASSERT( NULL != pfileinfo );

  DWORD dwRet = ((FILECLOSEPROC)g_FpnwDLL[FPNW_FILE_CLOSE])(
    const_cast<LPWSTR>(pcookie->QueryTargetServer()),
    pfileinfo->dwFileId );

  return (NERR_FileIdNotFound == dwRet ? NERR_Success : dwRet);
}

/*
DWORD
FpnwVolumeGetInfo(
    IN  LPWSTR pServerName OPTIONAL,
    IN  LPWSTR pVolumeName,
    IN  DWORD  dwLevel,
    OUT LPBYTE *ppVolumeInfo
);


//
//  The following fields are modified by a call to FpnwVolumeSetInfo :
//
//  DWORD     dwMaxUses;              // Maximum number of connections that are
//  PSECURITY_DESCRIPTOR FileSecurityDescriptor;
//
//  All other fields in FPNWVOLUMEINFO structure are ignored.  You may send
//  in a pointer to an FPNWVOLUMEINFO_2 structure instead of FPNWVOLUMEINFO.
//

DWORD
FpnwVolumeSetInfo(
    IN  LPWSTR pServerName OPTIONAL,
    IN  LPWSTR pVolumeName,
    IN  DWORD  dwLevel,
    IN  LPBYTE pVolumeInfo
);

typedef struct _FPNWVolumeInfo
{
    LPWSTR    lpVolumeName;           // Name of the volume
    DWORD     dwType;                 // Specifics of the volume. FPNWVOL_TYPE_???
    DWORD     dwMaxUses;              // Maximum number of connections that are
                                      // allowed to the volume
    DWORD     dwCurrentUses;          // Current number of connections to the volume
    LPWSTR    lpPath;                 // Path of the volume

} FPNWVOLUMEINFO, *PFPNWVOLUMEINFO;
*/

typedef DWORD (*VOLUMEGETINFOPROC) (LPWSTR,LPWSTR,DWORD,LPBYTE*);
typedef DWORD (*VOLUMESETINFOPROC) (LPWSTR,LPWSTR,DWORD,LPBYTE);

VOID FpnwFileServiceProvider::DisplayShareProperties(
    LPPROPERTYSHEETCALLBACK pCallBack,
    LPDATAOBJECT pDataObject,
    LONG_PTR handle)
{
  CSharePageGeneral * pPage = new CSharePageGeneral();
    if ( !pPage->Load( m_pFileMgmtData, pDataObject ) )
    return;

  // This mechanism deletes the CFileMgmtGeneral when the property sheet is finished
  pPage->m_pfnOriginalPropSheetPageProc = pPage->m_psp.pfnCallback;
  pPage->m_psp.lParam = reinterpret_cast<LPARAM>(pPage);
  pPage->m_psp.pfnCallback = &CSharePageGeneral::PropSheetPageProc;
  pPage->m_handle = handle;

  MMCPropPageCallback(INOUT &pPage->m_psp);
  HPROPSHEETPAGE hPage=MyCreatePropertySheetPage(&pPage->m_psp);
  pCallBack->AddPage(hPage);

  CComObject<CFPNWSecurityInformation>* psecinfo = NULL;
  HRESULT hRes = CComObject<CFPNWSecurityInformation>::CreateInstance(&psecinfo);
  if ( SUCCEEDED(hRes) )
    MyCreateShareSecurityPage(
      pCallBack,
      psecinfo,
      pPage->m_strMachineName,
      pPage->m_strShareName );

  CreateFolderSecurityPropPage(pCallBack, pDataObject);

}

DWORD FpnwFileServiceProvider::ReadShareProperties(
    LPCTSTR ptchServerName,
    LPCTSTR ptchShareName,
    OUT PVOID* ppvPropertyBlock,
    OUT CString& /*strDescription*/,
    OUT CString& strPath,
    OUT BOOL* pfEditDescription,
    OUT BOOL* pfEditPath,
    OUT DWORD* pdwShareType)
{
  if ( !g_FpnwDLL.LoadFunctionPointers() )
  {
    ASSERT(FALSE);
    return S_OK;
  }

  if (ppvPropertyBlock)     *ppvPropertyBlock = NULL;
  if (pdwShareType)         *pdwShareType = 0;
  if (pfEditDescription)    *pfEditDescription = FALSE;
  if (pfEditPath)           *pfEditPath = FALSE;

  USES_CONVERSION; // CODEWORK should store in native WCHAR
  FPNWVOLUMEINFO* pvolumeinfo = NULL;
  NET_API_STATUS retval = ((VOLUMEGETINFOPROC)g_FpnwDLL[FPNW_VOLUME_GET_INFO])(
                                                        T2OLE(const_cast<LPTSTR>(ptchServerName)),
                                                        T2OLE(const_cast<LPTSTR>(ptchShareName)),
                                                        1,
                                                        (LPBYTE*)&pvolumeinfo);
  if (NERR_Success == retval)
  {
    strPath = pvolumeinfo->lpPath;
    if (ppvPropertyBlock)
    {
        *ppvPropertyBlock = pvolumeinfo; // will be freed by the caller
    } else
    {
        FreeData((LPVOID)pvolumeinfo);
    }
  }

  return retval;
}

DWORD FpnwFileServiceProvider::WriteShareProperties(LPCTSTR ptchServerName, LPCTSTR ptchShareName,
    PVOID pvPropertyBlock, LPCTSTR /*ptchDescription*/, LPCTSTR ptchPath)
{
  ASSERT( NULL != pvPropertyBlock );
  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

  FPNWVOLUMEINFO* pvolumeinfo = (FPNWVOLUMEINFO*)pvPropertyBlock;
  pvolumeinfo->lpPath = const_cast<LPTSTR>(ptchPath);
  DWORD retval = ((VOLUMESETINFOPROC)g_FpnwDLL[FPNW_VOLUME_SET_INFO])(
    const_cast<LPTSTR>(ptchServerName),
    const_cast<LPTSTR>(ptchShareName),
    1,
    (LPBYTE)pvolumeinfo);
  pvolumeinfo->lpPath = NULL;
  return retval;
}

VOID FpnwFileServiceProvider::FreeShareProperties(PVOID pvPropertyBlock)
{
  FreeData( pvPropertyBlock );
}


DWORD FpnwFileServiceProvider::QueryMaxUsers(PVOID pvPropertyBlock)
{
  FPNWVOLUMEINFO* pvolumeinfo = (FPNWVOLUMEINFO*)pvPropertyBlock;
  ASSERT( NULL != pvolumeinfo );
  return pvolumeinfo->dwMaxUses;
}

VOID FpnwFileServiceProvider::SetMaxUsers(PVOID pvPropertyBlock, DWORD dwMaxUsers)
{
  FPNWVOLUMEINFO* pvolumeinfo = (FPNWVOLUMEINFO*)pvPropertyBlock;
  ASSERT( NULL != pvolumeinfo );
  pvolumeinfo->dwMaxUses = dwMaxUsers;
}
VOID FpnwFileServiceProvider::FreeData(PVOID pv)
{
  FPNWFreeData( &pv );
}

CFpnwCookieBlock::~CFpnwCookieBlock()
{
  FPNWFreeData( &m_pvCookieData );
}

DEFINE_COOKIE_BLOCK(CFpnwCookie)
DEFINE_FORWARDS_MACHINE_NAME( CFpnwCookie, m_pCookieBlock )

void CFpnwCookie::AddRefCookie() { m_pCookieBlock->AddRef(); }
void CFpnwCookie::ReleaseCookie() { m_pCookieBlock->Release(); }

LPCTSTR FpnwFileServiceProvider::QueryTransportString()
{
  return m_strTransportFPNW;
}

HRESULT CFpnwCookie::GetTransport( FILEMGMT_TRANSPORT* pTransport )
{
  *pTransport = FILEMGMT_FPNW;
  return S_OK;
}

HRESULT CFpnwShareCookie::GetShareName( CString& strShareName )
{
  FPNWVOLUMEINFO* pvolumeinfo = (FPNWVOLUMEINFO*)m_pobject;
  ASSERT( NULL != pvolumeinfo );
  USES_CONVERSION;
  strShareName = OLE2T(pvolumeinfo->lpVolumeName);
  return S_OK;
}

HRESULT CFpnwShareCookie::GetSharePIDList( OUT LPITEMIDLIST *ppidl )
{
  ASSERT(ppidl);
  ASSERT(NULL == *ppidl);  // prevent memory leak
  *ppidl = NULL;

  FPNWVOLUMEINFO* pvolumeinfo = (FPNWVOLUMEINFO*)m_pobject;
  ASSERT( NULL != pvolumeinfo );
  ASSERT( _tcslen(pvolumeinfo->lpPath) >= 3 && 
          _T(':') == *(pvolumeinfo->lpPath + 1) );
  USES_CONVERSION;

  PCTSTR pszTargetServer = m_pCookieBlock->QueryTargetServer();
  CString csPath;

  if (pszTargetServer)
  {
    //
    // since MS Windows user cannot see shares created for MAC or Netware users,
    // we have to use $ share to retrieve the pidl here.
    //
    CString csTemp = OLE2T(pvolumeinfo->lpPath);
    csTemp.SetAt(1, _T('$'));
    if ( _tcslen(pszTargetServer) >= 2 &&
         _T('\\') == *pszTargetServer &&
         _T('\\') == *(pszTargetServer + 1) )
    {
      csPath = pszTargetServer;
    } else
    {
      csPath = _T("\\\\");
      csPath += pszTargetServer;
    }
    csPath += _T("\\");
    csPath += csTemp;
  } else
  {
    csPath = OLE2T(pvolumeinfo->lpPath);
  }

  if (FALSE == csPath.IsEmpty())
    *ppidl = ILCreateFromPath(csPath);

  return ((*ppidl) ? S_OK : E_FAIL);
}

HRESULT CFpnwSessionCookie::GetSessionID( DWORD* pdwSessionID )
{
  FPNWCONNECTIONINFO* pconninfo = (FPNWCONNECTIONINFO*)m_pobject;
  ASSERT( NULL != pdwSessionID && NULL != pconninfo );
  *pdwSessionID = pconninfo->dwConnectionId;
  return S_OK;
}

HRESULT CFpnwResourceCookie::GetFileID( DWORD* pdwFileID )
{
  FPNWFILEINFO* pfileinfo = (FPNWFILEINFO*)m_pobject;
  ASSERT( NULL != pdwFileID && NULL != pfileinfo );
  *pdwFileID = pfileinfo->dwFileId;
  return S_OK;
}

BSTR CFpnwShareCookie::GetColumnText( int nCol )
{
  switch (nCol)
  {
  case COLNUM_SHARES_SHARED_FOLDER:
    return GetShareInfo()->lpVolumeName;
  case COLNUM_SHARES_SHARED_PATH:
    return GetShareInfo()->lpPath;
  case COLNUM_SHARES_TRANSPORT:
    return const_cast<BSTR>((LPCTSTR)g_strTransportFPNW);
  case COLNUM_SHARES_COMMENT:
    break; // not known for FPNW
  default:
    ASSERT(FALSE);
    break;
  }
  return L"";
}

BSTR CFpnwShareCookie::QueryResultColumnText( int nCol, CFileMgmtComponentData& /*refcdata*/ )
{
  if (COLNUM_SHARES_NUM_SESSIONS == nCol)
    return MakeDwordResult( GetNumOfCurrentUses() );

  return GetColumnText(nCol);
}

BSTR CFpnwSessionCookie::GetColumnText( int nCol )
{
  switch (nCol)
  {
  case COLNUM_SESSIONS_USERNAME:
    return GetSessionInfo()->lpUserName;
  case COLNUM_SESSIONS_COMPUTERNAME:
    break; // not known for FPNW
  case COLNUM_SESSIONS_TRANSPORT:
    return const_cast<BSTR>((LPCTSTR)g_strTransportFPNW);
  case COLNUM_SESSIONS_IS_GUEST:
    break; // not known for FPNW
  default:
    ASSERT(FALSE);
    break;
  }
  return L"";
}

BSTR CFpnwSessionCookie::QueryResultColumnText( int nCol, CFileMgmtComponentData& /*refcdata*/ )
{
  switch (nCol)
  {
  case COLNUM_SESSIONS_NUM_FILES:
    return MakeDwordResult( GetNumOfOpenFiles() );
  case COLNUM_SESSIONS_CONNECTED_TIME:
    return MakeElapsedTimeResult( GetConnectedTime() );
  case COLNUM_SESSIONS_IDLE_TIME:
    return L""; // not known for FPNW
  default:
    break;
  }
  return GetColumnText(nCol);
}

BSTR CFpnwResourceCookie::GetColumnText( int nCol )
{
  switch (nCol)
  {
  case COLNUM_RESOURCES_FILENAME:
    return GetFileInfo()->lpPathName;
  case COLNUM_RESOURCES_USERNAME:
    return GetFileInfo()->lpUserName;
  case COLNUM_RESOURCES_TRANSPORT:
    return const_cast<BSTR>((LPCTSTR)g_strTransportFPNW);
  case COLNUM_RESOURCES_OPEN_MODE:
    return MakePermissionsResult(GetFileInfo()->dwPermissions);
  default:
    ASSERT(FALSE);
    break;
  }
  return L"";
}

BSTR CFpnwResourceCookie::QueryResultColumnText( int nCol, CFileMgmtComponentData& /*refcdata*/ )
{
  if (COLNUM_RESOURCES_NUM_LOCKS == nCol)
    return MakeDwordResult( GetNumOfLocks() );

  return GetColumnText(nCol);
}

CFPNWSecurityInformation::CFPNWSecurityInformation()
: m_pvolumeinfo( NULL ),
  m_pDefaultDescriptor( NULL )
{
}

CFPNWSecurityInformation::~CFPNWSecurityInformation()
{
  if (NULL != m_pDefaultDescriptor)
  {
    delete m_pDefaultDescriptor;
    m_pvolumeinfo->FileSecurityDescriptor = NULL;
  }
  FPNWFreeData( (PVOID*)&m_pvolumeinfo );
}

STDMETHODIMP CFPNWSecurityInformation::GetSecurity (
                        SECURITY_INFORMATION RequestedInformation,
                        PSECURITY_DESCRIPTOR *ppSecurityDescriptor,
                        BOOL fDefault )
{
  MFC_TRY;

    if (0 == RequestedInformation || NULL == ppSecurityDescriptor)
    {
        ASSERT(FALSE);
        return E_INVALIDARG;
    }

    if (fDefault)
        return E_NOTIMPL;

    *ppSecurityDescriptor = NULL;

  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

  FPNWFreeData( (PVOID*)&m_pvolumeinfo );
    NET_API_STATUS dwErr = ((VOLUMEGETINFOPROC)g_FpnwDLL[FPNW_VOLUME_GET_INFO])(
    QueryMachineName(),
    QueryShareName(),
    2,
    (LPBYTE*)&m_pvolumeinfo );
  if (NERR_Success != dwErr)
  {
    // AndyHe confirms errors are in WIN32 error namespace
    return HRESULT_FROM_WIN32(dwErr);
  }
  ASSERT( NULL != m_pvolumeinfo );
  if (NULL == m_pvolumeinfo->FileSecurityDescriptor)
  {
    if (NULL == m_pDefaultDescriptor)
    {
      HRESULT hr = NewDefaultDescriptor(
        &m_pDefaultDescriptor,
        RequestedInformation );
      if ( !SUCCEEDED(hr) )
        return hr;
    }
    m_pvolumeinfo->FileSecurityDescriptor = m_pDefaultDescriptor;
  }
  ASSERT( NULL != m_pvolumeinfo->FileSecurityDescriptor );

  // We have to pass back a LocalAlloc'ed copy of the SD
  return MakeSelfRelativeCopy(
    m_pvolumeinfo->FileSecurityDescriptor,
    ppSecurityDescriptor );

  MFC_CATCH;
}

STDMETHODIMP CFPNWSecurityInformation::SetSecurity (
                        SECURITY_INFORMATION SecurityInformation,
                        PSECURITY_DESCRIPTOR pSecurityDescriptor )
{
  MFC_TRY;

  if ( !g_FpnwDLL.LoadFunctionPointers() )
    return S_OK;

  // First get the current settings
  PSECURITY_DESCRIPTOR dummy;
  HRESULT hr = GetSecurity( SecurityInformation, &dummy, FALSE );
  if ( FAILED(hr) )
    return hr;

  // Now set the new values
  m_pvolumeinfo->FileSecurityDescriptor = pSecurityDescriptor;
    NET_API_STATUS dwErr = ((VOLUMESETINFOPROC)g_FpnwDLL[FPNW_VOLUME_SET_INFO])(
    QueryMachineName(),
    QueryShareName(),
    2,
    (LPBYTE)m_pvolumeinfo );
  if (NERR_Success != dwErr)
  {
    return HRESULT_FROM_WIN32(dwErr);
  }

    return S_OK;

  MFC_CATCH;
}