archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
8 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: 744f0b4006
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '744f0b4006'
${ noResults }
windows-xp/Source/XPSP1/NT/net/sfm/afp/ui/afpmgr/newvol.cxx

1831 lines
38 KiB
Raw Blame History

/**********************************************************************/
/** Microsoft Windows NT **/
/** Copyright(c) Microsoft Corp., 1991 **/
/**********************************************************************/
/*
newvol.cxx
This file contains the definition of NEW_VOLUME_DIALOG.
History:
NarenG 11/18/92 Modified SHARE_DIALOG_BASE for
AFPMGR
*/
extern "C"
{
#include <nt.h>
#include <ntrtl.h>
#include <ntseapi.h>
#include <nturtl.h>
}
#define INCL_WINDOWS_GDI
#define INCL_WINDOWS
#define INCL_DOSERRORS
#define INCL_NET
#define INCL_NETERRORS
#define INCL_NETSHARE
#define INCL_NETSERVER
#define INCL_NETCONS
#define INCL_NETLIB
#define INCL_NETUSE
#define INCL_NETSHARE
#include <lmui.hxx>
#define INCL_BLT_WINDOW
#define INCL_BLT_DIALOG
#define INCL_BLT_CONTROL
#define INCL_BLT_MISC
#define INCL_BLT_CLIENT
#define INCL_BLT_MSGPOPUP
#define INCL_BLT_SPIN_GROUP
#define INCL_BLT_GROUP
#include <blt.hxx>
#include <lmodev.hxx>
#include <lmoshare.hxx>
#include <string.hxx>
#include <uitrace.hxx>
#include <dbgstr.hxx>
#include <netname.hxx>
extern "C"
{
#include <mnet.h>
#include <afpmgr.h>
#include <macfile.h>
extern APIERR ConvertRedirectedDriveToLocal( NLS_STR nlsServer,
NLS_STR * pnlsDrive,
NLS_STR * pnlsPath );
extern BOOL IsDriveGreaterThan2Gig( LPWSTR lpwsVolPath,
APIERR * perr );
}
#include "util.hxx"
#include "perms.hxx"
#include "newvol.hxx"
/*******************************************************************
NAME: NEW_VOLUME_SRVMGR_DIALOG::NEW_VOLUME_SRVMGR_DIALOG
SYNOPSIS: Constructor for NEW_VOLUME_SRVMGR_DIALOG class
ENTRY: hwndParent - handle of parent window
EXIT:
RETURNS:
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
NEW_VOLUME_SRVMGR_DIALOG::NEW_VOLUME_SRVMGR_DIALOG(
HWND hwndParent,
AFP_SERVER_HANDLE hServer,
const TCHAR * pszServerName )
: DIALOG_WINDOW ( MAKEINTRESOURCE(IDD_NEW_VOLUME_DIALOG), hwndParent ),
_sleVolumeName( this, IDNV_SLE_NAME, AFP_VOLNAME_LEN ),
_sleVolumePath( this, IDNV_SLE_PATH ),
_slePassword( this, IDNV_SLE_PASSWORD, AFP_VOLPASS_LEN ),
_slePasswordConfirm( this, IDNV_SLE_CONFIRM_PASSWORD, AFP_VOLPASS_LEN ),
_chkReadOnly( this, IDNV_CHK_READONLY ),
_chkGuestAccess( this, IDNV_CHK_GUEST_ACCESS ),
_mgrpUserLimit( this, IDNV_RB_UNLIMITED, 2, IDNV_RB_UNLIMITED),
_spsleUsers( this, IDNV_SLE_USERS,1,1,AFP_VOLUME_UNLIMITED_USES-1,
TRUE,IDNV_SLE_USERS_GROUP),
_spgrpUsers(this,IDNV_SB_USERS_GROUP,IDNV_SB_USERS_UP,IDNV_SB_USERS_DOWN),
_pbPermissions( this, IDNV_PB_PERMISSIONS ),
_pbOK( this, IDOK ),
_pbCancel( this, IDCANCEL ),
_nlsOwner(),
_nlsGroup(),
_hServer( hServer ),
_nlsServerName( pszServerName ),
_fCommitDirInfo( FALSE )
{
AUTO_CURSOR Cursor;
//
// Make sure everything constructed OK
//
if ( QueryError() != NERR_Success )
return;
APIERR err;
if ( ((err = _mgrpUserLimit.QueryError()) != NERR_Success )
|| ((err = _spgrpUsers.AddAssociation( &_spsleUsers )) != NERR_Success )
|| ((err = _mgrpUserLimit.AddAssociation( IDNV_RB_USERS, &_spgrpUsers ))
!= NERR_Success )
|| ((err = _chkReadOnly.QueryError()) != NERR_Success )
|| ((err = _chkGuestAccess.QueryError()) != NERR_Success )
|| ((err = _nlsServerName.QueryError()) != NERR_Success )
|| ((err = _nlsOwner.QueryError()) != NERR_Success )
|| ((err = _nlsGroup.QueryError()) != NERR_Success )
)
{
ReportError( err );
return;
}
//
// Set the caption
//
err = ::SetCaption( this, IDS_CAPTION_CREATE_VOLUME, pszServerName );
if ( err != NO_ERROR )
{
ReportError( err );
return;
}
//
// Set the defaults
//
_chkReadOnly.SetCheck( FALSE );
_chkGuestAccess.SetCheck( TRUE );
_mgrpUserLimit.SetSelection( IDNV_RB_UNLIMITED );
_pbPermissions.Enable( FALSE );
}
/*******************************************************************
NAME: NEW_VOLUME_SRVMGR_DIALOG::OnCommand
SYNOPSIS: Handle the case where the user clicked the permission button
ENTRY: event - the CONTROL_EVENT that occurred
EXIT:
RETURNS:
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
BOOL NEW_VOLUME_SRVMGR_DIALOG::OnCommand( const CONTROL_EVENT &event )
{
APIERR err;
if ( event.QueryCid() == IDNV_PB_PERMISSIONS )
{
AUTO_CURSOR Cursor;
//
// Get the volume path and validate it.
//
NLS_STR nlsDisplayPath;
NLS_STR nlsVolumePath;
BOOL fOk;
if ((( err = nlsVolumePath.QueryError() ) != NERR_Success ) ||
(( err = nlsDisplayPath.QueryError() ) != NERR_Success ) ||
(( err = _sleVolumePath.QueryText(&nlsDisplayPath))
!= NERR_Success ))
{
::MsgPopup( this, AFPERR_TO_STRINGID( err ) );
return FALSE;
}
//
// Validate the path.
//
NET_NAME netname( nlsDisplayPath.QueryPch() );
if ( ( err = netname.QueryError() ) != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return FALSE;
}
if ( netname.QueryType() == TYPE_PATH_UNC )
{
::MsgPopup( this, IDS_TYPE_LOCAL_PATH );
SetFocusOnPath();
return TRUE;
}
nlsVolumePath.CopyFrom( nlsDisplayPath );
_fCommitDirInfo = TRUE;
DIRECTORY_PERMISSIONS_DLG *pdlg = new DIRECTORY_PERMISSIONS_DLG(
QueryHwnd(),
_hServer,
_nlsServerName.QueryPch(),
TRUE,
nlsVolumePath.QueryPch(),
nlsDisplayPath.QueryPch(),
FALSE,
&_nlsOwner,
&_nlsGroup,
&_dwPerms );
if ( ( pdlg == NULL )
|| (( err = pdlg->QueryError()) != NERR_Success )
|| (( err = pdlg->Process( &fOk )) != NERR_Success )
)
{
err = (pdlg == NULL ) ? ERROR_NOT_ENOUGH_MEMORY : err;
::MsgPopup( this, AFPERR_TO_STRINGID( err ) );
}
delete pdlg;
if ( ( err != NERR_Success ) || ( !fOk ) )
{
_fCommitDirInfo = FALSE;
}
return TRUE;
}
//
// Enable the permissions button if the path string is filled in.
//
if ( event.QueryCid() == IDNV_SLE_PATH )
{
if ( event.QueryCode() == EN_CHANGE )
{
if ( _sleVolumePath.QueryTextLength() > 0 )
{
_pbOK.MakeDefault();
_pbPermissions.Enable( TRUE );
}
else
{
_pbPermissions.Enable( FALSE );
_pbCancel.MakeDefault();
}
}
return TRUE;
}
return DIALOG_WINDOW::OnCommand( event );
}
/*******************************************************************
NAME: NEW_VOLUME_SRVMGR_DIALOG::OnOK
SYNOPSIS: Validate all the information and create the volume.
ENTRY:
EXIT:
RETURNS:
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
BOOL NEW_VOLUME_SRVMGR_DIALOG::OnOK( VOID )
{
APIERR err;
NLS_STR nlsVolumePath;
NLS_STR nlsVolumeName;
NLS_STR nlsPassword;
NLS_STR nlsPasswordConfirm;
WCHAR szVolPath[CNLEN+6];
WCHAR *wchTemp;
AUTO_CURSOR Cursor;
//
// This is not a loop.
//
do {
//
// Get the volume name.
//
if ( ( err = nlsVolumeName.QueryError() ) != NERR_Success )
break;
if ((err = _sleVolumeName.QueryText( &nlsVolumeName )) != NERR_Success)
break;
//
// Get the volume path.
//
if ( ( err = nlsVolumePath.QueryError() ) != NERR_Success )
break;
if (( err = _sleVolumePath.QueryText(&nlsVolumePath)) != NERR_Success)
break;
//
// Get the password if there is one.
//
if ( ( err = nlsPassword.QueryError() ) != NERR_Success )
break;
if ( ( err = _slePassword.QueryText( &nlsPassword )) != NERR_Success )
break;
//
// Get the password confirmation.
//
if ( ( err = nlsPasswordConfirm.QueryError() ) != NERR_Success )
break;
if ( ( err = _slePasswordConfirm.QueryText( &nlsPasswordConfirm ))
!= NERR_Success )
break;
}while( FALSE );
if ( err != NERR_Success )
{
::MsgPopup( this, err );
return TRUE;
}
//
// Set up the volume structure
//
AFP_VOLUME_INFO AfpVolume;
if ( nlsVolumeName.strlen() > 0 )
{
//
// Validate the volume name
//
ISTR istr( nlsVolumeName );
if ( nlsVolumeName.strchr( &istr, TEXT(':') ) )
{
::MsgPopup( this, IDS_AFPERR_InvalidVolumeName );
SetFocusOnName();
return FALSE;
}
AfpVolume.afpvol_name = (LPWSTR)(nlsVolumeName.QueryPch());
}
else
{
::MsgPopup( this, IDS_NEED_VOLUME_NAME );
SetFocusOnName();
return TRUE;
}
//
// Validate the path.
//
NET_NAME netname( nlsVolumePath.QueryPch() );
if ( ( err = netname.QueryError() ) != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return TRUE;
}
if ( netname.QueryType() == TYPE_PATH_UNC )
{
::MsgPopup( this, IDS_TYPE_LOCAL_PATH );
SetFocusOnPath();
return TRUE;
}
::wcscpy(szVolPath, _nlsServerName.QueryPch());
wchTemp = szVolPath + wcslen(szVolPath);
*wchTemp++ = TEXT('\\');
*wchTemp++ = (nlsVolumePath.QueryPch())[0];
*wchTemp++ = TEXT('$');
*wchTemp++ = TEXT('\\');
*wchTemp++ = 0;
BOOL fDriveGreaterThan2Gig = ::IsDriveGreaterThan2Gig( (LPWSTR)(szVolPath), &err );
if ( err != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return TRUE;
}
if ( fDriveGreaterThan2Gig )
{
if ( ::MsgPopup( this,
IDS_VOLUME_TOO_BIG,
MPSEV_WARNING,
MP_YESNO,
MP_NO ) == IDNO )
{
SetFocusOnPath();
return TRUE;
}
}
AfpVolume.afpvol_path = (LPWSTR)(nlsVolumePath.QueryPch());
//
// Make sure the passwords match.
//
if ( nlsPassword.strcmp( nlsPasswordConfirm ) )
{
::MsgPopup( this, IDS_PASSWORD_MISMATCH );
SetFocusOnPasswordConfirm();
return TRUE;
}
if ( nlsPassword.strlen() > 0 )
{
AfpVolume.afpvol_password = (LPWSTR)(nlsPassword.QueryPch());
}
else
{
AfpVolume.afpvol_password = (LPWSTR)NULL;
}
AfpVolume.afpvol_props_mask = _chkReadOnly.QueryCheck()
? AFP_VOLUME_READONLY
: 0;
AfpVolume.afpvol_props_mask = _chkGuestAccess.QueryCheck()
? (AFP_VOLUME_GUESTACCESS | AfpVolume.afpvol_props_mask)
: AfpVolume.afpvol_props_mask;
AfpVolume.afpvol_max_uses = QueryUserLimit();
//
// Try to create the volume.
//
err = ::AfpAdminVolumeAdd( _hServer, (LPBYTE)&AfpVolume );
if ( err != NO_ERROR )
{
::MsgPopup( this, AFPERR_TO_STRINGID( err ) );
SetFocusOnPath();
return FALSE;
}
//
// If the user mucked around with the root directory's permissions
// the we have to set it.
//
if ( _fCommitDirInfo )
{
AFP_DIRECTORY_INFO AfpDirInfo;
AfpDirInfo.afpdir_path = (LPWSTR)nlsVolumePath.QueryPch();
AfpDirInfo.afpdir_owner = (LPWSTR)_nlsOwner.QueryPch();
AfpDirInfo.afpdir_group = (LPWSTR)_nlsGroup.QueryPch();
AfpDirInfo.afpdir_perms = _dwPerms;
err = ::AfpAdminDirectorySetInfo( _hServer,
(LPBYTE)&AfpDirInfo,
AFP_DIR_PARMNUM_ALL );
}
else
{
//
// User did not muck arount with the permissions, so we have
// to get and reset the current permissions. This is requred
// to remove everyone as the owner.
//
PAFP_DIRECTORY_INFO pAfpDirInfo;
err = ::AfpAdminDirectoryGetInfo( _hServer,
(LPWSTR)nlsVolumePath.QueryPch(),
(LPBYTE*)&pAfpDirInfo );
if ( err == NO_ERROR )
{
DWORD dwParmNum = AFP_DIR_PARMNUM_PERMS;
pAfpDirInfo->afpdir_path = (LPWSTR)(nlsVolumePath.QueryPch());
if ( pAfpDirInfo->afpdir_owner != (LPWSTR)NULL )
{
dwParmNum |= AFP_DIR_PARMNUM_OWNER;
}
if ( pAfpDirInfo->afpdir_group != (LPWSTR)NULL )
{
dwParmNum |= AFP_DIR_PARMNUM_GROUP;
}
err = ::AfpAdminDirectorySetInfo( _hServer,
(LPBYTE)pAfpDirInfo,
dwParmNum );
::AfpAdminBufferFree( pAfpDirInfo );
}
}
switch( err )
{
case NO_ERROR:
case AFPERR_SecurityNotSupported:
Dismiss( TRUE );
break;
case AFPERR_NoSuchUser:
case AFPERR_NoSuchGroup:
case AFPERR_NoSuchUserGroup:
case ERROR_NONE_MAPPED:
::MsgPopup( this, IDS_INVALID_DIR_ACCOUNT, MPSEV_INFO );
Dismiss( TRUE );
break;
case AFPERR_UnsupportedFS:
//
// Ignore this error
//
Dismiss( TRUE );
break;
default:
::AfpAdminVolumeDelete( _hServer, (LPWSTR)(nlsVolumeName.QueryPch()));
::MsgPopup( this, AFPERR_TO_STRINGID( err ) );
break;
}
return TRUE;
}
/*******************************************************************
NAME: NEW_VOLUME_SRVMGR_DIALOG::QueryUserLimit
SYNOPSIS: Get the user limit from the magic group
ENTRY:
EXIT:
RETURNS: The user limit stored in the user limit magic group
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
DWORD NEW_VOLUME_SRVMGR_DIALOG::QueryUserLimit( VOID ) const
{
switch ( _mgrpUserLimit.QuerySelection() )
{
case IDNV_RB_UNLIMITED:
return( AFP_VOLUME_UNLIMITED_USES );
case IDNV_RB_USERS:
return( _spsleUsers.QueryValue() );
default:
//
// Should never get here but in case we do, return unlimited
//
return( AFP_VOLUME_UNLIMITED_USES );
}
}
/*******************************************************************
NAME: NEW_VOLUME_SRVMGR_DIALOG::QueryHelpContext
SYNOPSIS: Query the help context of the dialog
ENTRY:
EXIT:
RETURNS: Return the help context of the dialog
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
ULONG NEW_VOLUME_SRVMGR_DIALOG::QueryHelpContext( VOID )
{
return HC_NEW_VOLUME_SRVMGR_DIALOG;
}
/*******************************************************************
NAME: NEW_VOLUME_FILEMGR_DIALOG::NEW_VOLUME_FILEMGR_DIALOG
SYNOPSIS: Constructor for NEW_VOLUME_FILEMGR_DIALOG class
ENTRY: hwndParent - handle of parent window
EXIT:
RETURNS:
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
NEW_VOLUME_FILEMGR_DIALOG::NEW_VOLUME_FILEMGR_DIALOG(
HWND hwndParent,
const TCHAR * pszPath,
BOOL fIsFile )
: DIALOG_WINDOW ( MAKEINTRESOURCE(IDD_NEW_VOLUME_DIALOG), hwndParent ),
_sleVolumeName( this, IDNV_SLE_NAME, AFP_VOLNAME_LEN ),
_sleVolumePath( this, IDNV_SLE_PATH ),
_slePassword( this, IDNV_SLE_PASSWORD, AFP_VOLPASS_LEN ),
_slePasswordConfirm( this, IDNV_SLE_CONFIRM_PASSWORD, AFP_VOLPASS_LEN ),
_chkReadOnly( this, IDNV_CHK_READONLY ),
_chkGuestAccess( this, IDNV_CHK_GUEST_ACCESS ),
_mgrpUserLimit( this, IDNV_RB_UNLIMITED, 2, IDNV_RB_UNLIMITED),
_spsleUsers( this, IDNV_SLE_USERS,1,1,AFP_VOLUME_UNLIMITED_USES-1,
TRUE,IDNV_SLE_USERS_GROUP),
_spgrpUsers(this,IDNV_SB_USERS_GROUP,IDNV_SB_USERS_UP,IDNV_SB_USERS_DOWN),
_pbPermissions( this, IDNV_PB_PERMISSIONS ),
_pbOK( this, IDOK ),
_pbCancel( this, IDCANCEL ),
_nlsOwner(),
_nlsGroup(),
_fCommitDirInfo( FALSE )
{
AUTO_CURSOR Cursor;
//
// Make sure everything constructed OK
//
if ( QueryError() != NERR_Success )
return;
APIERR err;
if ( ((err = _mgrpUserLimit.QueryError()) != NERR_Success )
|| ((err = _spgrpUsers.AddAssociation( &_spsleUsers )) != NERR_Success )
|| ((err = _mgrpUserLimit.AddAssociation( IDNV_RB_USERS, &_spgrpUsers ))
!= NERR_Success )
|| ((err = _chkReadOnly.QueryError()) != NERR_Success )
|| ((err = _chkGuestAccess.QueryError()) != NERR_Success )
|| ((err = _nlsOwner.QueryError()) != NERR_Success )
|| ((err = _nlsGroup.QueryError()) != NERR_Success )
)
{
ReportError( err );
return;
}
//
// Set the defaults
//
_chkReadOnly.SetCheck( FALSE );
_chkGuestAccess.SetCheck( TRUE );
_mgrpUserLimit.SetSelection( IDNV_RB_UNLIMITED );
_pbPermissions.Enable( FALSE );
//
// Set the volumename and path if the path drive is NTFS
//
NLS_STR nlsVolumePath( pszPath );
NLS_STR nlsVolumeName;
NLS_STR nlsUNCPath;
if ( (( err = nlsVolumePath.QueryError() ) != NERR_Success ) ||
(( err = nlsVolumeName.QueryError() ) != NERR_Success ) ||
(( err = nlsUNCPath.QueryError() ) != NERR_Success ) )
{
ReportError( err );
return;
}
err = ValidateVolumePath( nlsVolumePath.QueryPch() );
if ( ( err != NO_ERROR ) && ( err != AFPERR_UnsupportedFS ) )
{
ReportError( err );
return;
}
//
// If the drive is an NTFS/CDFS drive, then set the volume name and path
//
if ( err == NO_ERROR )
{
//
// If this is a file then we need to remove the file name from the
// path.
//
if ( fIsFile )
{
ISTR istrVolumePath( nlsVolumePath );
if ( nlsVolumePath.strrchr( &istrVolumePath, TEXT('\\') ))
{
nlsVolumePath.DelSubStr( istrVolumePath );
}
}
//
// Extract the last component of the path and use it to set the
// volume name
//
nlsVolumeName = nlsVolumePath;
ISTR istrStart( nlsVolumeName );
ISTR istrEnd( nlsVolumeName );
if ( nlsVolumeName.strrchr( &istrEnd, TEXT('\\') ))
{
nlsVolumeName.DelSubStr( istrStart, ++istrEnd );
}
if ( nlsVolumeName.QueryTextLength() <= AFP_VOLNAME_LEN )
_sleVolumeName.SetText( nlsVolumeName );
//
// Ok, if the drive is remote then we need to display the UNC path
//
NET_NAME netname( nlsVolumePath );
if ( ( err = netname.QueryError() ) != NERR_Success )
{
ReportError( err );
return;
}
BOOL fIsLocal = netname.IsLocal( &err );
if ( err != NERR_Success )
{
ReportError( err );
return;
}
if ( fIsLocal )
{
_sleVolumePath.SetText( nlsVolumePath );
}
else
{
if ( ( err = netname.QueryUNCPath( &nlsUNCPath ) ) != NERR_Success )
{
ReportError( err );
return;
}
_sleVolumePath.SetText( nlsUNCPath );
}
_pbPermissions.Enable( TRUE );
_sleVolumeName.SelectString();
SetFocusOnName();
}
}
/*******************************************************************
NAME: NEW_VOLUME_FILEMGR_DIALOG::OnCommand
SYNOPSIS: Handle the case where the user clicked the permission button
ENTRY: event - the CONTROL_EVENT that occurred
EXIT:
RETURNS:
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
BOOL NEW_VOLUME_FILEMGR_DIALOG::OnCommand( const CONTROL_EVENT &event )
{
APIERR err;
AFP_SERVER_HANDLE hServer = NULL;
if ( event.QueryCid() == IDNV_PB_PERMISSIONS )
{
AUTO_CURSOR Cursor;
//
// Get the volume path and validate it.
//
NLS_STR nlsDisplayPath;
NLS_STR nlsVolumePath;
NLS_STR nlsComputerName;
NLS_STR nlsDrive;
BOOL fOk;
if ((( err = nlsVolumePath.QueryError() ) != NERR_Success ) ||
(( err = nlsComputerName.QueryError() ) != NERR_Success ) ||
(( err = nlsDrive.QueryError() ) != NERR_Success ) ||
(( err = nlsDisplayPath.QueryError() ) != NERR_Success ) ||
(( err = _sleVolumePath.QueryText(&nlsDisplayPath))
!= NERR_Success ))
{
::MsgPopup( this, AFPERR_TO_STRINGID( err ) );
return FALSE;
}
//
// If the path is not local then we need to get the local
// path.
//
NET_NAME netname( nlsDisplayPath.QueryPch() );
if ( ( err = netname.QueryError() ) != NERR_Success )
{
::MsgPopup( this, err );
return FALSE;
}
BOOL fIsLocal = netname.IsLocal( &err );
if ( err != NERR_Success )
{
::MsgPopup( this, err );
return FALSE;
}
//
// Get the computer name for this volume
//
if ((err = netname.QueryComputerName(&nlsComputerName)) != NERR_Success)
{
if ( err == NERR_InvalidDevice )
{
err = ERROR_INVALID_DRIVE;
}
::MsgPopup( this, err );
return FALSE;
}
if ((!fIsLocal) || (fIsLocal && (netname.QueryType() == TYPE_PATH_UNC)))
{
//
// If the path is remote get the absolute path with
// the drive letter.
//
err = netname.QueryLocalPath( &nlsVolumePath );
if ( err != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return FALSE;
}
}
else
{
//
// If the path happens to be a loopback redirected drive then we
// replace
// the redirected drive with the action drive.
//
if ( (err = netname.QueryDrive( &nlsDrive )) != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return TRUE;
}
nlsVolumePath.CopyFrom( nlsDisplayPath );
if ( (err=::ConvertRedirectedDriveToLocal(
nlsComputerName,
&nlsDrive,
&nlsVolumePath ))!= NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return FALSE;
}
}
if ( ( err = ::AfpAdminConnect((LPWSTR)(nlsComputerName.QueryPch()),
&hServer ) ) != NO_ERROR )
{
::MsgPopup( this, err );
SetFocusOnPath();
return FALSE;
}
_fCommitDirInfo = TRUE;
DIRECTORY_PERMISSIONS_DLG *pdlg = new DIRECTORY_PERMISSIONS_DLG(
QueryHwnd(),
hServer,
NULL,
FALSE,
nlsVolumePath.QueryPch(),
nlsDisplayPath.QueryPch(),
FALSE,
&_nlsOwner,
&_nlsGroup,
&_dwPerms );
if ( ( pdlg == NULL )
|| (( err = pdlg->QueryError()) != NERR_Success )
|| (( err = pdlg->Process( &fOk )) != NERR_Success )
)
{
err = (pdlg == NULL ) ? ERROR_NOT_ENOUGH_MEMORY : err;
::MsgPopup( this, AFPERR_TO_STRINGID( err ) );
}
delete pdlg;
if ( ( err != NERR_Success ) || ( !fOk ) )
{
_fCommitDirInfo = FALSE;
}
if ( hServer != NULL )
{
::AfpAdminDisconnect( hServer );
}
return TRUE;
}
//
// Enable the permissions button if the path string is filled in.
//
if ( event.QueryCid() == IDNV_SLE_PATH )
{
if ( event.QueryCode() == EN_CHANGE )
{
if ( _sleVolumePath.QueryTextLength() > 0 )
{
_pbOK.MakeDefault();
_pbPermissions.Enable( TRUE );
}
else
{
_pbPermissions.Enable( FALSE );
_pbCancel.MakeDefault();
}
}
return TRUE;
}
return DIALOG_WINDOW::OnCommand( event );
}
/*******************************************************************
NAME: NEW_VOLUME_FILEMGR_DIALOG::OnOK
SYNOPSIS: Validate all the information and create the volume.
ENTRY:
EXIT:
RETURNS:
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
BOOL NEW_VOLUME_FILEMGR_DIALOG::OnOK( VOID )
{
APIERR err;
NLS_STR nlsVolumePath;
NLS_STR nlsVolumeName;
NLS_STR nlsPassword;
NLS_STR nlsPasswordConfirm;
NLS_STR nlsComputerName;
NLS_STR nlsDrive;
AFP_SERVER_HANDLE hServer = NULL;
AUTO_CURSOR Cursor;
//
// This is not a loop.
//
do {
if ( ( err = nlsComputerName.QueryError() ) != NERR_Success )
break;
if ( ( err = nlsDrive.QueryError() ) != NERR_Success )
break;
//
// Get the volume name.
//
if ( ( err = nlsVolumeName.QueryError() ) != NERR_Success )
break;
if ((err = _sleVolumeName.QueryText( &nlsVolumeName )) != NERR_Success)
break;
//
// Get the volume path.
//
if ( ( err = nlsVolumePath.QueryError() ) != NERR_Success )
break;
if (( err = _sleVolumePath.QueryText(&nlsVolumePath)) != NERR_Success)
break;
//
// Get the password if there is one.
//
if ( ( err = nlsPassword.QueryError() ) != NERR_Success )
break;
if ( ( err = _slePassword.QueryText( &nlsPassword )) != NERR_Success )
break;
//
// Get the password confirmation.
//
if ( ( err = nlsPasswordConfirm.QueryError() ) != NERR_Success )
break;
if ( ( err = _slePasswordConfirm.QueryText( &nlsPasswordConfirm ))
!= NERR_Success )
break;
}while( FALSE );
if ( err != NERR_Success )
{
::MsgPopup( this, err );
return TRUE;
}
//
// Set up the volume structure
//
AFP_VOLUME_INFO AfpVolume;
if ( nlsVolumeName.strlen() > 0 )
{
//
// Validate the volume name
//
ISTR istr( nlsVolumeName );
if ( nlsVolumeName.strchr( &istr, TEXT(':') ) )
{
::MsgPopup( this, IDS_AFPERR_InvalidVolumeName );
SetFocusOnName();
return FALSE;
}
AfpVolume.afpvol_name = (LPWSTR)(nlsVolumeName.QueryPch());
}
else
{
::MsgPopup( this, IDS_NEED_VOLUME_NAME );
SetFocusOnName();
return TRUE;
}
//
// If the path is not local then we need to get the local
// path.
//
NET_NAME netname( nlsVolumePath.QueryPch() );
if ( ( err = netname.QueryError() ) != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return TRUE;
}
BOOL fIsLocal = netname.IsLocal( &err );
if ( err != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return TRUE;
}
if ( (err = netname.QueryComputerName( &nlsComputerName )) != NERR_Success)
{
if ( err == NERR_InvalidDevice )
{
err = ERROR_INVALID_DRIVE;
}
::MsgPopup( this, err );
SetFocusOnPath();
return FALSE;
}
BOOL fDriveGreaterThan2Gig = ::IsDriveGreaterThan2Gig( (LPWSTR)(nlsVolumePath.QueryPch()),
&err );
if ( err != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return TRUE;
}
if ( (!fIsLocal) || (fIsLocal && (netname.QueryType() == TYPE_PATH_UNC)))
{
//
// If the path is remote then get the absolute path and drive letter.
//
err = netname.QueryLocalPath( &nlsVolumePath );
if ( err != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return FALSE;
}
}
else
{
//
// If the path happens to be a loopback redirected drive then we
// replace
// the redirected drive with the action drive.
//
if ( (err = netname.QueryDrive( &nlsDrive )) != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return TRUE;
}
if ( (err=::ConvertRedirectedDriveToLocal(
nlsComputerName,
&nlsDrive,
&nlsVolumePath )) != NERR_Success )
{
::MsgPopup( this, err );
SetFocusOnPath();
return FALSE;
}
}
if ( fDriveGreaterThan2Gig )
{
if ( ::MsgPopup( this,
IDS_VOLUME_TOO_BIG,
MPSEV_WARNING,
MP_YESNO,
MP_NO ) == IDNO )
{
SetFocusOnPath();
return TRUE;
}
}
AfpVolume.afpvol_path = (LPWSTR)(nlsVolumePath.QueryPch());
if ( nlsPassword.strcmp( nlsPasswordConfirm ) )
{
::MsgPopup( this, IDS_PASSWORD_MISMATCH );
SetFocusOnPasswordConfirm();
return TRUE;
}
if ( nlsPassword.strlen() > 0 )
{
AfpVolume.afpvol_password = (LPWSTR)(nlsPassword.QueryPch());
}
else
{
AfpVolume.afpvol_password = (LPWSTR)NULL;
}
AfpVolume.afpvol_props_mask = _chkReadOnly.QueryCheck()
? AFP_VOLUME_READONLY
: 0;
AfpVolume.afpvol_props_mask = _chkGuestAccess.QueryCheck()
? (AFP_VOLUME_GUESTACCESS | AfpVolume.afpvol_props_mask)
: AfpVolume.afpvol_props_mask;
AfpVolume.afpvol_max_uses = QueryUserLimit();
//
// Try to create the volume.
//
err = ::AfpAdminConnect((LPWSTR)(nlsComputerName.QueryPch()), &hServer );
if ( err == NO_ERROR )
{
err = ::AfpAdminVolumeAdd( hServer, (LPBYTE)&AfpVolume );
}
if ( err == NO_ERROR )
{
//
// If the user mucked around with the root directory's permissions
// the we have to set it.
//
if ( _fCommitDirInfo )
{
AFP_DIRECTORY_INFO AfpDirInfo;
AfpDirInfo.afpdir_path = (LPWSTR)(nlsVolumePath.QueryPch());
AfpDirInfo.afpdir_owner = (LPWSTR)(_nlsOwner.QueryPch());
AfpDirInfo.afpdir_group = (LPWSTR)(_nlsGroup.QueryPch());
AfpDirInfo.afpdir_perms = _dwPerms;
err = ::AfpAdminDirectorySetInfo( hServer,
(LPBYTE)&AfpDirInfo,
AFP_DIR_PARMNUM_ALL );
}
else
{
//
// User did not muck arount with the permissions, so we have
// to get and reset the current permissions. This is requred
// to remove everyone as the owner.
//
PAFP_DIRECTORY_INFO pAfpDirInfo;
err = ::AfpAdminDirectoryGetInfo(hServer,
(LPWSTR)(nlsVolumePath.QueryPch()),
(LPBYTE*)&pAfpDirInfo );
if ( err == NO_ERROR )
{
DWORD dwParmNum = AFP_DIR_PARMNUM_PERMS;
pAfpDirInfo->afpdir_path = (LPWSTR)(nlsVolumePath.QueryPch());
if ( pAfpDirInfo->afpdir_owner != (LPWSTR)NULL )
{
dwParmNum |= AFP_DIR_PARMNUM_OWNER;
}
if ( pAfpDirInfo->afpdir_group != (LPWSTR)NULL )
{
dwParmNum |= AFP_DIR_PARMNUM_GROUP;
}
err = ::AfpAdminDirectorySetInfo( hServer,
(LPBYTE)pAfpDirInfo,
dwParmNum );
::AfpAdminBufferFree( pAfpDirInfo );
}
}
switch( err )
{
case NO_ERROR:
break;
case AFPERR_SecurityNotSupported:
err = NO_ERROR;
break;
case AFPERR_NoSuchUser:
case AFPERR_NoSuchGroup:
case AFPERR_NoSuchUserGroup:
case ERROR_NONE_MAPPED:
err = NO_ERROR;
::MsgPopup( this, IDS_INVALID_DIR_ACCOUNT, MPSEV_INFO );
break;
case AFPERR_UnsupportedFS:
//
// Ignore this error
//
err = NO_ERROR;
break;
default:
::AfpAdminVolumeDelete( hServer,
(LPWSTR)(nlsVolumeName.QueryPch()));
break;
}
}
if ( hServer != NULL )
{
::AfpAdminDisconnect( hServer );
}
if ( err == NO_ERROR )
{
Dismiss( TRUE );
}
else
{
::MsgPopup( this, AFPERR_TO_STRINGID( err ) );
SetFocusOnPath();
}
return TRUE;
}
/*******************************************************************
NAME: NEW_VOLUME_FILEGMR_DIALOG::QueryUserLimit
SYNOPSIS: Get the user limit from the magic group
ENTRY:
EXIT:
RETURNS: The user limit stored in the user limit magic group
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
DWORD NEW_VOLUME_FILEMGR_DIALOG::QueryUserLimit( VOID ) const
{
switch ( _mgrpUserLimit.QuerySelection() )
{
case IDNV_RB_UNLIMITED:
return( AFP_VOLUME_UNLIMITED_USES );
case IDNV_RB_USERS:
return( _spsleUsers.QueryValue() );
default:
//
// Should never get here but in case we do, return unlimited
//
return( AFP_VOLUME_UNLIMITED_USES );
}
}
/*******************************************************************
NAME: NEW_VOLUME_FILEMGR_DIALOG::ValidateVolumePath
SYNOPSIS: Validates the volume path. It makes sure that the
the path syntax is valid and the volume of the drive
is either NTFS or CDFS.
ENTRY: pszPath - Pointer to the volume path
EXIT:
RETURNS: Any error encountered. (Path syntax is invalid etc)
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
DWORD NEW_VOLUME_FILEMGR_DIALOG::ValidateVolumePath( const WCHAR * pszPath )
{
WCHAR wchDrive[5];
DWORD dwMaxCompSize;
DWORD dwFlags;
WCHAR wchFileSystem[10];
DWORD err = NO_ERROR;
NET_NAME Path( pszPath );
if ( ( err = Path.QueryError() ) != NERR_Success )
{
return err;
}
// Get the drive letter, : and backslash
//
::ZeroMemory( wchDrive, sizeof( wchDrive ) );
::wcsncpy( wchDrive, pszPath, 3 );
if ( !( ::GetVolumeInformation( (LPWSTR)wchDrive,
NULL,
0,
NULL,
&dwMaxCompSize,
&dwFlags,
(LPWSTR)wchFileSystem,
sizeof( wchFileSystem ) ) ) ){
return GetLastError();
}
if ( ( ::_wcsicmp( wchFileSystem, SZ("NTFS") ) == 0 ) ||
( ::_wcsicmp( wchFileSystem, SZ("CDFS") ) == 0 ) ||
( ::_wcsicmp( wchFileSystem, SZ("AHFS") ) == 0 ) )
return( NO_ERROR );
else
return( (DWORD)AFPERR_UnsupportedFS );
}
/*******************************************************************
NAME: NEW_VOLUME_FILEMGR_DIALOG::QueryHelpContext
SYNOPSIS: Query the help context of the dialog
ENTRY:
EXIT:
RETURNS: Return the help context of the dialog
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
ULONG NEW_VOLUME_FILEMGR_DIALOG::QueryHelpContext( VOID )
{
return HC_NEW_VOLUME_FILEMGR_DIALOG;
}
/*******************************************************************
NAME: ::ConvertRedirectedDriveToLocal
SYNOPSIS: Determines if a drive is a loopback redirected drive or
not. If it is, then the redirected drive is changed to
the local drive.
ENTRY:
EXIT:
RETURNS: NERR_Success - Success
Non zero return codes - failure
NOTES:
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
APIERR ConvertRedirectedDriveToLocal( NLS_STR nlsServer,
NLS_STR * pnlsDrive,
NLS_STR * pnlsPath )
{
PBYTE pBuf;
APIERR err;
NLS_STR nlsDrive;
if ( ( err = nlsDrive.QueryError() ) != NERR_Success )
{
return err;
}
err = ::MNetUseGetInfo(nlsServer.QueryPch(),pnlsDrive->QueryPch(),1,&pBuf);
if ( err != NERR_Success )
{
if ( err == NERR_UseNotFound )
return NERR_Success;
else
return err;
}
NET_NAME netname( ((PUSE_INFO_0)pBuf)->ui0_remote );
::MNetApiBufferFree( &pBuf );
if ( ( err = netname.QueryError() ) != NERR_Success )
{
return err;
}
if ( ( err = netname.QueryLocalPath( pnlsPath ) ) != NERR_Success )
{
return err;
}
return( NERR_Success );
}
/*******************************************************************
NAME: ::IsDriveGreaterThan2Gig
SYNOPSIS: Determines if the disk is bigger than 2Gig. If it, return
TRUE so that a warning can be displayed to the user
RETURNS: TRUE if disk is larger than 2Gig
FALSE otherwise
HISTORY:
NarenG 11/18/92 Modified for AFPMGR
********************************************************************/
BOOL IsDriveGreaterThan2Gig( LPWSTR lpwsVolPath,
APIERR * perr )
{
DWORD SectorsPerCluster;
DWORD BytesPerSector;
DWORD NumberOfFreeClusters;
DWORD TotalNumberOfClusters;
LARGE_INTEGER DriveSize;
LARGE_INTEGER TwoGig = { MAXLONG, 0 };
LPWSTR lpwsPath;
LPWSTR lpwsTmp;
//
// If this drive volume is greater than 2G then we print warning
//
*perr = NERR_Success;
lpwsPath = (LPWSTR)::LocalAlloc( LPTR, (::wcslen(lpwsVolPath) + 2)*sizeof(WCHAR));
if (lpwsPath == NULL)
{
*perr = ERROR_NOT_ENOUGH_MEMORY;
return( TRUE );
}
::wcscpy(lpwsPath, lpwsVolPath);
// if this is a unc path of the type \\foo\bar\path\name then we must
// generate a string that is "\\foo\bar\"
if ( lpwsPath[0] == TEXT('\\') && lpwsPath[1] == TEXT('\\'))
{
lpwsTmp = lpwsPath;
lpwsTmp++;
lpwsTmp++; // point to f in \\foo\bar\path\name
lpwsTmp = ::wcschr(lpwsTmp, TEXT('\\'));
lpwsTmp++; // point to b in \\foo\bar\path\name
lpwsTmp = ::wcschr(lpwsTmp, TEXT('\\'));
// if the path is \\foo\bar\path\name then
if (lpwsTmp != NULL)
{
lpwsTmp++;
}
// else if the path is just \\foo\bar then
else
{
lpwsTmp = lpwsPath + ::wcslen(lpwsPath);
if ( *(lpwsTmp-1) != TEXT('\\'))
{
*lpwsTmp = TEXT('\\');
lpwsTmp++;
}
}
*(lpwsTmp) = 0;
}
// else if this is a local path of the type c:\foo\bar\path\name then
// we must generate a string that is "c:\"
else if (lpwsPath[1] == TEXT(':'))
{
lpwsPath[2] = TEXT('\\');
lpwsPath[3] = 0;
}
// huh?? how did this happen?
else
{
*perr = ERROR_INVALID_DRIVE;
::LocalFree(lpwsPath);
return( TRUE );
}
if ( !::GetDiskFreeSpace( lpwsPath,
&SectorsPerCluster,
&BytesPerSector,
&NumberOfFreeClusters,
&TotalNumberOfClusters
))
{
::LocalFree(lpwsPath);
// call failed: it's not fatal, treat it like disk size is ok
return FALSE;
}
::LocalFree(lpwsPath);
DriveSize = RtlEnlargedIntegerMultiply( SectorsPerCluster * BytesPerSector,
TotalNumberOfClusters ) ;
if ( DriveSize.QuadPart > TwoGig.QuadPart )
{
return TRUE;
}
else
{
return FALSE;
}
}