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/ds/nw/convert/nwconv/ntnetapi.c

3644 lines
80 KiB
Raw Blame History

/*++
Copyright (c) 1993-1995 Microsoft Corporation
Module Name:
NTNetaAPI.c
Abstract:
Author:
Arthur Hanson (arth) 16-Jun-1994
Revision History:
--*/
#include "globals.h"
#include <ntlsa.h>
#include <ntsam.h>
#include <ntddnwfs.h>
#include <align.h>
#include <math.h>
#include "convapi.h"
#include "ntnetapi.h"
#include "nwnetapi.h"
#include "loghours.h"
#include "usrprop.h"
#include "crypt.h"
// #include <nwstruct.h>
#include <nwconv.h>
#include "fpnwapi.h"
#ifdef DEBUG
int ErrorBoxRetry(LPTSTR szFormat, ...);
#endif
void ErrorIt(LPTSTR szFormat, ...);
NTSTATUS ACEAdd( PSECURITY_DESCRIPTOR pSD, PSID pSid, ACCESS_MASK AccessMask, ULONG AceFlags, PSECURITY_DESCRIPTOR *ppNewSD );
static LPTSTR LocalName = NULL;
// +3 for leading slashes and ending NULL
static TCHAR CachedServer[MAX_SERVER_NAME_LEN+3];
static BOOL LocalMachine = FALSE;
// keep this around so we don't have to keep re-do query
static LPSERVER_INFO_101 ServInfo = NULL;
// #define TYPE_DOMAIN SV_TYPE_DOMAIN_CTRL | SV_TYPE_DOMAIN_BAKCTRL | SV_TYPE_DOMAIN_MEMBER
#define TYPE_DOMAIN SV_TYPE_DOMAIN_CTRL | SV_TYPE_DOMAIN_BAKCTRL
static SAM_HANDLE SAMHandle = (SAM_HANDLE) 0;
static SAM_HANDLE DomainHandle = (SAM_HANDLE) 0;
static PSID DomainID;
static WCHAR UserParms[1024];
#define NCP_LSA_SECRET_KEY L"G$MNSEncryptionKey"
#define NCP_LSA_SECRET_LENGTH USER_SESSION_KEY_LENGTH
static char Secret[USER_SESSION_KEY_LENGTH];
static HANDLE FPNWLib = NULL;
static DWORD (FAR * NWVolumeAdd) (LPWSTR, DWORD, PNWVOLUMEINFO) = NULL;
//
// This bit is set when the server is running on a NTAS machine or
// the object is from a trusted domain. NWConv is always on NTAS
//
#define BINDLIB_REMOTE_DOMAIN_BIAS 0x10000000
//
// misc macros that are useful
//
#define SWAPWORD(w) ((WORD)((w & 0xFF) << 8)|(WORD)(w >> 8))
#define SWAPLONG(l) MAKELONG(SWAPWORD(HIWORD(l)),SWAPWORD(LOWORD(l)))
typedef struct _NT_CONN_BUFFER {
struct _NT_CONN_BUFFER *next;
struct _NT_CONN_BUFFER *prev;
LPTSTR Name;
} NT_CONN_BUFFER;
static NT_CONN_BUFFER *NTConnListStart = NULL;
static NT_CONN_BUFFER *NTConnListEnd = NULL;
HANDLE FpnwHandle = NULL;
static FARPROC pFpnwVolumeEnum = NULL;
static FARPROC pFpnwApiBufferFree = NULL;
/////////////////////////////////////////////////////////////////////////
LPSTR
FPNWSecretGet(
LPTSTR ServerName
)
/*++
Routine Description:
Checks the given machine for the FPNW secret.
Arguments:
Return Value:
--*/
{
SECURITY_QUALITY_OF_SERVICE QualityOfService;
OBJECT_ATTRIBUTES ObjectAttributes;
LSA_HANDLE PolicyHandle;
LSA_HANDLE SecretHandle;
NTSTATUS Status;
UNICODE_STRING UnicodeSecretName;
PUNICODE_STRING punicodeCurrentValue;
PUSER_INFO_2 pUserInfo = NULL;
static TCHAR LocServer[MAX_SERVER_NAME_LEN+3];
UNICODE_STRING UnicodeServerName;
BOOL ret = TRUE;
memset(Secret, 0, USER_SESSION_KEY_LENGTH);
wsprintf(LocServer, TEXT("\\\\%s"), ServerName);
// Verify & init secret name.
RtlInitUnicodeString( &UnicodeSecretName, NCP_LSA_SECRET_KEY );
RtlInitUnicodeString( &UnicodeServerName, LocServer);
// Prepare to open the policy object.
QualityOfService.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
QualityOfService.ImpersonationLevel = SecurityImpersonation;
QualityOfService.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
QualityOfService.EffectiveOnly = FALSE;
InitializeObjectAttributes( &ObjectAttributes, NULL, 0L, NULL, NULL );
ObjectAttributes.SecurityQualityOfService = &QualityOfService;
// Open a handle to the target machine's LSA policy.
Status = LsaOpenPolicy( &UnicodeServerName, &ObjectAttributes, 0, &PolicyHandle );
if( !NT_SUCCESS( Status ) ) {
ret = FALSE;
goto FatalExit0;
}
// Open the secret object.
Status = LsaOpenSecret( PolicyHandle, &UnicodeSecretName, SECRET_QUERY_VALUE, &SecretHandle );
if( !NT_SUCCESS( Status ) ) {
ret = FALSE;
goto FatalExit1;
}
// Query the secret.
Status = LsaQuerySecret( SecretHandle, &punicodeCurrentValue, NULL, NULL, NULL );
if( !NT_SUCCESS( Status ) ) {
ret = FALSE;
goto FatalExit2;
}
if (punicodeCurrentValue != NULL) {
memcpy(Secret, punicodeCurrentValue->Buffer, USER_SESSION_KEY_LENGTH);
LsaFreeMemory( (PVOID)punicodeCurrentValue );
}
FatalExit2:
LsaClose( SecretHandle );
FatalExit1:
LsaClose( PolicyHandle );
FatalExit0:
if (ret)
return Secret;
else
return NULL;
} // FPNWSecretGet
/////////////////////////////////////////////////////////////////////////
NTSTATUS
SetGraceLoginAllowed(
USHORT ushGraceLoginAllowed
)
/*++
Routine Description:
Store Grace Login Allowed in UserParms.
Arguments:
Return Value:
--*/
{
NTSTATUS err = NERR_Success;
USHORT ushTemp = ushGraceLoginAllowed;
UNICODE_STRING uniGraceLoginAllowed;
LPWSTR lpNewUserParms = NULL;
BOOL fUpdate;
uniGraceLoginAllowed.Buffer = &ushTemp;
uniGraceLoginAllowed.Length = 2;
uniGraceLoginAllowed.MaximumLength = 2;
err = SetUserProperty (UserParms, GRACELOGINALLOWED, uniGraceLoginAllowed, USER_PROPERTY_TYPE_ITEM, &lpNewUserParms, &fUpdate);
if ((err == NERR_Success) && (lpNewUserParms != NULL)) {
if (fUpdate)
lstrcpyW(UserParms, lpNewUserParms);
LocalFree(lpNewUserParms);
}
return err;
} // SetGraceLoginAllowed
/////////////////////////////////////////////////////////////////////////
NTSTATUS
SetGraceLoginRemainingTimes(
USHORT ushGraceLoginRemainingTimes
)
/*++
Routine Description:
Store Grace Login Remaining Times in UserParms. if ushGraceLogin is 0,
"GraceLogin" field will be deleted from UserParms.
Arguments:
Return Value:
--*/
{
NTSTATUS err = NERR_Success;
USHORT ushTemp = ushGraceLoginRemainingTimes;
UNICODE_STRING uniGraceLoginRemainingTimes;
LPWSTR lpNewUserParms = NULL;
BOOL fUpdate;
uniGraceLoginRemainingTimes.Buffer = &ushTemp;
uniGraceLoginRemainingTimes.Length = 2;
uniGraceLoginRemainingTimes.MaximumLength = 2;
err = SetUserProperty (UserParms, GRACELOGINREMAINING, uniGraceLoginRemainingTimes, USER_PROPERTY_TYPE_ITEM, &lpNewUserParms, &fUpdate);
if ((err == NERR_Success) && (lpNewUserParms != NULL)) {
if (fUpdate)
lstrcpyW(UserParms, lpNewUserParms);
LocalFree(lpNewUserParms);
}
return err;
} // SetGraceLoginRemainingTimes
/////////////////////////////////////////////////////////////////////////
NTSTATUS
SetMaxConnections(
USHORT ushMaxConnections
)
/*++
Routine Description:
Store Maximum Concurret Connections in UserParms. If ushMaxConnections
is 0xffff or 0, "MaxConnections" field will be deleted from UserParms,
otherwise the value is stored.
Arguments:
Return Value:
--*/
{
NTSTATUS err = NERR_Success;
USHORT ushTemp = ushMaxConnections;
UNICODE_STRING uniMaxConnections;
LPWSTR lpNewUserParms = NULL;
BOOL fUpdate;
uniMaxConnections.Buffer = &ushMaxConnections;
uniMaxConnections.Length = 2;
uniMaxConnections.MaximumLength = 2;
err = SetUserProperty (UserParms, MAXCONNECTIONS, uniMaxConnections, USER_PROPERTY_TYPE_ITEM, &lpNewUserParms, &fUpdate);
if ((err == NERR_Success) && (lpNewUserParms != NULL)) {
if (fUpdate)
lstrcpyW(UserParms, lpNewUserParms);
LocalFree(lpNewUserParms);
}
return err;
} // SetMaxConnections
/////////////////////////////////////////////////////////////////////////
NTSTATUS
SetNWPasswordAge(
BOOL fExpired
)
/*++
Routine Description:
If fExpired is TRUE, set the NWPasswordSet field to be all fs.
otherwise set it to be the current time.
Arguments:
Return Value:
--*/
{
NTSTATUS err = NERR_Success;
LARGE_INTEGER currentTime;
LPWSTR lpNewUserParms = NULL;
UNICODE_STRING uniPasswordAge;
BOOL fUpdate;
if (fExpired) {
currentTime.HighPart = 0xffffffff;
currentTime.LowPart = 0xffffffff;
} else
NtQuerySystemTime (&currentTime);
uniPasswordAge.Buffer = (PWCHAR) &currentTime;
uniPasswordAge.Length = sizeof (LARGE_INTEGER);
uniPasswordAge.MaximumLength = sizeof (LARGE_INTEGER);
err = SetUserProperty (UserParms, NWTIMEPASSWORDSET, uniPasswordAge, USER_PROPERTY_TYPE_ITEM, &lpNewUserParms, &fUpdate);
if ((err == NERR_Success) &&(lpNewUserParms != NULL)) {
if (fUpdate)
lstrcpyW(UserParms, lpNewUserParms);
LocalFree(lpNewUserParms);
}
return err;
} // SetNWPasswordAge
/////////////////////////////////////////////////////////////////////////
NTSTATUS
SetNWPassword(
DWORD dwUserId,
const TCHAR *pchNWPassword,
BOOL ForcePasswordChange
)
/*++
Routine Description:
Set "NWPassword" field is fIsNetWareUser is TRUE, Otherwise, delete
the field from UserParms.
Arguments:
Return Value:
--*/
{
NTSTATUS err;
TCHAR pchEncryptedNWPassword[NWENCRYPTEDPASSWORDLENGTH + 1];
LPWSTR lpNewUserParms = NULL;
BOOL fUpdate;
UNICODE_STRING uniPassword;
#ifdef DEBUG
dprintf(TEXT("Set NetWare password: [%s]\r\n"), pchNWPassword);
#endif
do {
// Now munge the UserID to the format required by ReturnNetwareForm...
dwUserId |= BINDLIB_REMOTE_DOMAIN_BIAS;
err = ReturnNetwareForm( Secret, dwUserId, pchNWPassword, (UCHAR *) pchEncryptedNWPassword );
if ( err != NERR_Success )
break;
uniPassword.Buffer = pchEncryptedNWPassword;
uniPassword.Length = NWENCRYPTEDPASSWORDLENGTH * sizeof (WCHAR);
uniPassword.MaximumLength = NWENCRYPTEDPASSWORDLENGTH * sizeof (WCHAR);
err = SetUserProperty (UserParms, NWPASSWORD, uniPassword, USER_PROPERTY_TYPE_ITEM, &lpNewUserParms, &fUpdate);
if ((err == NERR_Success) && (lpNewUserParms != NULL)) {
if (fUpdate)
lstrcpyW(UserParms, lpNewUserParms);
LocalFree(lpNewUserParms);
if ((err = SetNWPasswordAge (ForcePasswordChange)) != NERR_Success )
break;
}
} while (FALSE);
return err;
} // SetNWPassword
/////////////////////////////////////////////////////////////////////////
NTSTATUS
SetNWWorkstations(
const TCHAR * pchNWWorkstations
)
/*++
Routine Description:
Store NetWare allowed workstation addresses to UserParms. If
pchNWWorkstations is NULL, this function will delete "NWLgonFrom"
field from UserParms.
Arguments:
Return Value:
--*/
{
NTSTATUS err = NERR_Success;
UNICODE_STRING uniNWWorkstations;
CHAR * pchTemp = NULL;
LPWSTR lpNewUserParms = NULL;
BOOL fUpdate;
if (pchNWWorkstations == NULL) {
uniNWWorkstations.Buffer = NULL;
uniNWWorkstations.Length = 0;
uniNWWorkstations.MaximumLength = 0;
} else {
BOOL fDummy;
INT nStringLength = lstrlen(pchNWWorkstations) + 1;
pchTemp = (CHAR *) LocalAlloc (LPTR, nStringLength);
if ( pchTemp == NULL )
err = ERROR_NOT_ENOUGH_MEMORY;
if ( err == NERR_Success && !WideCharToMultiByte (CP_ACP, 0, pchNWWorkstations, nStringLength, pchTemp, nStringLength, NULL, &fDummy))
err = GetLastError();
if ( err == NERR_Success ) {
uniNWWorkstations.Buffer = (WCHAR *) pchTemp;
uniNWWorkstations.Length = (USHORT) nStringLength;
uniNWWorkstations.MaximumLength = (USHORT) nStringLength;
}
}
err = err? err: SetUserProperty (UserParms, NWLOGONFROM, uniNWWorkstations, USER_PROPERTY_TYPE_ITEM, &lpNewUserParms, &fUpdate);
if ((err == NERR_Success) && (lpNewUserParms != NULL)) {
if (fUpdate)
lstrcpyW(UserParms, lpNewUserParms);
LocalFree(lpNewUserParms);
}
if (pchTemp != NULL)
LocalFree (pchTemp);
return err;
} // SetNWWorkstations
/////////////////////////////////////////////////////////////////////////
NTSTATUS SetNWHomeDir(
const TCHAR * pchNWHomeDir
)
/*++
Routine Description:
Store NetWare Home Directory to UserParms If pchNWWorkstations is NULL,
this function will delete "NWLgonFrom" field from UserParms.
Arguments:
Return Value:
--*/
{
NTSTATUS err = NERR_Success;
UNICODE_STRING uniNWHomeDir;
CHAR * pchTemp = NULL;
LPWSTR lpNewUserParms = NULL;
BOOL fUpdate;
if (pchNWHomeDir == NULL) {
uniNWHomeDir.Buffer = NULL;
uniNWHomeDir.Length = 0;
uniNWHomeDir.MaximumLength = 0;
} else {
BOOL fDummy;
INT nStringLength = lstrlen(pchNWHomeDir) + 1;
pchTemp = (CHAR *) LocalAlloc (LPTR, nStringLength);
if ( pchTemp == NULL )
err = ERROR_NOT_ENOUGH_MEMORY;
if ( err == NERR_Success && !WideCharToMultiByte (CP_ACP, 0, pchNWHomeDir, nStringLength, pchTemp, nStringLength, NULL, &fDummy))
err = GetLastError();
if ( err == NERR_Success ) {
uniNWHomeDir.Buffer = (WCHAR *) pchTemp;
uniNWHomeDir.Length = (USHORT) nStringLength;
uniNWHomeDir.MaximumLength = (USHORT) nStringLength;
}
}
err = err? err : SetUserProperty (UserParms, NWHOMEDIR, uniNWHomeDir, USER_PROPERTY_TYPE_ITEM, &lpNewUserParms, &fUpdate);
if ((err == NERR_Success) && (lpNewUserParms != NULL)) {
if (fUpdate)
lstrcpyW(UserParms, lpNewUserParms);
LocalFree(lpNewUserParms);
}
if (pchTemp != NULL)
LocalFree (pchTemp);
return err;
} // SetNWHomeDir
/////////////////////////////////////////////////////////////////////////
DWORD
NTObjectIDGet(
LPTSTR ObjectName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
UNICODE_STRING UniNewObjectName;
PULONG pRids = NULL;
PSID_NAME_USE pSidNameUse = NULL;
ULONG ObjectID = 0;
RtlInitUnicodeString(&UniNewObjectName, ObjectName);
status = SamLookupNamesInDomain(DomainHandle,
1,
&UniNewObjectName,
&pRids,
&pSidNameUse);
if ((status == STATUS_SUCCESS) && (pRids != NULL) && (pSidNameUse != NULL)) {
// Found the name - so copy and free SAM garbage
ObjectID = pRids[0];
ObjectID |= BINDLIB_REMOTE_DOMAIN_BIAS;
SamFreeMemory(pRids);
SamFreeMemory(pSidNameUse);
}
return ObjectID;
} // NTObjectIDGet
/////////////////////////////////////////////////////////////////////////
DWORD
NTSAMParmsSet(
LPTSTR ObjectName,
FPNW_INFO fpnw,
LPTSTR Password,
BOOL ForcePasswordChange
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
UNICODE_STRING UniNewObjectName;
PULONG pRids = NULL;
PSID_NAME_USE pSidNameUse = NULL;
ULONG ObjectID;
SID_NAME_USE SidNameUse;
SAM_HANDLE Handle = (SAM_HANDLE) 0;
PUSER_PARAMETERS_INFORMATION UserParmInfo = NULL;
USER_PARAMETERS_INFORMATION NewUserParmInfo;
LPWSTR lpNewUserParms = NULL;
RtlInitUnicodeString(&UniNewObjectName, ObjectName);
status = SamLookupNamesInDomain(DomainHandle,
1,
&UniNewObjectName,
&pRids,
&pSidNameUse);
if ((status == STATUS_SUCCESS) && (pRids != NULL) && (pSidNameUse != NULL)) {
// Found the name - so copy and free SAM garbage
ObjectID = pRids[0];
SidNameUse = pSidNameUse[0];
SamFreeMemory(pRids);
SamFreeMemory(pSidNameUse);
status = SamOpenUser(DomainHandle,
STANDARD_RIGHTS_READ |
STANDARD_RIGHTS_WRITE |
USER_ALL_ACCESS,
ObjectID,
&Handle);
// Now get the user parms
if (status == STATUS_SUCCESS)
status = SamQueryInformationUser(Handle, UserParametersInformation, (PVOID *) &UserParmInfo);
memset(UserParms, 0, sizeof(UserParms));
if ((status == STATUS_SUCCESS) && (UserParmInfo != NULL)) {
memcpy(UserParms, UserParmInfo->Parameters.Buffer, UserParmInfo->Parameters.Length * sizeof(WCHAR));
SamFreeMemory(UserParmInfo);
if (
((status = SetNWPassword (ObjectID, Password, ForcePasswordChange)) == NERR_Success) &&
((status = SetMaxConnections (fpnw.MaxConnections)) == NERR_Success) &&
((status = SetGraceLoginAllowed (fpnw.GraceLoginAllowed)) == NERR_Success) &&
((status = SetGraceLoginRemainingTimes (fpnw.GraceLoginRemaining)) == NERR_Success) &&
((status = SetNWWorkstations (fpnw.LoginFrom)) == NERR_Success) &&
((status = SetNWHomeDir (fpnw.HomeDir)) == NERR_Success) )
{
RtlInitUnicodeString(&NewUserParmInfo.Parameters, UserParms);
status = SamSetInformationUser(Handle, UserParametersInformation, (PVOID) &NewUserParmInfo);
}
}
}
if (Handle != (SAM_HANDLE) 0)
SamCloseHandle(Handle);
return 0;
} // NTSAMParmsSet
/////////////////////////////////////////////////////////////////////////
DWORD
NTSAMConnect(
LPTSTR ServerName,
LPTSTR DomainName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
OBJECT_ATTRIBUTES object_attrib;
UNICODE_STRING UniDomainName;
UNICODE_STRING UniServerName;
//
// Do all the garbage for connecting to SAM
//
RtlInitUnicodeString(&UniServerName, ServerName);
RtlInitUnicodeString(&UniDomainName, DomainName);
InitializeObjectAttributes(&object_attrib, NULL, 0, NULL, NULL);
status = SamConnect(&UniServerName, &SAMHandle, SAM_SERVER_ALL_ACCESS, &object_attrib);
if (status == STATUS_SUCCESS)
status = SamLookupDomainInSamServer(SAMHandle, &UniDomainName, &DomainID);
if (status == STATUS_SUCCESS)
status = SamOpenDomain(SAMHandle, DOMAIN_ALL_ACCESS, DomainID, &DomainHandle);
FPNWSecretGet(ServerName);
return (DWORD) status;
} // NTSAMConnect
/////////////////////////////////////////////////////////////////////////
VOID
NTSAMClose()
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
if (DomainHandle != (SAM_HANDLE) 0)
SamCloseHandle(DomainHandle);
if (DomainID != (PSID) 0)
SamFreeMemory(DomainID);
if (SAMHandle != (SAM_HANDLE) 0)
SamCloseHandle(SAMHandle);
SAMHandle = (SAM_HANDLE) 0;
DomainHandle = (SAM_HANDLE) 0;
DomainID = (PSID) 0;
} // NTSAMClose
/////////////////////////////////////////////////////////////////////////
DWORD
NTServerSet(
LPTSTR ServerName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
// Fixup the destination server name
lstrcpy(CachedServer, TEXT("\\\\"));
lstrcat(CachedServer, ServerName);
if (!LocalName)
GetLocalName(&LocalName);
if (lstrcmpi(ServerName, LocalName) == 0)
LocalMachine = TRUE;
else
LocalMachine = FALSE;
if (FpnwHandle == NULL)
FpnwHandle = LoadLibrary(TEXT("FPNWCLNT.DLL"));
if ((FpnwHandle != NULL) && (pFpnwVolumeEnum == NULL)) {
pFpnwVolumeEnum = GetProcAddress(FpnwHandle, ("FpnwVolumeEnum"));
pFpnwApiBufferFree = GetProcAddress(FpnwHandle, ("FpnwApiBufferFree"));
}
return (0);
} // NTServerSet
/////////////////////////////////////////////////////////////////////////
DWORD
NTServerFree()
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LocalMachine = FALSE;
lstrcpy(CachedServer, TEXT(""));
return (0);
} // NTServerFree
/////////////////////////////////////////////////////////////////////////
DWORD
FPNWShareAdd(
LPTSTR ShareName,
LPTSTR Path
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NET_API_STATUS Status = 0;
NWVOLUMEINFO NWVol;
if (FPNWLib == NULL)
FPNWLib = LoadLibrary(TEXT("FPNWCLNT.DLL"));
if (FPNWLib == NULL)
return 1;
if (NWVolumeAdd == NULL)
NWVolumeAdd = (DWORD (FAR * ) (LPWSTR, DWORD, PNWVOLUMEINFO)) GetProcAddress(FPNWLib, "NwVolumeAdd");
NWVol.lpVolumeName = AllocMemory((lstrlen(ShareName) + 1) * sizeof(TCHAR));
NWVol.lpPath = AllocMemory((lstrlen(Path) + 1) * sizeof(TCHAR));
if ((NWVol.lpVolumeName == NULL) || (NWVol.lpPath == NULL))
return 1;
lstrcpy(NWVol.lpVolumeName, ShareName);
NWVol.dwType = NWVOL_TYPE_DISKTREE;
NWVol.dwMaxUses = NWVOL_MAX_USES_UNLIMITED;
NWVol.dwCurrentUses = 0;
lstrcpy(NWVol.lpPath, Path);
if (LocalMachine)
Status = NWVolumeAdd(NULL, 1, &NWVol);
else
Status = NWVolumeAdd(CachedServer, 1, &NWVol);
return Status;
} // FPNWShareAdd
/////////////////////////////////////////////////////////////////////////
DWORD
NTShareAdd(
LPTSTR ShareName,
LPTSTR Path
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NET_API_STATUS Status = 0;
SHARE_INFO_2 shi2;
DWORD parmerr;
memset(&shi2, 0, sizeof(SHARE_INFO_2));
shi2.shi2_netname = ShareName;
shi2.shi2_type = STYPE_DISKTREE;
shi2.shi2_max_uses = (DWORD) 0xffffffff;
shi2.shi2_path = Path;
if (LocalMachine)
Status = NetShareAdd(NULL, 2, (LPBYTE) &shi2, &parmerr);
else
Status = NetShareAdd(CachedServer, 2, (LPBYTE) &shi2, &parmerr);
return Status;
} // NTShareAdd
/////////////////////////////////////////////////////////////////////////
DWORD
NTUsersEnum(
USER_LIST **lpUserList
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPUSER_INFO_0 buffer = NULL;
NET_API_STATUS Status = 0;
DWORD prefmaxlength = 0xffffffff;
DWORD totalentries = 0;
DWORD entriesread = 0;
DWORD resumehandle = 0;
DWORD i;
USER_LIST *UserList = NULL;
USER_BUFFER *UserBuffer = NULL;
if (LocalMachine)
Status = NetUserEnum(NULL, 0, 0, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, &resumehandle);
else
Status = NetUserEnum(CachedServer, 0, 0, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, &resumehandle);
if (Status == NO_ERROR) {
UserList = AllocMemory(sizeof(USER_LIST) + (sizeof(USER_BUFFER) * entriesread));
if (!UserList) {
Status = ERROR_NOT_ENOUGH_MEMORY;
} else {
UserBuffer = UserList->UserBuffer;
for (i = 0; i < entriesread; i++) {
lstrcpy(UserBuffer[i].Name, buffer[i].usri0_name);
lstrcpy(UserBuffer[i].NewName, buffer[i].usri0_name);
}
qsort((void *) UserBuffer, (size_t) entriesread, sizeof(USER_BUFFER), UserListCompare);
}
}
if (buffer != NULL)
NetApiBufferFree((LPVOID) buffer);
if (UserList != NULL)
UserList->Count = entriesread;
*lpUserList = UserList;
return Status;
} // NTUsersEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NTGroupsEnum(
GROUP_LIST **lpGroupList
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPGROUP_INFO_0 buffer = NULL;
NET_API_STATUS Status = 0;
DWORD prefmaxlength = 0xffffffff;
DWORD totalentries = 0;
DWORD entriesread = 0;
DWORD_PTR resumehandle = 0;
DWORD i;
GROUP_LIST *GroupList = NULL;
GROUP_BUFFER *GroupBuffer = NULL;
if (LocalMachine)
Status = NetGroupEnum(NULL, 0, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, &resumehandle);
else
Status = NetGroupEnum(CachedServer, 0, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, &resumehandle);
if (Status == NO_ERROR) {
GroupList = AllocMemory(sizeof(GROUP_LIST) + (sizeof(GROUP_BUFFER) * entriesread));
if (!GroupList) {
Status = ERROR_NOT_ENOUGH_MEMORY;
} else {
GroupBuffer = GroupList->GroupBuffer;
for (i = 0; i < entriesread; i++) {
lstrcpy(GroupBuffer[i].Name, buffer[i].grpi0_name);
lstrcpy(GroupBuffer[i].NewName, buffer[i].grpi0_name);
}
}
}
if (buffer != NULL)
NetApiBufferFree((LPVOID) buffer);
if (GroupList != NULL)
GroupList->Count = entriesread;
*lpGroupList = GroupList;
return Status;
} // NTGroupsEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NTDomainEnum(
SERVER_BROWSE_LIST **lpServList
)
/*++
Routine Description:
Enumerates all NT servers in a given domain.
Arguments:
Return Value:
--*/
{
LPSERVER_INFO_101 buffer = NULL;
NET_API_STATUS Status = 0;
DWORD prefmaxlength = 0xffffffff;
DWORD totalentries = 0;
DWORD entriesread = 0;
DWORD resumehandle = 0;
DWORD i;
BOOL Container = FALSE;
SERVER_BROWSE_LIST *ServList = NULL;
SERVER_BROWSE_BUFFER *SList;
Status = NetServerEnum(NULL, 101, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, SV_TYPE_DOMAIN_ENUM, NULL, &resumehandle);
if (Status == NO_ERROR) {
ServList = AllocMemory(sizeof(SERVER_BROWSE_LIST) + (sizeof(SERVER_BROWSE_BUFFER) * entriesread));
if (!ServList) {
Status = ERROR_NOT_ENOUGH_MEMORY;
} else {
ServList->Count = entriesread;
SList = (SERVER_BROWSE_BUFFER *) &ServList->SList;
for (i = 0; i < entriesread; i++) {
lstrcpy(SList[i].Name, buffer[i].sv101_name);
lstrcpy(SList[i].Description, buffer[i].sv101_comment);
SList[i].Container = FALSE;
SList[i].child = NULL;
}
}
}
if (buffer != NULL)
NetApiBufferFree((LPVOID) buffer);
*lpServList = ServList;
return Status;
} // NTDomainEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NTServerEnum(
LPTSTR szContainer,
SERVER_BROWSE_LIST **lpServList
)
/*++
Routine Description:
Enumerates all NT servers in a given domain.
Arguments:
Return Value:
--*/
{
LPSERVER_INFO_101 buffer = NULL;
NET_API_STATUS Status = 0;
DWORD prefmaxlength = 0xffffffff;
DWORD totalentries = 0;
DWORD entriesread = 0;
DWORD resumehandle = 0;
DWORD i;
BOOL Container = FALSE;
SERVER_BROWSE_LIST *ServList = NULL;
SERVER_BROWSE_BUFFER *SList;
if (((szContainer != NULL) && (lstrlen(szContainer))))
Container = TRUE;
if (Container)
Status = NetServerEnum(NULL, 101, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, SV_TYPE_NT, szContainer, &resumehandle);
else
Status = NetServerEnum(NULL, 101, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, SV_TYPE_DOMAIN_ENUM, NULL, &resumehandle);
if (Status == NO_ERROR) {
ServList = AllocMemory(sizeof(SERVER_BROWSE_LIST) + (sizeof(SERVER_BROWSE_BUFFER) * entriesread));
if (!ServList) {
Status = ERROR_NOT_ENOUGH_MEMORY;
} else {
ServList->Count = entriesread;
SList = (SERVER_BROWSE_BUFFER *) &ServList->SList;
for (i = 0; i < entriesread; i++) {
lstrcpy(SList[i].Name, buffer[i].sv101_name);
lstrcpy(SList[i].Description, buffer[i].sv101_comment);
SList[i].Container = !Container;
SList[i].child = NULL;
}
}
}
if (buffer != NULL)
NetApiBufferFree((LPVOID) buffer);
*lpServList = ServList;
return Status;
} // NTServerEnum
/////////////////////////////////////////////////////////////////////////
BOOL
NTShareNameValidate(
LPTSTR szShareName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
TCHAR *ptr = szShareName;
BOOL ret;
ret = TRUE;
if (*ptr) {
// go to end
while (*ptr)
ptr++;
// now back up to last character
ptr--;
if (*ptr == TEXT('$')) // for ADMIN$, IPC$, etc...
ret = FALSE;
} else
// Don't allow zero length - not sure why we would ever get these...
ret = FALSE;
return ret;
} // NTShareNameValidate
/////////////////////////////////////////////////////////////////////////
DWORD
NTSharesEnum(
SHARE_LIST **lpShares,
DRIVE_LIST *Drives
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPSHARE_INFO_2 buffer = NULL;
NET_API_STATUS Status = 0;
DWORD prefmaxlength = 0xffffffff;
DWORD totalentries = 0;
DWORD entriesread = 0;
DWORD ActualEntries = 0;
DWORD resumehandle = 0;
DWORD i, di;
SHARE_LIST *ShareList = NULL;
SHARE_BUFFER *SList;
DRIVE_BUFFER *DList;
ULONG TotalDrives;
TCHAR Drive[2];
PFPNWVOLUMEINFO VolumeInfo, VolumeEntry;
BOOL Found;
if (LocalMachine)
Status = NetShareEnum(NULL, 2, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, &resumehandle);
else
Status = NetShareEnum(CachedServer, 2, (LPBYTE *) &buffer, prefmaxlength, &entriesread, &totalentries, &resumehandle);
if (Status == NO_ERROR) {
// We have the list - but need to prune out IPC$, Admin$, etc...
for (i = 0; i < entriesread; i++)
if ((buffer[i].shi2_type == STYPE_DISKTREE) && NTShareNameValidate(buffer[i].shi2_netname))
ActualEntries++;
ShareList = AllocMemory(sizeof(SHARE_LIST) + (sizeof(SHARE_BUFFER) * ActualEntries));
if (!ShareList) {
Status = ERROR_NOT_ENOUGH_MEMORY;
} else {
SList = (SHARE_BUFFER *) &ShareList->SList;
ShareList->Count = ActualEntries;
ActualEntries = 0;
TotalDrives = 0;
Drive[1] = TEXT('\0');
if (Drives != NULL) {
DList = Drives->DList;
TotalDrives = Drives->Count;
}
// loop through copying the data
for (i = 0; i < entriesread; i++)
if ((buffer[i].shi2_type == STYPE_DISKTREE) && NTShareNameValidate(buffer[i].shi2_netname)) {
lstrcpy(SList[ActualEntries].Name, buffer[i].shi2_netname);
lstrcpy(SList[ActualEntries].Path, buffer[i].shi2_path);
SList[ActualEntries].Index = (USHORT) ActualEntries;
// Scan drive list looking for match to share path
for (di = 0; di < TotalDrives; di++) {
// Get first char from path - should be drive letter
Drive[0] = *buffer[i].shi2_path;
if (!lstrcmpi(Drive, DList[di].Drive))
SList[ActualEntries].Drive = &DList[di];
}
ActualEntries++;
}
}
}
//
// Now loop through any FPNW shares and tack those on as well
//
VolumeInfo = NULL;
resumehandle = entriesread = 0;
if (pFpnwVolumeEnum != NULL)
if (LocalMachine)
Status = (ULONG) (*pFpnwVolumeEnum) ( NULL, 1, (LPBYTE *)&VolumeInfo, &entriesread, &resumehandle );
else
Status = (ULONG) (*pFpnwVolumeEnum) ( CachedServer, 1, (LPBYTE *)&VolumeInfo, &entriesread, &resumehandle );
#if DBG
dprintf(TEXT("Status: 0x%lX Entries: %lu\n"), Status, entriesread);
#endif
if ( !Status && entriesread ) {
if (ShareList)
ShareList = ReallocMemory(ShareList, sizeof(SHARE_LIST) + (sizeof(SHARE_BUFFER) * (ActualEntries + entriesread)));
else
ShareList = AllocMemory(sizeof(SHARE_LIST) + (sizeof(SHARE_BUFFER) * entriesread));
if (!ShareList) {
Status = ERROR_NOT_ENOUGH_MEMORY;
} else {
SList = (SHARE_BUFFER *) &ShareList->SList; // reset pointer...
// loop through copying the data
for (i = 0; i < entriesread; i++) {
//
// Make sure not in NT Share list already
//
Found = FALSE;
for (di = 0; di < ShareList->Count; di++)
if (!lstrcmpi(SList[di].Name, VolumeInfo[i].lpVolumeName))
Found = TRUE;
if ((!Found) && (VolumeInfo[i].dwType == FPNWVOL_TYPE_DISKTREE) ) {
lstrcpy(SList[ActualEntries].Name, VolumeInfo[i].lpVolumeName);
lstrcpy(SList[ActualEntries].Path, VolumeInfo[i].lpPath);
SList[ActualEntries].Index = (USHORT) ActualEntries;
// Scan drive list looking for match to share path
for (di = 0; di < TotalDrives; di++) {
// Get first char from path - should be drive letter
Drive[0] = *VolumeInfo[i].lpPath;
if (!lstrcmpi(Drive, DList[di].Drive))
SList[ActualEntries].Drive = &DList[di];
}
ActualEntries++;
}
}
}
}
if (ShareList)
ShareList->Count = ActualEntries;
if (VolumeInfo && (pFpnwApiBufferFree != NULL))
(*pFpnwApiBufferFree) ( VolumeInfo );
if (buffer != NULL)
NetApiBufferFree((LPVOID) buffer);
*lpShares = ShareList;
return Status;
} // NTSharesEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NTGroupSave(
LPTSTR Name
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static NET_API_STATUS Status = 0;
GROUP_INFO_0 grpi0;
DWORD err;
grpi0.grpi0_name = Name;
if (LocalMachine)
Status = NetGroupAdd(NULL, 0, (LPBYTE) &grpi0, &err);
else {
Status = NetGroupAdd(CachedServer, 0, (LPBYTE) &grpi0, &err);
}
return Status;
} // NTGroupSave
/////////////////////////////////////////////////////////////////////////
DWORD
NTGroupUserAdd(
LPTSTR GroupName,
LPTSTR UserName,
BOOL Local
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NET_API_STATUS Status = 0;
SID *pUserSID = NULL;
if (LocalMachine)
if (Local) {
pUserSID = NTSIDGet(NULL, UserName);
if (pUserSID != NULL)
Status = NetLocalGroupAddMember(NULL, GroupName, pUserSID);
} else
Status = NetGroupAddUser(NULL, GroupName, UserName);
else {
if (Local) {
pUserSID = NTSIDGet(CachedServer, UserName);
if (pUserSID != NULL)
Status = NetLocalGroupAddMember(CachedServer, GroupName, pUserSID);
} else
Status = NetGroupAddUser(CachedServer, GroupName, UserName);
}
// If complaining because user is already there, ignore
if (Status == NERR_UserInGroup)
Status = 0;
return Status;
} // NTGroupUserAdd
/////////////////////////////////////////////////////////////////////////
DWORD
NTUserInfoSave(
NT_USER_INFO *NT_UInfo,
PFPNW_INFO fpnw
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static NET_API_STATUS Status = 0;
struct _USER_INFO_3 *usri3;
DWORD err;
usri3 = (struct _USER_INFO_3 *) NT_UInfo;
// Map logon hours to GMT time - as NetAPI re-fixes it
NetpRotateLogonHours(NT_UInfo->logon_hours, UNITS_PER_WEEK, TRUE);
if (LocalMachine)
Status = NetUserAdd(NULL, 3, (LPBYTE) usri3, &err);
else
Status = NetUserAdd(CachedServer, 3, (LPBYTE) usri3, &err);
if ((!Status) && (fpnw != NULL)) {
// Need to get user info via LSA call before calling setuserparms
}
return Status;
} // NTUserInfoSave
#define NEW_NULL_PASSWD TEXT(" ")
/////////////////////////////////////////////////////////////////////////
DWORD
NTUserInfoSet(
NT_USER_INFO *NT_UInfo,
PFPNW_INFO fpnw
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPWSTR Password;
LPWSTR Name;
static NET_API_STATUS Status = 0;
struct _USER_INFO_3 *usri3;
DWORD err;
// Tell it not to replace the password
Password = NT_UInfo->password;
NT_UInfo->password = NULL;
Name = NT_UInfo->name;
usri3 = (struct _USER_INFO_3 *) NT_UInfo;
// Map logon hours to GMT time - as NetAPI re-fixes it
NetpRotateLogonHours(NT_UInfo->logon_hours, UNITS_PER_WEEK, TRUE);
if (LocalMachine)
Status = NetUserSetInfo(NULL, Name, 3, (LPBYTE) usri3, &err);
else
Status = NetUserSetInfo(CachedServer, Name, 3, (LPBYTE) usri3, &err);
if ((!Status) && (fpnw != NULL)) {
}
// Reset the password in our data structure.
NT_UInfo->password = Password;
return Status;
} // NTUserInfoSet
/////////////////////////////////////////////////////////////////////////
VOID
NTUserRecInit(
LPTSTR UserName,
NT_USER_INFO *NT_UInfo
)
/*++
Routine Description:
Initializes a user record, uses static variables for string holders
so is not re-entrant, and will overwrite previous records data if
called again.
Arguments:
Return Value:
--*/
{
static TCHAR uname[UNLEN + 1];
static TCHAR upassword[ENCRYPTED_PWLEN];
static TCHAR uhomedir[PATHLEN + 1];
static TCHAR ucomment[MAXCOMMENTSZ + 1];
static TCHAR uscriptpath[PATHLEN + 1];
static TCHAR ufullname[MAXCOMMENTSZ + 1];
static TCHAR uucomment[MAXCOMMENTSZ + 1];
static TCHAR uparms[MAXCOMMENTSZ + 1];
static TCHAR uworkstations[1];
static BYTE ulogonhours[21];
static TCHAR ulogonserver[1];
static TCHAR uprofile[1];
static TCHAR uhome_dir_drive[1];
// init all the static data holders.
memset(uname, 0, sizeof( uname ));
lstrcpy(uname, UserName);
memset(upassword, 0, sizeof( upassword ));
memset(uhomedir, 0, sizeof( uhomedir ));
memset(ucomment, 0, sizeof( ucomment ));
memset(uscriptpath, 0, sizeof( uscriptpath ));
memset(ufullname, 0, sizeof( ufullname ));
memset(uucomment, 0, sizeof( uucomment ));
memset(uparms, 0, sizeof( uparms ));
memset(uworkstations, 0, sizeof( uworkstations ));
memset(ulogonhours, 0, sizeof( ulogonhours ));
memset(ulogonserver, 0, sizeof( ulogonserver ));
memset(uprofile, 0, sizeof( uprofile ));
memset(uhome_dir_drive, 0, sizeof( uhome_dir_drive ));
memset(NT_UInfo, 0, sizeof(NT_USER_INFO));
// point the passed in record to these data holders
NT_UInfo->name = uname;
NT_UInfo->password = upassword;
NT_UInfo->home_dir = uhomedir;
NT_UInfo->comment = ucomment;
NT_UInfo->script_path = uscriptpath;
NT_UInfo->full_name = ufullname;
NT_UInfo->usr_comment = uucomment;
NT_UInfo->parms = uparms;
NT_UInfo->workstations = uworkstations;
NT_UInfo->logon_hours = ulogonhours;
NT_UInfo->logon_server = ulogonserver;
NT_UInfo->profile = uprofile;
NT_UInfo->home_dir_drive = uhome_dir_drive;
NT_UInfo->units_per_week = UNITS_PER_WEEK;
// Set the default values for special fields
NT_UInfo->primary_group_id = DOMAIN_GROUP_RID_USERS;
NT_UInfo->priv = USER_PRIV_USER;
NT_UInfo->acct_expires = TIMEQ_FOREVER;
NT_UInfo->max_storage = USER_MAXSTORAGE_UNLIMITED;
NT_UInfo->flags = UF_SCRIPT;
} // NTUserRecInit
/////////////////////////////////////////////////////////////////////////
LPTSTR
NTDriveShare(
LPTSTR DriveLetter
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR RootPath[MAX_SERVER_NAME_LEN + 3];
if (LocalMachine)
wsprintf(RootPath, TEXT("%s:\\"), DriveLetter);
else
wsprintf(RootPath, TEXT("%s\\%s$\\"), CachedServer, DriveLetter);
return RootPath;
} // NTDriveShare
/////////////////////////////////////////////////////////////////////////
VOID
NTDriveInfoGet(
DRIVE_BUFFER *DBuff
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
DWORD volMaxCompLength, volFileSystemFlags;
DWORD sectorsPC, bytesPS, FreeClusters, Clusters;
TCHAR NameBuffer[20];
TCHAR volName[20];
LPTSTR RootPath;
UINT previousErrorMode;
//
// Disable DriveAccess Error, because no media is inserted onto specified drive.
//
previousErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS|
SEM_NOOPENFILEERRORBOX);
volMaxCompLength = volFileSystemFlags = 0;
sectorsPC = bytesPS = FreeClusters = Clusters = 0;
// First get file system type
RootPath = NTDriveShare(DBuff->Drive);
if (GetVolumeInformation(RootPath, volName, sizeof(volName), NULL, &volMaxCompLength, &volFileSystemFlags, NameBuffer, sizeof(NameBuffer))) {
if (GetDriveType(RootPath) == DRIVE_CDROM)
lstrcpy(DBuff->DriveType, Lids(IDS_S_49));
else
lstrcpyn(DBuff->DriveType, NameBuffer, sizeof(DBuff->DriveType)-1);
lstrcpyn(DBuff->Name, volName, sizeof(DBuff->Name)-1);
if (!lstrcmpi(NameBuffer, Lids(IDS_S_9)))
DBuff->Type = DRIVE_TYPE_NTFS;
}
else {
if (GetDriveType(RootPath) == DRIVE_CDROM)
lstrcpy(DBuff->DriveType, Lids(IDS_S_49));
else
lstrcpy(DBuff->DriveType, TEXT("\0"));
lstrcpy(DBuff->Name, TEXT("\0"));
if (!lstrcmpi(NameBuffer, Lids(IDS_S_9)))
DBuff->Type = DRIVE_TYPE_NTFS;
}
if (GetDiskFreeSpace(RootPath, &sectorsPC, &bytesPS, &FreeClusters, &Clusters)) {
DBuff->TotalSpace = Clusters * sectorsPC * bytesPS;
DBuff->FreeSpace = FreeClusters * sectorsPC * bytesPS;
}
else {
DBuff->TotalSpace = 0;
DBuff->FreeSpace = 0;
}
//
// Back to original error mode.
//
SetErrorMode(previousErrorMode);
} // NTDriveInfoGet
/////////////////////////////////////////////////////////////////////////
BOOL
NTDriveValidate(
TCHAR DriveLetter
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
BOOL ret = FALSE;
// Just make sure it isn't one of the two floppys
if (!((DriveLetter == TEXT('A')) || (DriveLetter == TEXT('B'))))
ret = TRUE;
return ret;
} // NTDriveValidate
/////////////////////////////////////////////////////////////////////////
VOID
NTDrivesEnum(
DRIVE_LIST **lpDrives
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
TCHAR *buffer = NULL;
NET_API_STATUS Status = 0;
DWORD entriesread, totalentries, resumehandle, actualentries, i;
DRIVE_LIST *DriveList;
DRIVE_BUFFER *DList;
entriesread = totalentries = resumehandle = actualentries = 0;
if (LocalMachine)
Status = NetServerDiskEnum(NULL, 0, (LPBYTE *) &buffer, 0xFFFFFFFF, &entriesread, &totalentries, &resumehandle);
else
Status = NetServerDiskEnum(CachedServer, 0, (LPBYTE *) &buffer, 0xFFFFFFFF, &entriesread, &totalentries, &resumehandle);
if (Status == NO_ERROR) {
// We have the list - but need to prune out A:, B:
for (i = 0; i < entriesread; i++)
if (NTDriveValidate(buffer[i * 3]))
actualentries++;
// temporarily use i to hold total size of data structure
i = sizeof(DRIVE_LIST) + (sizeof(DRIVE_BUFFER) * actualentries);
DriveList = AllocMemory(i);
if (!DriveList) {
Status = ERROR_NOT_ENOUGH_MEMORY;
} else {
memset(DriveList, 0, i);
DList = (DRIVE_BUFFER *) &DriveList->DList;
DriveList->Count = actualentries;
// Now fill in the individual data items
actualentries = 0;
for (i = 0; i < entriesread; i++)
if (NTDriveValidate(buffer[i * 3])) {
DList[actualentries].Drive[0] = buffer[i * 3];
NTDriveInfoGet(&DList[actualentries]);
actualentries++;
}
}
}
if (buffer != NULL)
NetApiBufferFree((LPVOID) buffer);
*lpDrives = DriveList;
return;
} // NTDrivesEnum
/////////////////////////////////////////////////////////////////////////
VOID
NTServerGetInfo(
LPTSTR ServerName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
TCHAR LocServer[MAX_SERVER_NAME_LEN + 3];
NET_API_STATUS Status = 0;
if (ServInfo != NULL)
NetApiBufferFree((LPVOID) ServInfo);
ServInfo = NULL;
wsprintf(LocServer, TEXT("\\\\%s"), ServerName);
if (!LocalName)
GetLocalName(&LocalName);
if (lstrcmpi(ServerName, LocalName) == 0)
Status = NetServerGetInfo(NULL, 101, (LPBYTE *) &ServInfo);
else
Status = NetServerGetInfo(LocServer, 101, (LPBYTE *) &ServInfo);
if (Status) {
ServInfo = NULL;
return;
}
} // NTServerGetInfo
/////////////////////////////////////////////////////////////////////////
NT_CONN_BUFFER *
NTConnListFind(
LPTSTR ServerName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
BOOL Found = FALSE;
static NT_CONN_BUFFER *ServList;
ServList = NTConnListStart;
while ((ServList && !Found)) {
if (!lstrcmpi(ServList->Name, ServerName))
Found = TRUE;
else
ServList = ServList->next;
}
if (!Found)
ServList = NULL;
return (ServList);
} // NTConnListFind
/////////////////////////////////////////////////////////////////////////
NT_CONN_BUFFER *
NTConnListAdd(
LPTSTR ServerName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static NT_CONN_BUFFER *tmpPtr;
ULONG Size, strlen1;
tmpPtr = NULL;
strlen1 = (lstrlen(ServerName) + 1) * sizeof(TCHAR);
Size = sizeof(NT_CONN_BUFFER) + strlen1;
tmpPtr = AllocMemory(Size);
if (tmpPtr != NULL) {
// init it to NULL's
memset(tmpPtr, 0, Size);
tmpPtr->Name = (LPTSTR) ((BYTE *) tmpPtr + sizeof(NT_CONN_BUFFER));
lstrcpy(tmpPtr->Name, ServerName);
// link it into the list
if (!NTConnListStart)
NTConnListStart = NTConnListEnd = tmpPtr;
else {
NTConnListEnd->next = tmpPtr;
tmpPtr->prev = NTConnListEnd;
NTConnListEnd = tmpPtr;
}
}
return (tmpPtr);
} // NTConnListAdd
/////////////////////////////////////////////////////////////////////////
VOID
NTConnListDelete(
NT_CONN_BUFFER *tmpPtr
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NT_CONN_BUFFER *PrevPtr;
NT_CONN_BUFFER *NextPtr;
if (tmpPtr == NULL)
return;
// Now unlink the actual server record
PrevPtr = tmpPtr->prev;
NextPtr = tmpPtr->next;
if (PrevPtr)
PrevPtr->next = NextPtr;
if (NextPtr)
NextPtr->prev = PrevPtr;
// Check if at end of list
if (NTConnListEnd == tmpPtr)
NTConnListEnd = PrevPtr;
// Check if at start of list
if (NTConnListStart == tmpPtr)
NTConnListStart = NextPtr;
FreeMemory(tmpPtr);
} // NTConnListDelete
/////////////////////////////////////////////////////////////////////////
VOID
NTConnListDeleteAll()
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR LocServer[MAX_SERVER_NAME_LEN + 3];
NT_CONN_BUFFER *ServList;
NT_CONN_BUFFER *ServListNext;
// Now remove the entries from the internal list
ServList = NTConnListStart;
while (ServList) {
ServListNext = ServList->next;
wsprintf(LocServer, Lids(IDS_S_10), ServList->Name);
WNetCancelConnection2(LocServer, 0, FALSE);
NTConnListDelete(ServList);
ServList = ServListNext;
}
} // NTConnListDeleteAll
/////////////////////////////////////////////////////////////////////////
VOID
NTUseDel(
LPTSTR ServerName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR LocServer[MAX_SERVER_NAME_LEN + 3];
NT_CONN_BUFFER *NTConn;
// Find it in our connection list - if it exists get rid of it.
NTConn = NTConnListFind(ServerName);
if (NTConn != NULL)
NTConnListDelete(NTConn);
NTServerFree();
wsprintf(LocServer, Lids(IDS_S_10), ServerName);
WNetCancelConnection2(LocServer, 0, FALSE);
} // NTUseDel
/////////////////////////////////////////////////////////////////////////
BOOL
NTServerValidate(
HWND hWnd,
LPTSTR ServerName
)
/*++
Routine Description:
Validates a given server - makes sure it can be connected to and
that the user has admin privs on it.
Arguments:
Return Value:
--*/
{
BOOL ret = FALSE;
DWORD idsErr = 0;
DWORD lastErr = 0;
DWORD Size;
NET_API_STATUS Status;
LPUSER_INFO_1 UserInfo1 = NULL;
TCHAR UserName[MAX_NT_USER_NAME_LEN + 1];
TCHAR ServName[MAX_SERVER_NAME_LEN + 3]; // +3 for leading slashes and ending NULL
LPVOID lpMessageBuffer = NULL;
NTServerSet(ServerName);
// server already connected then return success
if (NTConnListFind(ServerName)) {
return TRUE;
}
CursorHourGlass();
// Get Current Logged On User
lstrcpy(UserName, TEXT(""));
Size = sizeof(UserName);
WNetGetUser(NULL, UserName, &Size);
// Fixup the destination server name
lstrcpy(ServName, TEXT( "\\\\" ));
lstrcat(ServName, ServerName);
// Make an ADMIN$ connection to the server
if (UseAddPswd(hWnd, UserName, ServName, Lids(IDS_S_11), NT_PROVIDER)) {
// Double check we have admin privs
// Get connection to the system and check for admin privs...
Status = NetUserGetInfo(ServName, UserName, 1, (LPBYTE *) &UserInfo1);
if (Status == ERROR_SUCCESS) {
// Got User info, now make sure admin flag is set
if (!(UserInfo1->usri1_priv & USER_PRIV_ADMIN)) {
idsErr = IDS_E_6;
goto cleanup;
}
// We may have a connection to admin$ and we may have proven
// that the user we made the connection with really is an admin
// but sitting at the local machine we still may have a problem
// acquiring all of the administrative information necessary to
// accomplish a successful conversion. each and every one of the
// functions that make network calls should return errors and if
// that were the case then the errors would propagate up and we
// could deal with the access denial reasonably. unfortunately,
// alot of assumptions are made after the success of this call
// so we must perform yet another test here...
if (LocalMachine) {
DWORD EntriesRead = 0;
DWORD TotalEntries = 0;
LPSHARE_INFO_2 ShareInfo2 = NULL;
Status = NetShareEnum(
ServName,
2,
(LPBYTE *) &ShareInfo2,
MAX_PREFERRED_LENGTH,
&EntriesRead,
&TotalEntries,
NULL
);
if (ShareInfo2 != NULL)
NetApiBufferFree((LPVOID) ShareInfo2); // discarded...
if (Status != ERROR_SUCCESS) {
idsErr = (Status == ERROR_ACCESS_DENIED) ? IDS_E_6 : IDS_E_5;
goto cleanup;
}
}
// Now get server info and make certain this is an NT server
// instead of an LM type server. Note: Info from the call is
// cached and used later, so don't remove it!!
NTServerGetInfo(ServerName);
if (ServInfo) {
if (ServInfo->sv101_platform_id == SV_PLATFORM_ID_NT) {
if (ServInfo->sv101_type & (TYPE_DOMAIN)) {
// If NTAS and have admin privs then we are set
// then add it to our connection list...
NTConnListAdd(ServerName);
ret = TRUE;
} else {
idsErr = IDS_E_8;
}
} else {
idsErr = IDS_E_8;
}
} else {
idsErr = IDS_E_7;
}
} else {
// determine error string id and bail out...
idsErr = (Status == ERROR_ACCESS_DENIED) ? IDS_E_6 : IDS_E_5;
}
} else if (lastErr = GetLastError()) {
// error string id
idsErr = IDS_E_9;
// use system default language resource
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
lastErr,
0,
(LPTSTR)&lpMessageBuffer,
0,
NULL
);
}
cleanup:
if (lpMessageBuffer) {
WarningError(Lids((WORD)(DWORD)idsErr), ServerName, lpMessageBuffer);
LocalFree(lpMessageBuffer);
} else if (idsErr) {
WarningError(Lids((WORD)(DWORD)idsErr), ServerName);
}
if (UserInfo1 != NULL)
NetApiBufferFree((LPVOID) UserInfo1);
CursorNormal();
return ret;
} // NTServerValidate
/////////////////////////////////////////////////////////////////////////
VOID
NTServerInfoReset(
HWND hWnd,
DEST_SERVER_BUFFER *DServ,
BOOL ResetDomain
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPTSTR apiPDCName = NULL;
TCHAR PDCName[MAX_SERVER_NAME_LEN + 1];
TCHAR LocServer[MAX_SERVER_NAME_LEN + 3];
DOMAIN_BUFFER *DBuff;
TCHAR Domain[DNLEN + 1];
NET_API_STATUS Status = 0;
lstrcpy(PDCName, TEXT(""));
if (ServInfo) {
DServ->Type = ServInfo->sv101_type;
DServ->VerMaj = ServInfo->sv101_version_major;
DServ->VerMin = ServInfo->sv101_version_minor;
DServ->IsNTAS = IsNTAS(DServ->Name);
DServ->IsFPNW = IsFPNW(DServ->Name);
// If there was no old domain, don't worry about reseting it
if (ResetDomain && (DServ->Domain == NULL))
ResetDomain = FALSE;
// Check if we are a member of a domain.
if (ServInfo->sv101_type & (TYPE_DOMAIN)) {
wsprintf(LocServer, TEXT("\\\\%s"), DServ->Name);
Status = NetGetDCName(LocServer, NULL, (LPBYTE *) &apiPDCName);
if (!Status) {
// get rid of leading 2 backslashes
if (lstrlen(apiPDCName) > 2)
lstrcpy(PDCName, &apiPDCName[2]);
if (NTServerValidate(hWnd, PDCName)) {
DServ->IsFPNW = IsFPNW(PDCName);
DServ->InDomain = TRUE;
// Get Domain
memset(Domain, 0, sizeof(Domain));
NTDomainGet(DServ->Name, Domain);
if (ResetDomain) {
DomainListDelete(DServ->Domain);
DServ->Domain = NULL;
}
// Check if we need to add server to server list
DBuff = DomainListFind(Domain);
if (DBuff == NULL) {
DBuff = DomainListAdd(Domain, PDCName);
DBuff->Type = ServInfo->sv101_type;
DBuff->VerMaj = ServInfo->sv101_version_major;
DBuff->VerMin = ServInfo->sv101_version_minor;
}
DBuff->UseCount++;
DServ->Domain = DBuff;
} // if Domain valid
if (apiPDCName != NULL)
NetApiBufferFree((LPVOID) apiPDCName);
}
}
}
// make sure we are pointing to the right one
NTServerSet(DServ->Name);
// Fill in Drive Lists
NTDrivesEnum(&DServ->DriveList);
} // NTServerInfoReset
/////////////////////////////////////////////////////////////////////////
VOID
NTServerInfoSet(
HWND hWnd,
LPTSTR ServerName,
DEST_SERVER_BUFFER *DServ
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPTSTR apiPDCName = NULL;
NET_API_STATUS Status = 0;
CursorHourGlass();
DServ->UseCount++;
NTServerInfoReset(hWnd, DServ, FALSE);
// Fill in share and Drive Lists
NTSharesEnum(&DServ->ShareList, DServ->DriveList);
#ifdef DEBUG
{
DWORD i;
dprintf(TEXT("Adding NT Server: %s\n"), DServ->Name);
dprintf(TEXT(" Version: %lu.%lu\n"), DServ->VerMaj, DServ->VerMin);
if (DServ->InDomain && DServ->Domain)
dprintf(TEXT(" In Domain: %s [\\\\%s]\n"), DServ->Domain->Name, DServ->Domain->PDCName);
dprintf(TEXT("\n"));
dprintf(TEXT(" Drives:\n"));
dprintf(TEXT(" +-------------------+\n"));
for (i = 0; i < DServ->DriveList->Count; i++)
dprintf(TEXT(" %s\n"), DServ->DriveList->DList[i].Drive);
dprintf(TEXT("\n"));
dprintf(TEXT(" Shares:\n"));
dprintf(TEXT(" +-------------------+\n"));
for (i = 0; i < DServ->ShareList->Count; i++)
dprintf(TEXT(" %s\n"), DServ->ShareList->SList[i].Name);
dprintf(TEXT("\n"));
}
#endif
CursorNormal();
} // NTServerInfoSet
/////////////////////////////////////////////////////////////////////////
VOID
NTLoginTimesLog(
BYTE *Times
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
TCHAR *szDays[7];
DWORD Day;
DWORD Hours;
int Bit = 0;
static TCHAR szHours[80];
szDays[0] = Lids(IDS_SUN);
szDays[1] = Lids(IDS_MON);
szDays[2] = Lids(IDS_TUE);
szDays[3] = Lids(IDS_WED);
szDays[4] = Lids(IDS_THU);
szDays[5] = Lids(IDS_FRI);
szDays[6] = Lids(IDS_SAT);
LogWriteLog(1, Lids(IDS_CRLF));
LogWriteLog(1, Lids(IDS_L_56));
// while these should be indent 2, there isn't room on 80 cols - so indent 1
LogWriteLog(1, Lids(IDS_L_1));
LogWriteLog(1, Lids(IDS_L_2));
LogWriteLog(1, Lids(IDS_L_3));
for (Day = 0; Day < 7; Day++) {
LogWriteLog(1, szDays[Day]);
lstrcpy(szHours, TEXT(" "));
for (Hours = 0; Hours < 24; Hours++) {
if (BitTest(Bit, Times))
lstrcat(szHours, TEXT("**"));
else
lstrcat(szHours, TEXT(" "));
Bit++;
lstrcat(szHours, TEXT(" "));
}
LogWriteLog(0, szHours);
LogWriteLog(0, Lids(IDS_CRLF));
}
LogWriteLog(0, Lids(IDS_CRLF));
} // NTLoginTimesLog
/////////////////////////////////////////////////////////////////////////
VOID
NTUserRecLog(
NT_USER_INFO NT_UInfo
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPTSTR tmpStr;
LogWriteLog(1, Lids(IDS_L_57));
LogWriteLog(2, Lids(IDS_L_58), NT_UInfo.full_name);
LogWriteLog(2, Lids(IDS_L_59), NT_UInfo.password);
switch(NT_UInfo.priv) {
case 0:
tmpStr = Lids(IDS_L_60);
break;
case 1:
tmpStr = Lids(IDS_L_61);
break;
case 2:
tmpStr = Lids(IDS_L_62);
break;
}
LogWriteLog(2, Lids(IDS_L_63), tmpStr);
LogWriteLog(2, Lids(IDS_L_64), NT_UInfo.home_dir);
LogWriteLog(2, Lids(IDS_L_65), NT_UInfo.comment);
// Flags
LogWriteLog(2, Lids(IDS_L_66));
if (NT_UInfo.flags & 0x01)
LogWriteLog(3, Lids(IDS_L_67), Lids(IDS_YES));
else
LogWriteLog(3, Lids(IDS_L_67), Lids(IDS_NO));
if (NT_UInfo.flags & 0x02)
LogWriteLog(3, Lids(IDS_L_68), Lids(IDS_YES));
else
LogWriteLog(3, Lids(IDS_L_68), Lids(IDS_NO));
if (NT_UInfo.flags & 0x04)
LogWriteLog(3, Lids(IDS_L_69), Lids(IDS_YES));
else
LogWriteLog(3, Lids(IDS_L_69), Lids(IDS_NO));
if (NT_UInfo.flags & 0x08)
LogWriteLog(3, Lids(IDS_L_70), Lids(IDS_YES));
else
LogWriteLog(3, Lids(IDS_L_70), Lids(IDS_NO));
if (NT_UInfo.flags & 0x20)
LogWriteLog(3, Lids(IDS_L_71), Lids(IDS_NO));
else
LogWriteLog(3, Lids(IDS_L_71), Lids(IDS_YES));
if (NT_UInfo.flags & 0x40)
LogWriteLog(3, Lids(IDS_L_72), Lids(IDS_NO));
else
LogWriteLog(3, Lids(IDS_L_72), Lids(IDS_YES));
// Script path
LogWriteLog(2, Lids(IDS_L_73), NT_UInfo.script_path);
LogWriteLog(2, Lids(IDS_L_74), NT_UInfo.full_name);
LogWriteLog(2, Lids(IDS_L_75), NT_UInfo.logon_server);
NTLoginTimesLog((BYTE *) NT_UInfo.logon_hours);
LogWriteLog(0, Lids(IDS_CRLF));
} // NTUserRecLog
/////////////////////////////////////////////////////////////////////////
VOID
NTDomainSynch(
DEST_SERVER_BUFFER *DServ
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPBYTE buffer = NULL;
BOOL UsePDC = FALSE;
NET_API_STATUS Status;
TCHAR LocServer[MAX_SERVER_NAME_LEN + 3];
wsprintf(LocServer, TEXT("\\\\%s"), DServ->Name);
if ((DServ->InDomain) && (DServ->Domain != NULL)) {
wsprintf(LocServer, TEXT("\\\\%s"), DServ->Domain->PDCName);
UsePDC = TRUE;
}
if (UsePDC)
Status = I_NetLogonControl(LocServer, NETLOGON_CONTROL_PDC_REPLICATE, 1, &buffer);
else
Status = I_NetLogonControl(LocServer, NETLOGON_CONTROL_SYNCHRONIZE, 1, &buffer);
if (buffer != NULL)
NetApiBufferFree(buffer);
} // NTDomainSynch
/////////////////////////////////////////////////////////////////////////
BOOL
NTDomainInSynch(
LPTSTR Server
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
PNETLOGON_INFO_1 buffer = NULL;
NET_API_STATUS Status;
Status = I_NetLogonControl(Server, NETLOGON_CONTROL_QUERY, 1, (PBYTE *) &buffer);
if (Status) {
return TRUE;
}
if (buffer && buffer->netlog1_flags)
return FALSE;
if (buffer != NULL)
NetApiBufferFree(buffer);
return TRUE;
} // NTDomainInSynch
/////////////////////////////////////////////////////////////////////////
BOOL
NTDomainGet(
LPTSTR ServerName,
LPTSTR Domain
)
/*++
Routine Description:
Gee - what a simple way to get the domain a server is part of!
Arguments:
Return Value:
--*/
{
static TCHAR Serv[MAX_SERVER_NAME_LEN + 3];
UNICODE_STRING us;
NTSTATUS ret;
OBJECT_ATTRIBUTES oa;
ACCESS_MASK am;
SECURITY_QUALITY_OF_SERVICE qos;
LSA_HANDLE hLSA;
PPOLICY_PRIMARY_DOMAIN_INFO pvBuffer;
if (ServerName[0] == TEXT('\\'))
lstrcpy(Serv, ServerName);
else
wsprintf(Serv, TEXT("\\\\%s"), ServerName);
// Set up unicode string structure
us.Length = (USHORT)(lstrlen(Serv) * sizeof(TCHAR));
us.MaximumLength = us.Length + sizeof(TCHAR);
us.Buffer = Serv;
// only need read access
am = POLICY_READ | POLICY_VIEW_LOCAL_INFORMATION;
// set up quality of service
qos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
qos.ImpersonationLevel = SecurityImpersonation;
qos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
qos.EffectiveOnly = FALSE;
// Macro sets everything except security field
InitializeObjectAttributes( &oa, NULL, 0L, NULL, NULL );
oa.SecurityQualityOfService = &qos;
ret = LsaOpenPolicy(&us, &oa, am, &hLSA);
if (!ret) {
ret = LsaQueryInformationPolicy(hLSA, PolicyPrimaryDomainInformation, (PVOID *) &pvBuffer);
LsaClose(hLSA);
if ((!ret) && (pvBuffer != NULL)) {
lstrcpy(Domain, pvBuffer->Name.Buffer);
LsaFreeMemory((PVOID) pvBuffer);
}
}
if (ret)
return FALSE;
else
return TRUE;
} // NTDomainGet
/////////////////////////////////////////////////////////////////////////
BOOL
IsFPNW(
LPTSTR ServerName
)
/*++
Routine Description:
Checks the given machine for the FPNW secret.
Arguments:
Return Value:
--*/
{
return (FPNWSecretGet(ServerName) != NULL);
} // IsFPNW
/////////////////////////////////////////////////////////////////////////
BOOL
IsNTAS(
LPTSTR ServerName
)
/*++
Routine Description:
Checks the given machines registry to determine if it is an NTAS
system. The new 'Server' type is also counted as NTAS as all we
use this for is to determine if local or global groups should be
used.
Arguments:
Return Value:
--*/
{
HKEY hKey, hKey2;
DWORD dwType, dwSize;
static TCHAR LocServer[MAX_SERVER_NAME_LEN + 3];
static TCHAR Type[50];
LONG Status;
BOOL ret = FALSE;
wsprintf(LocServer, TEXT("\\\\%s"), ServerName);
dwSize = sizeof(Type);
if (RegConnectRegistry(LocServer, HKEY_LOCAL_MACHINE, &hKey) == ERROR_SUCCESS)
if ((Status = RegOpenKeyEx(hKey, Lids(IDS_S_12), 0, KEY_READ, &hKey2)) == ERROR_SUCCESS)
if ((Status = RegQueryValueEx(hKey2, Lids(IDS_S_13), NULL, &dwType, (LPBYTE) Type, &dwSize)) == ERROR_SUCCESS)
if (!lstrcmpi(Type, Lids(IDS_S_14)))
ret = TRUE;
RegCloseKey(hKey);
return ret;
} // IsNTAS
/////////////////////////////////////////////////////////////////////////
VOID
NTTrustedDomainsEnum(
LPTSTR ServerName,
TRUSTED_DOMAIN_LIST **pTList
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR Serv[MAX_SERVER_NAME_LEN + 3];
TRUSTED_DOMAIN_LIST *TList = NULL;
UNICODE_STRING us;
NTSTATUS ret;
OBJECT_ATTRIBUTES oa;
ACCESS_MASK am;
SECURITY_QUALITY_OF_SERVICE qos;
LSA_HANDLE hLSA;
PPOLICY_PRIMARY_DOMAIN_INFO pvBuffer = NULL;
LSA_ENUMERATION_HANDLE lsaenumh = 0;
LSA_TRUST_INFORMATION *lsat;
ULONG maxrequested = 0xffff;
ULONG cItems;
ULONG i;
if (ServerName[0] == TEXT('\\'))
lstrcpy(Serv, ServerName);
else
wsprintf(Serv, TEXT("\\\\%s"), ServerName);
// Set up unicode string structure
us.Length = (USHORT)(lstrlen(Serv) * sizeof(TCHAR));
us.MaximumLength = us.Length + sizeof(TCHAR);
us.Buffer = Serv;
// only need read access
am = POLICY_READ | POLICY_VIEW_LOCAL_INFORMATION;
// set up quality of service
qos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
qos.ImpersonationLevel = SecurityImpersonation;
qos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
qos.EffectiveOnly = FALSE;
// Macro sets everything except security field
InitializeObjectAttributes( &oa, NULL, 0L, NULL, NULL );
oa.SecurityQualityOfService = &qos;
ret = LsaOpenPolicy(&us, &oa, am, &hLSA);
if (!ret) {
ret = LsaEnumerateTrustedDomains(hLSA, &lsaenumh, (PVOID *) &pvBuffer, maxrequested, &cItems);
LsaClose(hLSA);
if ((!ret) && (pvBuffer != NULL)) {
lsat = (LSA_TRUST_INFORMATION *) pvBuffer;
TList = (TRUSTED_DOMAIN_LIST *) AllocMemory(sizeof(TRUSTED_DOMAIN_LIST) + (cItems * ((MAX_DOMAIN_NAME_LEN + 1) * sizeof(TCHAR))));
memset(TList, 0, sizeof(TRUSTED_DOMAIN_LIST) + (cItems * ((MAX_DOMAIN_NAME_LEN + 1) * sizeof(TCHAR))));
if (TList != NULL) {
TList->Count = cItems;
for (i = 0; i < cItems; i++)
memcpy(TList->Name[i], lsat[i].Name.Buffer, lsat[i].Name.Length);
}
LsaFreeMemory((PVOID) pvBuffer);
}
}
*pTList = TList;
} // NTTrustedDomainsEnum
/////////////////////////////////////////////////////////////////////////
DOMAIN_BUFFER *
NTTrustedDomainSet(
HWND hWnd,
LPTSTR Server,
LPTSTR TrustedDomain
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LPTSTR apiPDCName = NULL;
TCHAR PDCName[MAX_SERVER_NAME_LEN];
TCHAR LocServer[MAX_SERVER_NAME_LEN + 3];
static DOMAIN_BUFFER *DBuff;
NET_API_STATUS Status = 0;
DBuff = NULL;
lstrcpy(PDCName, TEXT(""));
wsprintf(LocServer, TEXT("\\\\%s"), Server);
Status = NetGetDCName(LocServer, TrustedDomain, (LPBYTE *) &apiPDCName);
if (!Status) {
// get rid of leading 2 backslashes
if (lstrlen(apiPDCName) > 2)
lstrcpy(PDCName, &apiPDCName[2]);
if (NTServerValidate(hWnd, PDCName)) {
// Check if we need to add domain to domain list
DBuff = DomainListFind(TrustedDomain);
if (DBuff == NULL) {
DBuff = DomainListAdd(TrustedDomain, PDCName);
DBuff->Type = ServInfo->sv101_type;
DBuff->VerMaj = ServInfo->sv101_version_major;
DBuff->VerMin = ServInfo->sv101_version_minor;
}
DBuff->UseCount++;
} // if Domain valid
if (apiPDCName != NULL)
NetApiBufferFree((LPVOID) apiPDCName);
}
// make sure we are pointing to the right one
NTServerSet(Server);
return DBuff;
} // NTTrustedDomainSet
/////////////////////////////////////////////////////////////////////////
SID *
NTSIDGet(
LPTSTR ServerName,
LPTSTR pUserName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR lpszDomain[80];
DWORD dwDomainLength = 80;
static UCHAR psnuType[1024];
static SID UserSID[1024];
DWORD dwSIDBufSize = 1024;
BOOL Retry = TRUE;
// Get SID for user
while (Retry) {
if (!LookupAccountName(ServerName, pUserName, UserSID, &dwSIDBufSize,
lpszDomain, &dwDomainLength, (PSID_NAME_USE) psnuType)) {
#ifdef DEBUG
dprintf(TEXT("Error %d: LookupAccountName\n"), GetLastError());
#endif
if (GetLastError() == ERROR_NONE_MAPPED)
if (NTDomainInSynch(ServerName))
Retry = FALSE;
else
Sleep(5000L);
} else
return UserSID;
}
return NULL;
} // NTSIDGet
#define SD_SIZE (65536 + SECURITY_DESCRIPTOR_MIN_LENGTH)
/////////////////////////////////////////////////////////////////////////
BOOL
NTFile_AccessRightsAdd(
LPTSTR ServerName,
LPTSTR pUserName,
LPTSTR pFileName,
ACCESS_MASK AccessMask,
BOOL Dir
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS ret;
SID *pUserSID;
// File SD variables
static UCHAR ucSDbuf[SD_SIZE];
PSECURITY_DESCRIPTOR pFileSD = (PSECURITY_DESCRIPTOR) ucSDbuf;
DWORD dwSDLengthNeeded = 0;
// New SD variables
UCHAR NewSD[SECURITY_DESCRIPTOR_MIN_LENGTH];
PSECURITY_DESCRIPTOR psdNewSD=(PSECURITY_DESCRIPTOR)NewSD;
// +-----------------------------------------------------------------+
// | Main Code |
// +-----------------------------------------------------------------+
pUserSID = NTSIDGet(ServerName, pUserName);
if (pUserSID == NULL) {
LogWriteLog(5, Lids(IDS_L_76), GetLastError());
ErrorIt(Lids(IDS_L_77), GetLastError(), pUserName);
return FALSE;
}
// Get security descriptor (SD) for file
if(!GetFileSecurity(pFileName, (SECURITY_INFORMATION) (DACL_SECURITY_INFORMATION),
pFileSD, SD_SIZE, (LPDWORD) &dwSDLengthNeeded)) {
#ifdef DEBUG
dprintf(TEXT("Error %d: GetFileSecurity\n"), GetLastError());
#endif
LogWriteLog(5, Lids(IDS_L_76), GetLastError());
ErrorIt(Lids(IDS_L_77), GetLastError(), pUserName);
return (FALSE);
}
if (Dir)
ret = ACEAdd(pFileSD, pUserSID, AccessMask, DirRightsMapping.NtAceFlags, &psdNewSD );
else
ret = ACEAdd(pFileSD, pUserSID, AccessMask, FileRightsMapping.NtAceFlags, &psdNewSD );
if (ret) {
#ifdef DEBUG
dprintf(TEXT("Error %d: NWAddRight\n"), GetLastError());
#endif
LogWriteLog(5, Lids(IDS_L_76), GetLastError());
ErrorIt(Lids(IDS_L_77), GetLastError(), pUserName);
return FALSE;
}
// Set the SD to the File
if (!SetFileSecurity(pFileName, DACL_SECURITY_INFORMATION, psdNewSD)) {
#ifdef DEBUG
dprintf(TEXT("Error %d: SetFileSecurity\n"), GetLastError());
#endif
LogWriteLog(5, Lids(IDS_L_76), GetLastError());
ErrorIt(Lids(IDS_L_77), GetLastError(), pUserName);
if (psdNewSD != pFileSD)
NW_FREE(psdNewSD);
return FALSE;
}
// Free the memory allocated for the new ACL, but only if
// it was allocated.
if (psdNewSD != pFileSD)
NW_FREE(psdNewSD);
return TRUE;
} // NTFile_AccessRightsAdd
/////////////////////////////////////////////////////////////////////////
NTSTATUS
ACEAdd(
PSECURITY_DESCRIPTOR pSD,
PSID pSid,
ACCESS_MASK AccessMask,
ULONG AceFlags,
PSECURITY_DESCRIPTOR *ppNewSD
)
/*++
Routine Description:
ACEAdd() - Taken from ChuckC's NWRights.C
Arguments:
psd - The security desciptor to modify. This must be a valid
security descriptor.
psid - The SID of the user/group for which we are adding this right.
AccessMask - The access mask that we wish to add.
ppNewSD - used to return the new Security descriptor.
Return Value:
NTSTATUS code
--*/
{
ACL Acl ;
PACL pAcl, pNewAcl = NULL ;
PACCESS_ALLOWED_ACE pAccessAce, pNewAce = NULL ;
NTSTATUS ntstatus ;
BOOLEAN fDaclPresent, fDaclDefaulted;
BOOLEAN Found = FALSE;
LONG i ;
// validate and initialize
if (!pSD || !pSid || !ppNewSD || !RtlValidSecurityDescriptor(pSD)) {
#ifdef DEBUG
dprintf(TEXT("ACEAdd: got invalid parm\n"));
#endif
return (STATUS_INVALID_PARAMETER) ;
}
// if AccessMask == 0, no need to add the ACE
if( !AccessMask ) {
*ppNewSD = pSD;
return( STATUS_SUCCESS );
}
*ppNewSD = NULL ;
// extract the DACL from the securiry descriptor
ntstatus = RtlGetDaclSecurityDescriptor(pSD, &fDaclPresent, &pAcl, &fDaclDefaulted) ;
if (!NT_SUCCESS(ntstatus)) {
#ifdef DEBUG
dprintf(TEXT("ACEAdd: RtlGetDaclSecurityDescriptor failed\n"));
#endif
goto CleanupAndExit ;
}
// if no DACL present, we create one
if ((!fDaclPresent) || (pAcl == NULL)) {
// create Dacl
ntstatus = RtlCreateAcl(&Acl, sizeof(Acl), ACL_REVISION) ;
if (!NT_SUCCESS(ntstatus)) {
#ifdef DEBUG
dprintf(TEXT("ACEAdd: RtlCreateAcl failed\n"));
#endif
goto CleanupAndExit ;
}
pAcl = &Acl ;
}
// loop thru ACEs, looking for entry with the user/group SID
pAccessAce = NULL ;
for (i = 0; i < pAcl->AceCount; i++) {
ACE_HEADER *pAce ;
ntstatus = RtlGetAce(pAcl,i,&pAce) ;
if (!NT_SUCCESS(ntstatus)) {
#ifdef DEBUG
dprintf(TEXT("ACEAdd: RtlGetAce failed\n"));
#endif
goto CleanupAndExit ;
}
if (pAce->AceType == ACCESS_ALLOWED_ACE_TYPE) {
// found a granting ace, which is what we want
PSID pAceSid ;
pAccessAce = (ACCESS_ALLOWED_ACE *) pAce ;
pAceSid = (PSID) &pAccessAce->SidStart ;
//
// is this the same SID?
// if yes, modify access mask and carry on.
//
if (RtlEqualSid(pAceSid, pSid)) {
ACCESS_MASK access_mask ;
ASSERT(pAccessAce != NULL) ;
access_mask = pAccessAce->Mask ;
if ( (access_mask & AccessMask) == access_mask ) {
ntstatus = STATUS_MEMBER_IN_GROUP ;
goto CleanupAndExit ;
}
pAccessAce->Mask = AccessMask ;
Found = TRUE ;
}
} else {
// ignore it. we only deal with granting aces.
}
}
if ( !Found ) { // now set the DACL to have the desired rights
// reached end of ACE list without finding match. so we need to
// create a new ACE.
USHORT NewAclSize, NewAceSize ;
// calculate the sizes
NewAceSize = (USHORT)(sizeof(ACE_HEADER) +
sizeof(ACCESS_MASK) +
RtlLengthSid(pSid));
NewAclSize = pAcl->AclSize + NewAceSize ;
// allocate new ACE and new ACL (since we are growing it)
pNewAce = (PACCESS_ALLOWED_ACE) NW_ALLOC(NewAceSize) ;
if (!pNewAce) {
#ifdef DEBUG
dprintf(TEXT("ACEAdd: memory allocation failed for new ACE\n"));
#endif
ntstatus = STATUS_INSUFFICIENT_RESOURCES ;
goto CleanupAndExit ;
}
pNewAce->Header.AceFlags = (UCHAR)AceFlags;
pNewAce->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
pNewAce->Header.AceSize = NewAceSize;
pNewAce->Mask = AccessMask;
RtlCopySid( RtlLengthSid(pSid), (PSID)(&pNewAce->SidStart), pSid );
pNewAcl = (PACL) NW_ALLOC(NewAclSize) ;
if (!pNewAcl) {
#ifdef DEBUG
dprintf(TEXT("ACEAdd: memory allocation failed for new ACL\n"));
#endif
ntstatus = STATUS_INSUFFICIENT_RESOURCES ;
goto CleanupAndExit ;
}
RtlCopyMemory(pNewAcl, pAcl, pAcl->AclSize) ;
pNewAcl->AclSize = NewAclSize ;
// Add the ACE to the end of the ACL
ntstatus = RtlAddAce(pNewAcl, ACL_REVISION, pNewAcl->AceCount, pNewAce, NewAceSize) ;
if (!NT_SUCCESS(ntstatus)) {
#ifdef DEBUG
dprintf(TEXT("ACEAdd: RtlAddAce failed\n"));
#endif
goto CleanupAndExit ;
}
pAcl = pNewAcl ;
}
// set the dacl back into the security descriptor. we need create
// a new security descriptor, since the old one may not have space
// for any additional ACE.
ntstatus = CreateNewSecurityDescriptor(ppNewSD, pSD, pAcl) ;
if (!NT_SUCCESS(ntstatus)) {
#ifdef DEBUG
dprintf(TEXT("ACEAdd: CreateNewSecurityDescriptor failed\n"));
#endif
}
CleanupAndExit:
if (pNewAcl)
NW_FREE(pNewAcl) ;
if (pNewAce)
NW_FREE(pNewAce) ;
return ntstatus ;
} // ACEAdd
/////////////////////////////////////////////////////////////////////////
NTSTATUS
CreateNewSecurityDescriptor(
PSECURITY_DESCRIPTOR *ppNewSD,
PSECURITY_DESCRIPTOR pSD,
PACL pAcl
)
/*++
Routine Description:
From a SD and a Dacl, create a new SD. The new SD will be fully self
contained (it is self relative) and does not have pointers to other
structures.
Arguments:
ppNewSD - used to return the new SD. Caller should free with NW_FREE
pSD - the self relative SD we use to build the new SD
pAcl - the new DACL that will be used for the new SD
Return Value:
NTSTATUS code
--*/
{
PACL pSacl ;
PSID psidGroup, psidOwner ;
BOOLEAN fSaclPresent ;
BOOLEAN fSaclDefaulted, fGroupDefaulted, fOwnerDefaulted ;
ULONG NewSDSize ;
SECURITY_DESCRIPTOR NewSD ;
PSECURITY_DESCRIPTOR pNewSD ;
NTSTATUS ntstatus ;
// extract the originals from the securiry descriptor
ntstatus = RtlGetSaclSecurityDescriptor(pSD, &fSaclPresent, &pSacl, &fSaclDefaulted) ;
if (!NT_SUCCESS(ntstatus))
return ntstatus ;
ntstatus = RtlGetOwnerSecurityDescriptor(pSD, &psidOwner, &fOwnerDefaulted) ;
if (!NT_SUCCESS(ntstatus))
return ntstatus ;
ntstatus = RtlGetGroupSecurityDescriptor(pSD, &psidGroup, &fGroupDefaulted) ;
if (!NT_SUCCESS(ntstatus))
return ntstatus ;
// now create a new SD and set the info in it. we cannot return this one
// since it has pointers to old SD.
ntstatus = RtlCreateSecurityDescriptor(&NewSD, SECURITY_DESCRIPTOR_REVISION) ;
if (!NT_SUCCESS(ntstatus))
return ntstatus ;
ntstatus = RtlSetDaclSecurityDescriptor(&NewSD, TRUE, pAcl, FALSE) ;
if (!NT_SUCCESS(ntstatus))
return ntstatus ;
ntstatus = RtlSetSaclSecurityDescriptor(&NewSD, fSaclPresent, pSacl, fSaclDefaulted) ;
if (!NT_SUCCESS(ntstatus))
return ntstatus ;
ntstatus = RtlSetOwnerSecurityDescriptor(&NewSD, psidOwner, fOwnerDefaulted) ;
if (!NT_SUCCESS(ntstatus))
return ntstatus ;
ntstatus = RtlSetGroupSecurityDescriptor(&NewSD, psidGroup, fGroupDefaulted) ;
if (!NT_SUCCESS(ntstatus))
return ntstatus ;
// calculate size needed for the returned SD and allocated it
NewSDSize = RtlLengthSecurityDescriptor(&NewSD) ;
pNewSD = (PSECURITY_DESCRIPTOR) NW_ALLOC(NewSDSize) ;
if (!pNewSD)
return (STATUS_INSUFFICIENT_RESOURCES) ;
// convert the absolute to self relative
ntstatus = RtlAbsoluteToSelfRelativeSD(&NewSD, pNewSD, &NewSDSize) ;
if (NT_SUCCESS(ntstatus))
*ppNewSD = pNewSD ;
else
NW_FREE(pNewSD) ;
return ntstatus ;
} // CreateNewSecurityDescriptor
/////////////////////////////////////////////////////////////////////////
LPTSTR
NTAccessLog(
ACCESS_MASK AccessMask
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR AccessDesc[80];
TCHAR AccessStr[80];
if (AccessMask == 0) {
lstrcpy(AccessDesc, Lids(IDS_L_78));
return AccessDesc;
} else
if ((AccessMask & GENERIC_ALL) == GENERIC_ALL) {
lstrcpy(AccessDesc, Lids(IDS_L_79));
return AccessDesc;
} else {
lstrcpy(AccessStr, TEXT("("));
if ((AccessMask & GENERIC_READ) == GENERIC_READ)
lstrcat(AccessStr, Lids(IDS_L_80));
if ((AccessMask & GENERIC_WRITE) == GENERIC_WRITE)
lstrcat(AccessStr, Lids(IDS_L_81));
if ((AccessMask & GENERIC_EXECUTE) == GENERIC_EXECUTE)
lstrcat(AccessStr, Lids(IDS_L_82));
if ((AccessMask & DELETE) == DELETE)
lstrcat(AccessStr, Lids(IDS_L_83));
if ((AccessMask & WRITE_DAC) == WRITE_DAC)
lstrcat(AccessStr, Lids(IDS_L_84));
lstrcat(AccessStr, TEXT(")"));
// Figured out the individual rights, now need to see if this corresponds
// to a generic mapping
if (!lstrcmpi(AccessStr, Lids(IDS_L_85))) {
lstrcpy(AccessDesc, Lids(IDS_L_86));
return AccessDesc;
}
if (!lstrcmpi(AccessStr, Lids(IDS_L_87))) {
lstrcpy(AccessDesc, Lids(IDS_L_88));
return AccessDesc;
}
if (!lstrcmpi(AccessStr, Lids(IDS_L_89))) {
lstrcpy(AccessDesc, Lids(IDS_L_90));
return AccessDesc;
}
if (!lstrcmpi(AccessStr, Lids(IDS_L_91))) {
lstrcpy(AccessDesc, Lids(IDS_L_92));
return AccessDesc;
}
wsprintf(AccessDesc, Lids(IDS_L_93), AccessStr);
}
return AccessDesc;
} // NTAccessLog
/////////////////////////////////////////////////////////////////////////
VOID
NTUserDefaultsGet(
NT_DEFAULTS **UDefaults
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
USER_MODALS_INFO_0 *NTDefaults = NULL;
NET_API_STATUS Status = 0;
if (LocalMachine)
Status = NetUserModalsGet(NULL, 0, (LPBYTE *) &NTDefaults);
else
Status = NetUserModalsGet(CachedServer, 0, (LPBYTE *) &NTDefaults);
if (Status) {
NTDefaults = NULL;
return;
}
*UDefaults = (NT_DEFAULTS *) NTDefaults;
} // NTUserDefaultsGet
/////////////////////////////////////////////////////////////////////////
DWORD
NTUserDefaultsSet(
NT_DEFAULTS NTDefaults
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NET_API_STATUS Status = 0;
DWORD err;
if (LocalMachine)
Status = NetUserModalsSet(NULL, 0, (LPBYTE) &NTDefaults, &err);
else
Status = NetUserModalsSet(CachedServer, 0, (LPBYTE) &NTDefaults, &err);
return Status;
} // NTUserDefaultsSet
/////////////////////////////////////////////////////////////////////////
VOID
NTUserDefaultsLog(
NT_DEFAULTS UDefaults
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LogWriteLog(1, Lids(IDS_L_94), UDefaults.min_passwd_len);
// Age is in seconds, convert to days
LogWriteLog(1, Lids(IDS_L_95), UDefaults.max_passwd_age / 86400);
LogWriteLog(1, Lids(IDS_L_96), UDefaults.force_logoff);
LogWriteLog(0, Lids(IDS_CRLF));
} // NTUserDefaultsLog