Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/nw/convert/nwconv/nwnetapi.c

2693 lines
59 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1993-1995 Microsoft Corporation
Module Name:
nwnetapi.c
Abstract:
Author:
Arthur Hanson (arth) 16-Jun-1994
Revision History:
--*/
#include "globals.h"
#include <nwapi32.h>
#include "nwconv.h"
#include "convapi.h"
#include "nwnetapi.h"
#include "statbox.h"
#define SUPERVISOR "SUPERVISOR"
#define ACCOUNT_LOCKOUT "ACCT_LOCKOUT"
#define GROUP_MEMBERS "GROUP_MEMBERS"
#define GROUPS_IM_IN "GROUPS_I'M_IN"
#define IDENTIFICATION "IDENTIFICATION"
#define LOGIN_CONTROL "LOGIN_CONTROL"
#define PS_OPERATORS "PS_OPERATORS"
#define SECURITY_EQUALS "SECURITY_EQUALS"
#define USER_DEFAULTS "USER_DEFAULTS"
#define MS_EXTENDED_NCPS "MS_EXTENDED_NCPS"
#define FPNW_PDC "FPNWPDC"
#ifdef DEBUG
int ErrorBoxRetry(LPTSTR szFormat, ...);
#endif
// Couple of NetWare specific data structures - see NetWare programming books for
// info on these structures
#pragma pack(1)
typedef struct tagLoginControl {
BYTE byAccountExpires[3];
BYTE byAccountDisabled;
BYTE byPasswordExpires[3];
BYTE byGraceLogins;
WORD wPasswordInterval;
BYTE byGraceLoginReset;
BYTE byMinPasswordLength;
WORD wMaxConnections;
BYTE byLoginTimes[42];
BYTE byLastLogin[6];
BYTE byRestrictions;
BYTE byUnused;
long lMaxDiskBlocks;
WORD wBadLogins;
LONG lNextResetTime;
BYTE byBadLoginAddr[12];
}; // tagLoginControl
#pragma pack()
typedef struct tagAccountBalance {
long lBalance;
long lCreditLimit;
}; // tagAccountBalance
typedef struct tagUserDefaults {
BYTE byAccountExpiresYear;
BYTE byAccountExpiresMonth;
BYTE byAccountExpiresDay;
BYTE byRestrictions;
WORD wPasswordInterval;
BYTE byGraceLoginReset;
BYTE byMinPasswordLength;
WORD wMaxConnections;
BYTE byLoginTimes[42];
long lBalance;
long lCreditLimit;
long lMaxDiskBlocks;
}; // tagUserDefaults
// define the mapping for FILE objects. Note: we only use GENERIC and
// STANDARD bits!
RIGHTS_MAPPING FileRightsMapping = {
0,
{ FILE_GENERIC_READ,
FILE_GENERIC_WRITE,
FILE_GENERIC_EXECUTE,
FILE_ALL_ACCESS
},
{ { NW_FILE_READ, GENERIC_READ},
{ NW_FILE_WRITE, GENERIC_WRITE},
{ NW_FILE_CREATE, 0},
{ NW_FILE_DELETE, GENERIC_WRITE|DELETE},
{ NW_FILE_PERM, WRITE_DAC},
{ NW_FILE_SCAN, 0},
{ NW_FILE_MODIFY, GENERIC_WRITE},
{ NW_FILE_SUPERVISOR, GENERIC_ALL},
{ 0, 0 }
}
} ;
RIGHTS_MAPPING DirRightsMapping = {
CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE,
{ FILE_GENERIC_READ,
FILE_GENERIC_WRITE,
FILE_GENERIC_EXECUTE,
FILE_ALL_ACCESS
},
{ { NW_FILE_READ, GENERIC_READ|GENERIC_EXECUTE},
{ NW_FILE_WRITE, GENERIC_WRITE},
{ NW_FILE_CREATE, GENERIC_WRITE},
{ NW_FILE_DELETE, DELETE},
{ NW_FILE_PERM, WRITE_DAC},
{ NW_FILE_SCAN, GENERIC_READ},
{ NW_FILE_MODIFY, GENERIC_WRITE},
{ NW_FILE_SUPERVISOR, GENERIC_ALL},
{ 0, 0 }
}
} ;
VOID UserInfoLog(LPTSTR UserName, struct tagLoginControl tag);
VOID Moveit(NWCONN_HANDLE Conn, LPTSTR UserName);
VOID UserRecInit(NT_USER_INFO *UserInfo);
BOOL IsNCPServerFPNW(NWCONN_HANDLE Conn);
static NWCONN_HANDLE CachedConn = 0;
static TCHAR CachedServer[MAX_SERVER_NAME_LEN + 1];
static DWORD CachedServerTime = 0xffffffff; // minutes since 1985...
typedef struct _PRINT_SERVER_BUFFER {
TCHAR Name[20];
} PRINT_SERVER_BUFFER;
typedef struct _PRINT_SERVER_LIST {
ULONG Count;
PRINT_SERVER_BUFFER PSList[];
} PRINT_SERVER_LIST;
/////////////////////////////////////////////////////////////////////////
int
NWGetMaxServerNameLen()
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
return MAX_SERVER_NAME_LEN;
} // NWGetMaxServerNameLen
/////////////////////////////////////////////////////////////////////////
int
NWGetMaxUserNameLen()
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
return MAX_USER_NAME_LEN;
} // NWGetMaxUserNameLen
/////////////////////////////////////////////////////////////////////////
DWORD
NWServerFree()
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
if (CachedConn)
NWDetachFromFileServer(CachedConn);
CachedConn = 0;
return (0);
} // NWServerFree
/////////////////////////////////////////////////////////////////////////
DWORD
NWServerSet(
LPTSTR FileServer
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NWLOCAL_SCOPE ScopeFlag = 0;
NWCONN_HANDLE Conn = 0;
NWCCODE ret = 0;
char szAnsiFileServer[MAX_SERVER_NAME_LEN + 1];
NWServerFree();
lstrcpy(CachedServer, FileServer);
CharToOem(FileServer, szAnsiFileServer);
ret = NWAttachToFileServer(szAnsiFileServer, ScopeFlag, &Conn);
if (!ret) {
CachedConn = Conn;
NWServerTimeGet();
}
return ((DWORD) ret);
} // NWServerSet
/////////////////////////////////////////////////////////////////////////
VOID
NWUseDel(
LPTSTR ServerName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR LocServer[MAX_SERVER_NAME_LEN+3];
NWServerFree();
wsprintf(LocServer, Lids(IDS_S_27), ServerName);
WNetCancelConnection2(LocServer, 0, FALSE);
} // NWUseDel
/////////////////////////////////////////////////////////////////////////
BOOL
NWUserNameValidate(
LPTSTR szUserName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
TCHAR UserName[MAX_USER_NAME_LEN + 1];
DWORD Size;
// if same as logged on user then don't convert or overwrite
Size = sizeof(UserName);
WNetGetUser(NULL, UserName, &Size);
if (!lstrcmpi(szUserName, UserName))
return FALSE;
// Now check for other special names
if (!lstrcmpi(szUserName, Lids(IDS_S_28)))
return FALSE;
if (!lstrcmpi(szUserName, Lids(IDS_S_29)))
return FALSE;
if (!lstrcmpi(szUserName, Lids(IDS_S_30)))
return FALSE;
return TRUE;
} // NWUserNameValidate
/////////////////////////////////////////////////////////////////////////
BOOL
NWGroupNameValidate(
LPTSTR szGroupName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
if (!lstrcmpi(szGroupName, Lids(IDS_S_31)))
return FALSE;
if (!lstrcmpi(szGroupName, Lids(IDS_S_28)))
return FALSE;
return TRUE;
} // NWGroupNameValidate
/////////////////////////////////////////////////////////////////////////
LPTSTR
NWSpecialNamesMap(
LPTSTR Name
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
ULONG i;
static BOOL InitStrings = FALSE;
static LPTSTR SpecialNames[5];
static LPTSTR SpecialMap[5];
if (!InitStrings) {
InitStrings = TRUE;
SpecialNames[0] = Lids(IDS_S_28);
SpecialNames[1] = Lids(IDS_S_30);
SpecialNames[2] = Lids(IDS_S_31);
SpecialNames[3] = Lids(IDS_S_29);
SpecialNames[4] = NULL;
SpecialMap[0] = Lids(IDS_S_32);
SpecialMap[1] = Lids(IDS_S_32);
SpecialMap[2] = Lids(IDS_S_33);
SpecialMap[3] = Lids(IDS_S_29);
SpecialMap[4] = NULL;
}
i = 0;
while(SpecialNames[i] != NULL) {
if (!lstrcmpi(SpecialNames[i], Name)) {
return SpecialMap[i];
}
i++;
}
return Name;
} // NWSpecialNamesMap
/////////////////////////////////////////////////////////////////////////
BOOL
NWIsAdmin(
LPTSTR UserName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
char szAnsiUserName[MAX_USER_NAME_LEN];
NWCCODE ret;
CharToOem(UserName, szAnsiUserName);
ret = NWIsObjectInSet(CachedConn, szAnsiUserName, OT_USER, SECURITY_EQUALS,
SUPERVISOR, OT_USER);
if (ret == SUCCESSFUL)
return TRUE;
else
return FALSE;
} // NWIsAdmin
/////////////////////////////////////////////////////////////////////////
BOOL
NWObjectNameGet(
DWORD ObjectID,
LPTSTR ObjectName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
char szAnsiObjectName[MAX_USER_NAME_LEN + 1];
WORD wFoundUserType = 0;
NWCCODE ret;
lstrcpy(ObjectName, TEXT(""));
if (!(ret = NWGetObjectName(CachedConn, ObjectID, szAnsiObjectName, &wFoundUserType))) {
//
// Got user - now convert and save off the information
//
OemToChar(szAnsiObjectName, ObjectName);
}
if (ret == SUCCESSFUL)
return TRUE;
else
return FALSE;
} // NWObjectNameGet
#define DEF_NUM_RECS 200
/////////////////////////////////////////////////////////////////////////
DWORD
NWUsersEnum(
USER_LIST **lpUsers,
BOOL Display
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
USER_LIST *Users = NULL;
USER_BUFFER *UserBuffer = NULL;
DWORD NumRecs = DEF_NUM_RECS; // Default 200 names
DWORD Count = 0;
DWORD status = 0;
char szAnsiUserName[MAX_USER_NAME_LEN + 1];
TCHAR szUserName[MAX_USER_NAME_LEN + 1];
WORD wFoundUserType = 0;
DWORD dwObjectID = 0xFFFFFFFFL;
BYTE byPropertiesFlag = 0;
BYTE byObjectFlag = 0;
BYTE byObjectSecurity = 0;
NWCCODE ret;
if (Display)
Status_ItemLabel(Lids(IDS_S_44));
Users = (USER_LIST *) AllocMemory(sizeof(USER_LIST) + (sizeof(USER_BUFFER) * NumRecs));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
UserBuffer = Users->UserBuffer;
// init to NULL so doesn't have garbage if call fails
lstrcpyA(szAnsiUserName, "");
// Loop through bindery getting all the users.
while ((ret = NWScanObject(CachedConn, "*", OT_USER, &dwObjectID, szAnsiUserName,
&wFoundUserType, &byPropertiesFlag,
&byObjectFlag, &byObjectSecurity)) == SUCCESSFUL) {
// Got user - now convert and save off the information
OemToChar(szAnsiUserName, szUserName);
if (NWUserNameValidate(szUserName)) {
if (Display)
Status_Item(szUserName);
lstrcpy(UserBuffer[Count].Name, szUserName);
lstrcpy(UserBuffer[Count].NewName, szUserName);
Count++;
}
// Check if we have to re-allocate buffer
if (Count >= NumRecs) {
NumRecs += DEF_NUM_RECS;
Users = (USER_LIST *) ReallocMemory((HGLOBAL) Users, sizeof(USER_LIST) + (sizeof(USER_BUFFER) * NumRecs));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
break;
}
UserBuffer = Users->UserBuffer;
}
}
// Gotta clear this out from the last loop
if (Count)
ret = 0;
}
// check if error occured...
if (ret)
status = ret;
// Now slim down the list to just what we need.
if (!status) {
Users = (USER_LIST *) ReallocMemory((HGLOBAL) Users, sizeof(USER_LIST) + (sizeof(USER_BUFFER)* Count));
if (!Users)
status = ERROR_NOT_ENOUGH_MEMORY;
else {
// Sort the server list before putting it in the dialog
UserBuffer = Users->UserBuffer;
qsort((void *) UserBuffer, (size_t) Count, sizeof(USER_BUFFER), UserListCompare);
}
}
if (Users != NULL)
Users->Count = Count;
*lpUsers = Users;
return status;
} // NWUsersEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NWGroupsEnum(
GROUP_LIST **lpGroups,
BOOL Display
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
GROUP_LIST *Groups = NULL;
GROUP_BUFFER *GroupBuffer;
DWORD NumRecs = DEF_NUM_RECS; // Default 200 names
DWORD Count = 0;
DWORD status = 0;
char szAnsiGroupName[MAX_GROUP_NAME_LEN + 1];
TCHAR szGroupName[MAX_GROUP_NAME_LEN + 1];
WORD wFoundGroupType = 0;
DWORD dwObjectID = 0xFFFFFFFFL;
BYTE byPropertiesFlag = 0;
BYTE byObjectFlag = 0;
BYTE byObjectSecurity = 0;
NWCCODE ret;
if (Display)
Status_ItemLabel(Lids(IDS_S_45));
Groups = (GROUP_LIST *) AllocMemory(sizeof(GROUP_LIST) + (sizeof(GROUP_BUFFER) * NumRecs));
if (!Groups) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
GroupBuffer = Groups->GroupBuffer;
// init to NULL so doesn't have garbage if call fails
lstrcpyA(szAnsiGroupName, "");
// Loop through bindery getting all the users.
while ((ret = NWScanObject(CachedConn, "*", OT_USER_GROUP, &dwObjectID, szAnsiGroupName,
&wFoundGroupType, &byPropertiesFlag,
&byObjectFlag, &byObjectSecurity)) == SUCCESSFUL) {
// Got user - now convert and save off the information
OemToChar(szAnsiGroupName, szGroupName);
if (NWGroupNameValidate(szGroupName)) {
if (Display)
Status_Item(szGroupName);
lstrcpy(GroupBuffer[Count].Name, szGroupName);
lstrcpy(GroupBuffer[Count].NewName, szGroupName);
Count++;
}
// Check if we have to re-allocate buffer
if (Count >= NumRecs) {
NumRecs += DEF_NUM_RECS;
Groups = (GROUP_LIST *) ReallocMemory((HGLOBAL) Groups, sizeof(GROUP_LIST) + (sizeof(GROUP_BUFFER) * NumRecs));
if (!Groups) {
status = ERROR_NOT_ENOUGH_MEMORY;
break;
}
GroupBuffer = Groups->GroupBuffer;
}
}
// Gotta clear this out from the last loop
if (Count)
ret = 0;
}
// check if error occured...
if (ret)
status = ret;
// Now slim down the list to just what we need.
if (!status) {
Groups = (GROUP_LIST *) ReallocMemory((HGLOBAL) Groups, sizeof(GROUP_LIST) + (sizeof(GROUP_BUFFER) * Count));
if (!Groups)
status = ERROR_NOT_ENOUGH_MEMORY;
else {
// Sort the server list before putting it in the dialog
GroupBuffer = Groups->GroupBuffer;
qsort((void *) GroupBuffer, (size_t) Count, sizeof(GROUP_BUFFER), UserListCompare);
}
}
if (Groups != NULL)
Groups->Count = Count;
*lpGroups = Groups;
return status;
} // NWGroupsEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NWGroupUsersEnum(
LPTSTR GroupName,
USER_LIST **lpUsers
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
USER_LIST *Users = NULL;
USER_BUFFER *UserBuffer;
DWORD NumRecs = DEF_NUM_RECS; // Default 200 names
DWORD Count = 0;
DWORD i = 0;
DWORD status = 0;
char szAnsiUserName[MAX_USER_NAME_LEN + 1];
char szAnsiGroupName[MAX_GROUP_NAME_LEN + 1];
TCHAR szUserName[MAX_USER_NAME_LEN + 1];
WORD wFoundUserType = 0;
BYTE byPropertyFlags = 0;
BYTE byObjectFlag = 0;
BYTE byObjectSecurity = 0;
UCHAR Segment = 1;
DWORD bySegment[32];
BYTE byMoreSegments;
NWCCODE ret;
Users = (USER_LIST *) AllocMemory(sizeof(USER_LIST) + (sizeof(USER_BUFFER) * NumRecs));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
UserBuffer = Users->UserBuffer;
// init to NULL so doesn't have garbage if call fails
lstrcpyA(szAnsiUserName, "");
CharToOem(GroupName, szAnsiGroupName);
// Loop through bindery getting all the users.
do {
if (!(ret = NWReadPropertyValue(CachedConn, szAnsiGroupName, OT_USER_GROUP, GROUP_MEMBERS,
Segment, (BYTE *) bySegment, &byMoreSegments, &byPropertyFlags))) {
Segment++;
// loop through properties converting them to user names
i = 0;
while ((bySegment[i]) && (i < 32)) {
if (!(ret = NWGetObjectName(CachedConn, bySegment[i], szAnsiUserName, &wFoundUserType))) {
// Got user - now convert and save off the information
OemToChar(szAnsiUserName, szUserName);
lstrcpy(UserBuffer[Count].Name, szUserName);
lstrcpy(UserBuffer[Count].NewName, szUserName);
Count++;
// Check if we have to re-allocate buffer
if (Count >= NumRecs) {
NumRecs += DEF_NUM_RECS;
Users = (USER_LIST *) ReallocMemory((HGLOBAL) Users, sizeof(USER_LIST) + (sizeof(USER_BUFFER) * NumRecs));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
break;
}
UserBuffer = Users->UserBuffer;
}
}
i++;
}
} else // if NWReadPropertyValue
byMoreSegments = 0;
} while (byMoreSegments);
// Gotta clear this out from the last loop
if (Count)
ret = 0;
}
// check if error occured...
if (ret)
status = ret;
// Now slim down the list to just what we need.
if (!status) {
Users = (USER_LIST *) ReallocMemory((HGLOBAL) Users, sizeof(USER_LIST) + (sizeof(USER_BUFFER) * Count));
if (!Users)
status = ERROR_NOT_ENOUGH_MEMORY;
else {
// Sort the server list before putting it in the dialog
UserBuffer = Users->UserBuffer;
qsort((void *) UserBuffer, (size_t) Count, sizeof(USER_BUFFER), UserListCompare);
}
}
if (Users != NULL)
Users->Count = Count;
*lpUsers = Users;
return status;
} // NWGroupUsersEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NWUserEquivalenceEnum(
LPTSTR UserName,
USER_LIST **lpUsers
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
USER_LIST *Users;
USER_BUFFER *UserBuffer;
DWORD NumRecs = DEF_NUM_RECS; // Default 200 names
DWORD Count = 0;
DWORD i = 0;
DWORD status = 0;
char szAnsiUserName[MAX_USER_NAME_LEN + 1];
char szAnsiName[MAX_GROUP_NAME_LEN + 1];
TCHAR szUserName[MAX_USER_NAME_LEN + 1];
WORD wFoundUserType = 0;
DWORD dwObjectID = 0xFFFFFFFFL;
BYTE byPropertyFlags = 0;
BYTE byObjectFlag = 0;
BYTE byObjectSecurity = 0;
UCHAR Segment = 1;
DWORD bySegment[32];
BYTE byMoreSegments;
NWCCODE ret;
Users = (USER_LIST *) AllocMemory(sizeof(USER_LIST) + (sizeof(USER_BUFFER) * NumRecs));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
UserBuffer = Users->UserBuffer;
// init to NULL so doesn't have garbage if call fails
lstrcpyA(szAnsiUserName, "");
CharToOem(UserName, szAnsiName);
// Loop through bindery getting all the users.
do {
if (!(ret = NWReadPropertyValue(CachedConn, szAnsiName, OT_USER, SECURITY_EQUALS,
Segment, (BYTE *) bySegment, &byMoreSegments, &byPropertyFlags))) {
Segment++;
// loop through properties converting them to user names
i = 0;
while ((bySegment[i]) && (i < 32)) {
if (!(ret = NWGetObjectName(CachedConn, bySegment[i], szAnsiUserName, &wFoundUserType))) {
// Got user - now convert and save off the information
OemToChar(szAnsiUserName, szUserName);
// Map out Everyone equivalence
if (lstrcmpi(szUserName, Lids(IDS_S_31))) {
lstrcpy(UserBuffer[Count].Name, szUserName);
lstrcpy(UserBuffer[Count].NewName, szUserName);
Count++;
}
// Check if we have to re-allocate buffer
if (Count >= NumRecs) {
NumRecs += DEF_NUM_RECS;
Users = (USER_LIST *) ReallocMemory((HGLOBAL) Users, sizeof(USER_LIST) + (sizeof(USER_BUFFER) * NumRecs));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
break;
}
UserBuffer = Users->UserBuffer;
}
}
i++;
}
} else // if NWReadPropertyValue
byMoreSegments = 0;
} while (byMoreSegments);
// Gotta clear this out from the last loop
if (Count)
ret = 0;
}
// check if error occured...
if (ret)
status = ret;
// Now slim down the list to just what we need.
if (!status) {
Users = (USER_LIST *) ReallocMemory((HGLOBAL) Users, sizeof(USER_LIST) + (sizeof(USER_BUFFER) * Count));
if (!Users)
status = ERROR_NOT_ENOUGH_MEMORY;
else {
// Sort the server list before putting it in the dialog
UserBuffer = Users->UserBuffer;
qsort((void *) UserBuffer, (size_t) Count, sizeof(USER_BUFFER), UserListCompare);
}
}
if (Users != NULL)
Users->Count = Count;
*lpUsers = Users;
return status;
} // NWUserEquivalenceEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NWFileRightsEnum(
LPTSTR FileName,
USER_RIGHTS_LIST **lpUsers,
DWORD *UserCount,
BOOL DownLevel
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
BOOL Continue = TRUE;
USER_RIGHTS_LIST *Users = NULL;
DWORD NumRecs = DEF_NUM_RECS; // Default 200 names
DWORD Count = 0;
DWORD i = 0;
DWORD status = 0;
char szAnsiUserName[MAX_USER_NAME_LEN + 1];
char szAnsiSearchDir[MAX_PATH + 1];
TCHAR szUserName[MAX_USER_NAME_LEN + 1];
WORD wFoundUserType = 0;
NWCCODE ret;
char FoundDir[16];
ULONG Entries;
TRUSTEE_INFO ti[20];
BYTE DirHandle, nDirHandle;
BYTE Sequence;
BYTE NumEntries = 0;
NWDATE_TIME dtime = 0;
NWOBJ_ID ownerID = 0;
if (DownLevel) {
Entries = 5;
Sequence = 1;
} else {
Entries = 20;
Sequence = 0;
}
DirHandle = nDirHandle = 0;
memset(ti, 0, sizeof(ti));
Users = (USER_RIGHTS_LIST *) AllocMemory(NumRecs * sizeof(USER_RIGHTS_LIST));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
// init to NULL so doesn't have garbage if call fails
lstrcpyA(szAnsiUserName, "");
CharToOem(FileName, szAnsiSearchDir);
// Loop through bindery getting all the users.
do {
if (DownLevel)
ret = NWCScanDirectoryForTrustees2(CachedConn, nDirHandle, szAnsiSearchDir,
&Sequence, FoundDir, &dtime, &ownerID, ti);
else
ret = NWCScanForTrustees(CachedConn, nDirHandle, szAnsiSearchDir,
&Sequence, &NumEntries, ti);
if (!ret) {
// loop through properties converting them to user names
for (i = 0; i < Entries; i++) {
if (ti[i].objectID != 0) {
if (!(ret = NWGetObjectName(CachedConn, ti[i].objectID, szAnsiUserName, &wFoundUserType))) {
// Got user - now convert and save off the information
OemToChar(szAnsiUserName, szUserName);
lstrcpy(Users[Count].Name, szUserName);
Users[Count].Rights = ti[i].objectRights;
Count++;
// Check if we have to re-allocate buffer
if (Count >= NumRecs) {
NumRecs += DEF_NUM_RECS;
Users = (USER_RIGHTS_LIST *) ReallocMemory((HGLOBAL) Users, NumRecs * sizeof(USER_RIGHTS_LIST));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
break;
}
} // if realloc buffer
}
} // if objectID != 0
}
} else // NWScan failed
Continue = FALSE;
} while (Continue);
// Gotta clear this out from the last loop
if (Count)
ret = 0;
}
// check if error occured...
if (ret) {
status = ret;
if (Users != NULL) {
FreeMemory(Users);
Count = 0;
}
}
// Now slim down the list to just what we need.
if (!status) {
Users = (USER_RIGHTS_LIST *) ReallocMemory((HGLOBAL) Users, Count * sizeof(USER_RIGHTS_LIST));
if (!Users)
status = ERROR_NOT_ENOUGH_MEMORY;
else
// Sort the server list before putting it in the dialog
qsort((void *) Users, (size_t) Count, sizeof(USER_RIGHTS_LIST), UserListCompare);
}
*UserCount = Count;
*lpUsers = Users;
return status;
} // NWFileRightsEnum
/////////////////////////////////////////////////////////////////////////
VOID
NWLoginTimesMap(
BYTE *Times,
BYTE *NewTimes
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
DWORD i, j;
int Bit = 0;
int Val;
BYTE BitSet;
for (i = 0; i < 21; i++) {
BitSet = 0;
for (j = 0; j < 8; j++) {
if (BitTest(Bit, Times) || BitTest(Bit+1, Times)) {
Val = 0x1 << j;
BitSet = BitSet + (BYTE) Val;
}
Bit++; Bit++;
}
NewTimes[i] = BitSet;
}
} // NWLoginTimesMap
/*+-------------------------------------------------------------------------+
| Time Conversion |
+-------------------------------------------------------------------------+*/
#define IS_LEAP(y) ((y % 4 == 0) && (y % 100 != 0 || y % 400 == 0))
#define DAYS_IN_YEAR(y) (IS_LEAP(y) ? 366 : 365)
#define DAYS_IN_MONTH(m,y) (IS_LEAP(y) ? _days_month_leap[m] : _days_month[m])
#define SECS_IN_DAY (60L * 60L * 24L)
#define SECS_IN_HOUR (60L * 60L)
#define SECS_IN_MINUTE (60L)
static short _days_month_leap[] = { 31,29,31,30,31,30,31,31,30,31,30,31 };
static short _days_month[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
/////////////////////////////////////////////////////////////////////////
BOOL
NWTimeMap(
DWORD Days,
DWORD dwMonth,
DWORD dwYear,
DWORD dwBasis,
ULONG *Time
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
DWORD dw = 0;
DWORD dwDays = 0;
// Zero
*Time = 0L;
// Adjust year
if(dwYear < 70)
dwYear += 2000L;
else
if(dwYear < 100)
dwYear += 1900L;
if (dwYear < dwBasis)
return FALSE;
// Calculate days in previous years, take -1 so we skip current year
dw = dwYear - 1;
while(dw >= dwBasis) {
dwDays += DAYS_IN_YEAR(dw);
--dw;
}
// Days from month
if((dwMonth < 1)||(dwMonth > 12))
return FALSE;
// Loop through adding number of days in each month. Take -2 (-1 to skip
// current month, and -1 to make 0 based).
dw = dwMonth;
while(dw > 1) {
dwDays += DAYS_IN_MONTH(dw-2, dwYear);
--dw;
}
// Convert days
dw = Days;
if((dw >= 1) && (dw <= (DWORD) DAYS_IN_MONTH(dwMonth - 1, dwYear)))
dwDays += dw;
else
return FALSE; // out of range
*Time += dwDays * SECS_IN_DAY;
return TRUE;
} // NWTimeMap
/////////////////////////////////////////////////////////////////////////
LPTSTR
NWUserNameGet(
LPTSTR szUserName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR UserName[128];
char szAnsiUserName[MAX_USER_NAME_LEN];
NWCCODE ret;
BYTE bySegment[128];
BYTE byMoreSegments, byPropertyFlags;
LPSTR szAnsiFullName;
CharToOem(szUserName, szAnsiUserName);
ret = NWReadPropertyValue(CachedConn, szAnsiUserName, OT_USER, IDENTIFICATION,
1, bySegment, &byMoreSegments, &byPropertyFlags);
if (ret == SUCCESSFUL) {
szAnsiFullName = (LPSTR) bySegment;
OemToChar(szAnsiFullName, UserName);
return UserName;
}
return NULL;
} // NWUserNameGet
/////////////////////////////////////////////////////////////////////////
VOID
NWNetUserMapInfo (
LPTSTR szUserName,
VOID *UInfo,
NT_USER_INFO *NT_UInfo
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
ULONG expires;
struct tagLoginControl *tag;
LPTSTR FullName;
tag = (struct tagLoginControl *) UInfo;
FullName = NWUserNameGet(szUserName);
if (FullName != NULL)
lstrcpyn(NT_UInfo->full_name, FullName, MAXCOMMENTSZ);
// Account disabled
if (tag->byAccountDisabled)
NT_UInfo->flags = NT_UInfo->flags | 0x02;
// account locked out
if ((tag->wBadLogins == 0xffff) &&
(tag->lNextResetTime > (LONG)CachedServerTime))
NT_UInfo->flags = NT_UInfo->flags | 0x02; // disable account...
// user can change password
if ((tag->byRestrictions & 0x01))
NT_UInfo->flags = NT_UInfo->flags | 0x40;
NWLoginTimesMap(tag->byLoginTimes, NT_UInfo->logon_hours);
// account expires
if (tag->byAccountExpires[0] == 0)
NT_UInfo->acct_expires = TIMEQ_FOREVER;
else
if (tag->byAccountExpires[0] < 70)
NT_UInfo->acct_expires = 0;
else {
// fits within time range so convert to #seconds since 1970
expires = 0;
NWTimeMap((DWORD) tag->byAccountExpires[2],
(DWORD) tag->byAccountExpires[1],
(DWORD) tag->byAccountExpires[0], 1970, &expires);
NT_UInfo->acct_expires = expires;
}
} // NWNetUserMapInfo
/////////////////////////////////////////////////////////////////////////
VOID
NWFPNWMapInfo(
VOID *NWUInfo,
PFPNW_INFO fpnw
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
struct tagLoginControl *tag;
tag = (struct tagLoginControl *) NWUInfo;
fpnw->MaxConnections = tag->wMaxConnections;
fpnw->PasswordInterval = tag->wPasswordInterval;
fpnw->GraceLoginAllowed = tag->byGraceLogins;
fpnw->GraceLoginRemaining = tag->byGraceLoginReset;
fpnw->LoginFrom = NULL;
fpnw->HomeDir = NULL;
} // NWFPNWMapInfo
/////////////////////////////////////////////////////////////////////////
VOID
NWUserDefaultsGet(
VOID **UDefaults
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
struct tagUserDefaults *UserDefaults = NULL;
NWCCODE ret;
BYTE bySegment[128];
BYTE byMoreSegments, byPropertyFlags;
ret = NWReadPropertyValue(CachedConn, SUPERVISOR, OT_USER, USER_DEFAULTS, 1, bySegment, &byMoreSegments, &byPropertyFlags);
if (ret == SUCCESSFUL) {
UserDefaults = AllocMemory(sizeof(struct tagUserDefaults));
memcpy(UserDefaults, bySegment, sizeof (struct tagUserDefaults));
// Now put the data in 'normal' Intel format
SWAPBYTES(UserDefaults->wPasswordInterval);
SWAPBYTES(UserDefaults->wMaxConnections);
SWAPWORDS(UserDefaults->lBalance);
SWAPWORDS(UserDefaults->lCreditLimit);
SWAPWORDS(UserDefaults->lMaxDiskBlocks);
}
*UDefaults = (void *) UserDefaults;
} // NWUserDefaultsGet
/////////////////////////////////////////////////////////////////////////
VOID
NWUserDefaultsMap(
VOID *NWUDefaults,
NT_DEFAULTS *NTDefaults
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
struct tagUserDefaults *UserDefaults = NULL;
if ((NWUDefaults == NULL) || (NTDefaults == NULL))
return;
UserDefaults = (struct tagUserDefaults *) NWUDefaults;
NTDefaults->min_passwd_len = (DWORD) UserDefaults->byMinPasswordLength;
NTDefaults->max_passwd_age = (DWORD) UserDefaults->wPasswordInterval * 86400;
NTDefaults->force_logoff = (DWORD) UserDefaults->byGraceLoginReset;
// These fields aren't used/converted
// NTDefaults->min-passwd_age - no such thing for NetWare
// NTDefaults->password_hist_len - no such thing for NetWare
} // NWUserDefaultsMap
/////////////////////////////////////////////////////////////////////////
VOID
NWLoginTimesLog(
BYTE *Times
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
TCHAR *szDays[7];
DWORD Day;
DWORD Hours;
int Bit = 0, i;
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_104));
// while these should be level 2, there isn't room on 80 cols - so level 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++) {
for (i = 0; i < 2; i++) {
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));
} // NWLoginTimesLog
/////////////////////////////////////////////////////////////////////////
VOID
NWUserDefaultsLog(
VOID *UDefaults
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
struct tagUserDefaults *tag;
tag = (struct tagUserDefaults *) UDefaults;
// Account expires
LogWriteLog(1, Lids(IDS_L_109));
if (tag->byAccountExpiresYear == 0)
LogWriteLog(0, Lids(IDS_L_107));
else
LogWriteLog(0, TEXT("%02u/%02u/%04u"), (UINT) tag->byAccountExpiresDay,
(UINT) tag->byAccountExpiresMonth, (UINT) 1900 + tag->byAccountExpiresYear);
LogWriteLog(0, Lids(IDS_CRLF));
// Restrictions
LogWriteLog(1, Lids(IDS_L_110));
// user can change password
if ((tag->byRestrictions & 0x01))
LogWriteLog(2, Lids(IDS_L_111));
else
LogWriteLog(2, Lids(IDS_L_112));
// unique password required
if ((tag->byRestrictions & 0x02))
LogWriteLog(2, Lids(IDS_L_113), Lids(IDS_YES));
else
LogWriteLog(2, Lids(IDS_L_113), Lids(IDS_NO));
// Password interval
LogWriteLog(1, Lids(IDS_L_114));
if (tag->wPasswordInterval == 0)
LogWriteLog(0, Lids(IDS_L_107));
else
LogWriteLog(0, TEXT("%u"), (UINT) tag->wPasswordInterval);
LogWriteLog(0, Lids(IDS_CRLF));
// Grace Logins
LogWriteLog(1, Lids(IDS_L_115));
if (tag->byGraceLoginReset == 0xff)
LogWriteLog(0, Lids(IDS_L_108));
else
LogWriteLog(0, TEXT("%u"), (UINT) tag->byGraceLoginReset);
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(1, Lids(IDS_L_116), (UINT) tag->byMinPasswordLength);
// Max Connections
LogWriteLog(1, Lids(IDS_L_117));
if (tag->wMaxConnections == 0)
LogWriteLog(0, Lids(IDS_L_108));
else
LogWriteLog(0, TEXT("%u"), (UINT) tag->wMaxConnections);
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(1, Lids(IDS_L_118), (ULONG) tag->lBalance);
LogWriteLog(1, Lids(IDS_L_119), (ULONG) tag->lCreditLimit);
// Max Disk blocks
LogWriteLog(1, Lids(IDS_L_120));
if (tag->lMaxDiskBlocks == 0x7FFFFFFF)
LogWriteLog(0, Lids(IDS_L_108));
else
LogWriteLog(0, TEXT("%lu"), (ULONG) tag->lMaxDiskBlocks);
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(0, Lids(IDS_CRLF));
} // NWUserDefaultsLog
/////////////////////////////////////////////////////////////////////////
VOID
NWUserInfoLog(
LPTSTR szUserName,
VOID *UInfo
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
struct tagLoginControl *tag;
LPTSTR FullName;
tag = (struct tagLoginControl *) UInfo;
LogWriteLog(1, Lids(IDS_L_105));
// Full Name
LogWriteLog(2, Lids(IDS_L_106));
FullName = NWUserNameGet(szUserName);
if (FullName != NULL)
LogWriteLog(2, FullName);
LogWriteLog(0, Lids(IDS_CRLF));
// Account disabled
if (tag->byAccountDisabled == 0xff)
LogWriteLog(2, Lids(IDS_L_121), Lids(IDS_YES));
else if ((tag->wBadLogins == 0xffff) &&
(tag->lNextResetTime > (LONG)CachedServerTime))
LogWriteLog(2, Lids(IDS_L_121), Lids(IDS_LOCKED_OUT));
else
LogWriteLog(2, Lids(IDS_L_121), Lids(IDS_NO));
// Account expires
LogWriteLog(2, Lids(IDS_L_109));
if (tag->byAccountExpires[0] == 0)
LogWriteLog(0, Lids(IDS_L_107));
else
LogWriteLog(0, TEXT("%02u/%02u/%04u"), (UINT) tag->byAccountExpires[1],
(UINT) tag->byAccountExpires[2], (UINT) 1900 + tag->byAccountExpires[0]);
LogWriteLog(0, Lids(IDS_CRLF));
// Password Expires
LogWriteLog(2, Lids(IDS_L_122));
if (tag->byPasswordExpires[0] == 0)
LogWriteLog(0, Lids(IDS_L_107));
else
LogWriteLog(0, TEXT("%02u/%02u/19%02u"), (int) tag->byPasswordExpires[1],
(int) tag->byPasswordExpires[2], (int) tag->byPasswordExpires[0]);
LogWriteLog(0, Lids(IDS_CRLF));
// Grace logins
LogWriteLog(2, Lids(IDS_L_123));
if (tag->byGraceLogins == 0xff)
LogWriteLog(0, Lids(IDS_L_108));
else
LogWriteLog(0, TEXT("%u"), (UINT) tag->byGraceLogins);
LogWriteLog(0, Lids(IDS_CRLF));
// initial grace logins
LogWriteLog(2, Lids(IDS_L_115));
if (tag->byGraceLoginReset == 0xff)
LogWriteLog(0, Lids(IDS_L_108));
else
LogWriteLog(0, TEXT("%u"), (UINT) tag->byGraceLoginReset);
LogWriteLog(0, Lids(IDS_CRLF));
// Min password length
LogWriteLog(2, Lids(IDS_L_116), (UINT) tag->byMinPasswordLength);
// Password expiration
LogWriteLog(2, Lids(IDS_L_114));
if (tag->wPasswordInterval == 0)
LogWriteLog(0, Lids(IDS_L_107));
else
LogWriteLog(0, TEXT("%u"), (UINT) tag->wPasswordInterval);
LogWriteLog(0, Lids(IDS_CRLF));
// Max connections
LogWriteLog(2, Lids(IDS_L_117));
if (tag->wMaxConnections == 0)
LogWriteLog(0, Lids(IDS_L_108));
else
LogWriteLog(0, TEXT("%u"), (UINT) tag->wMaxConnections);
LogWriteLog(0, Lids(IDS_CRLF));
// Restrictions
// user can change password
LogWriteLog(2, Lids(IDS_L_110));
if ((tag->byRestrictions & 0x01))
LogWriteLog(3, Lids(IDS_L_111));
else
LogWriteLog(3, Lids(IDS_L_112));
// unique password required
if ((tag->byRestrictions & 0x02))
LogWriteLog(3, Lids(IDS_L_113), Lids(IDS_YES));
else
LogWriteLog(3, Lids(IDS_L_113), Lids(IDS_NO));
LogWriteLog(2, Lids(IDS_L_124), (UINT) tag->wBadLogins);
// Max Disk Blocks
LogWriteLog(2, Lids(IDS_L_120));
if (tag->lMaxDiskBlocks == 0x7FFFFFFF)
LogWriteLog(0, Lids(IDS_L_108));
else
LogWriteLog(0, TEXT("%lX"), tag->lMaxDiskBlocks);
LogWriteLog(0, Lids(IDS_CRLF));
// Login Times
NWLoginTimesLog(tag->byLoginTimes);
} // NWUserInfoLog
/////////////////////////////////////////////////////////////////////////
VOID
NWUserInfoGet(
LPTSTR szUserName,
VOID **UInfo
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static struct tagLoginControl xUI;
struct tagLoginControl *UserInfo = NULL;
char szAnsiUserName[MAX_USER_NAME_LEN];
NWCCODE ret;
BYTE bySegment[128];
BYTE byMoreSegments, byPropertyFlags;
CharToOem(szUserName, szAnsiUserName);
ret = NWReadPropertyValue(CachedConn, szAnsiUserName, OT_USER, LOGIN_CONTROL, 1, bySegment, &byMoreSegments, &byPropertyFlags);
if (ret == SUCCESSFUL) {
UserInfo = &xUI;
memset(UserInfo, 0, sizeof(struct tagLoginControl));
memcpy(UserInfo, bySegment, sizeof (struct tagLoginControl));
// Now put the data in 'normal' Intel format
SWAPBYTES(UserInfo->wPasswordInterval);
SWAPBYTES(UserInfo->wMaxConnections);
SWAPWORDS(UserInfo->lMaxDiskBlocks);
SWAPBYTES(UserInfo->wBadLogins);
SWAPWORDS(UserInfo->lNextResetTime);
}
*UInfo = (void *) UserInfo;
} // NWUserInfoGet
/////////////////////////////////////////////////////////////////////////
DWORD
NWServerEnum(
LPTSTR Container,
SERVER_BROWSE_LIST **lpServList
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
int NumBufs = 0;
DWORD TotalEntries = 0;
ENUM_REC *BufHead, *CurrBuf, *OldBuf;
SERVER_BROWSE_LIST *ServList = NULL;
SERVER_BROWSE_BUFFER *SList = NULL;
DWORD status = 0;
DWORD i, j;
NETRESOURCE ResourceBuf;
// Container is ignored - NW is a flat network topology...
SetProvider(NW_PROVIDER, &ResourceBuf);
BufHead = CurrBuf = OldBuf = NULL;
status = EnumBufferBuild(&BufHead, &NumBufs, ResourceBuf);
if (!status) {
// We have 0 to xxx Enum recs each with a buffer sitting off of it. Now
// need to consolidate these into one global enum list...
if (NumBufs) {
CurrBuf = BufHead;
// Figure out how many total entries there are
while (CurrBuf) {
TotalEntries += CurrBuf->cEntries;
CurrBuf = CurrBuf->next;
}
CurrBuf = BufHead;
// Now create a Server List to hold all of these.
ServList = AllocMemory(sizeof(SERVER_BROWSE_LIST) + TotalEntries * sizeof(SERVER_BROWSE_BUFFER));
if (ServList == NULL) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
ServList->Count = TotalEntries;
SList = (SERVER_BROWSE_BUFFER *) &ServList->SList;
j = 0;
// Now loop through copying the data...
while (CurrBuf) {
for(i = 0; i < CurrBuf->cEntries; i++) {
if (CurrBuf->lpnr[i].lpRemoteName != NULL)
if (CurrBuf->lpnr[i].lpRemoteName[0] == TEXT('\\') && CurrBuf->lpnr[i].lpRemoteName[1] == TEXT('\\'))
lstrcpy(SList[j].Name, &CurrBuf->lpnr[i].lpRemoteName[2]);
else
lstrcpy(SList[j].Name, CurrBuf->lpnr[i].lpRemoteName);
else
lstrcpy(SList[j].Name, TEXT(""));
if (CurrBuf->lpnr[i].lpComment != NULL)
lstrcpy(SList[j].Description, CurrBuf->lpnr[i].lpComment);
else
lstrcpy(SList[j].Description, TEXT(""));
SList[j].Container = FALSE;
j++;
}
OldBuf = CurrBuf;
CurrBuf = CurrBuf->next;
// Free the old buffer
FreeMemory((HGLOBAL) OldBuf);
} // while
} // else (ServList)
} // if (numbufs)
}
*lpServList = ServList;
return status;
} // NWServerEnum
/////////////////////////////////////////////////////////////////////////
ULONG
NWShareSizeGet(
LPTSTR Share
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR RootPath[MAX_PATH + 1];
DWORD sectorsPC, bytesPS, FreeClusters, Clusters;
DWORD TotalSpace, FreeSpace;
TotalSpace = FreeSpace = 0;
wsprintf(RootPath, TEXT("\\\\%s\\%s\\"), CachedServer, Share);
if (GetDiskFreeSpace(RootPath, &sectorsPC, &bytesPS, &FreeClusters, &Clusters)) {
TotalSpace = Clusters * sectorsPC * bytesPS;
FreeSpace = FreeClusters * sectorsPC * bytesPS;
}
// total - free = approx allocated space (if multiple shares on drive then
// this doesn't take that into account, we just want an approximation...
return TotalSpace - FreeSpace;
} // NWShareSizeGet
/////////////////////////////////////////////////////////////////////////
DWORD
NWSharesEnum(
SHARE_LIST **lpShares
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
int NumBufs = 0;
DWORD TotalEntries = 0;
ENUM_REC *BufHead, *CurrBuf, *OldBuf;
SHARE_LIST *ShareList = NULL;
SHARE_BUFFER *SList = NULL;
DWORD status;
DWORD i, j;
NETRESOURCE ResourceBuf;
// Setup NETRESOURCE data structure
SetProvider(NW_PROVIDER, &ResourceBuf);
ResourceBuf.lpRemoteName = CachedServer;
ResourceBuf.dwUsage = RESOURCEUSAGE_CONTAINER;
status = EnumBufferBuild(&BufHead, &NumBufs, ResourceBuf);
if (!status) {
// We have 0 to xxx Enum recs each with a buffer sitting off of it. Now
// need to consolidate these into one global enum list...
if (NumBufs) {
CurrBuf = BufHead;
// Figure out how many total entries there are
while (CurrBuf) {
TotalEntries += CurrBuf->cEntries;
CurrBuf = CurrBuf->next;
}
CurrBuf = BufHead;
// Now create a Server List to hold all of these.
ShareList = (SHARE_LIST *) AllocMemory(sizeof(SHARE_LIST) + (TotalEntries * sizeof(SHARE_BUFFER)));
if (ShareList == NULL) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
j = 0;
// Zero out everything and get pointer to list
memset(ShareList, 0, sizeof(SHARE_LIST) + (TotalEntries * sizeof(SHARE_BUFFER)));
ShareList->Count = TotalEntries;
SList = (SHARE_BUFFER *) &ShareList->SList;
// Now loop through copying the data...
while (CurrBuf) {
for(i = 0; i < CurrBuf->cEntries; i++) {
if (CurrBuf->lpnr[i].lpRemoteName != NULL)
lstrcpy(SList[j].Name, ShareNameParse(CurrBuf->lpnr[i].lpRemoteName));
else
lstrcpy(SList[j].Name, TEXT(""));
SList[j].Size = NWShareSizeGet(SList[j].Name);
SList[j].Index = (USHORT) j;
j++;
}
OldBuf = CurrBuf;
CurrBuf = CurrBuf->next;
// Free the old buffer
FreeMemory((HGLOBAL) OldBuf);
} // while
} // else (ShareList)
} // if (numbufs)
}
*lpShares = ShareList;
return status;
} // NWSharesEnum
/////////////////////////////////////////////////////////////////////////
VOID
NWServerInfoReset(
SOURCE_SERVER_BUFFER *SServ
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static VERSION_INFO NWInfo;
NWCCODE ret = 0;
ret = NWGetFileServerVersionInfo(CachedConn, &NWInfo);
// BUGBUG: This API returns fail (8801) - but is actually succeding,
// just ignore error for right now as it really doesn't matter for the
// version info.
// if (ret == SUCCESSFUL) {
SServ->VerMaj = NWInfo.Version;
SServ->VerMin = NWInfo.SubVersion;
// }
} // NWServerInfoReset
/////////////////////////////////////////////////////////////////////////
VOID
NWServerInfoSet(
LPTSTR ServerName,
SOURCE_SERVER_BUFFER *SServ
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static VERSION_INFO NWInfo;
NWCCODE ret = 0;
CursorHourGlass();
lstrcpy(SServ->Name, ServerName);
NWServerInfoReset(SServ);
// Fill in share list
NWSharesEnum(&SServ->ShareList);
#ifdef DEBUG
{
DWORD i;
dprintf(TEXT("Adding NW Server: %s\n"), SServ->Name);
dprintf(TEXT(" Version: %u.%u\n"), (UINT) SServ->VerMaj, (UINT) SServ->VerMin);
dprintf(TEXT(" Shares\n"));
dprintf(TEXT(" +---------------------------------------+\n"));
if (SServ->ShareList) {
for (i = 0; i < SServ->ShareList->Count; i++) {
dprintf(TEXT(" %-15s AllocSpace %lu\n"), SServ->ShareList->SList[i].Name, SServ->ShareList->SList[i].Size);
}
}
else
dprintf(TEXT(" <Serv List enum failed!!>\n"));
dprintf(TEXT("\n"));
}
#endif
CursorNormal();
} // NWServerInfoSet
/////////////////////////////////////////////////////////////////////////
BOOL
NWServerValidate(
HWND hWnd,
LPTSTR ServerName,
BOOL DupFlag
)
/*++
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:
--*/
{
DWORD Status;
BOOL ret = FALSE;
SOURCE_SERVER_BUFFER *SServ = NULL;
DWORD dwObjectID = 0;
DWORD Size;
BYTE AccessLevel;
TCHAR UserName[MAX_USER_NAME_LEN + 1];
static TCHAR LocServer[MAX_SERVER_NAME_LEN+3];
LPVOID lpMessageBuffer;
CursorHourGlass();
if (DupFlag)
SServ = SServListFind(ServerName);
if (SServ == NULL) {
// Get Current Logged On User
lstrcpy(UserName, TEXT(""));
Size = sizeof(UserName);
WNetGetUser(NULL, UserName, &Size);
lstrcpy(LocServer, TEXT("\\\\"));
lstrcat(LocServer, ServerName);
if (UseAddPswd(hWnd, UserName, LocServer, Lids(IDS_S_6), NW_PROVIDER)) {
Status = NWServerSet(ServerName);
if (Status) {
if (GetLastError() != 0)
WarningError(Lids(IDS_NWCANT_CON), ServerName);
} else {
if (IsNCPServerFPNW(CachedConn))
WarningError(Lids(IDS_E_18), ServerName);
else {
Status = NWCGetBinderyAccessLevel(CachedConn, &AccessLevel, &dwObjectID);
if (!Status) {
AccessLevel &= BS_SUPER_READ;
if (AccessLevel == BS_SUPER_READ)
ret = TRUE;
else
WarningError(Lids(IDS_NWNO_ADMIN), ServerName);
}
}
}
} else {
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(), 0,
(LPTSTR) &lpMessageBuffer, 0, NULL );
if (GetLastError() != 0)
WarningError(Lids(IDS_E_9), ServerName, lpMessageBuffer);
LocalFree(lpMessageBuffer);
}
} else {
// Already in source server list - can't appear more then once
WarningError(Lids(IDS_E_14), ServerName);
}
CursorNormal();
return ret;
} // NWServerValidate
/////////////////////////////////////////////////////////////////////////
LPTSTR
NWRightsLog(
DWORD Rights
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
static TCHAR NWRights[15];
lstrcpy(NWRights, Lids(IDS_S_34));
// Read
if (!(Rights & 0x01))
NWRights[2] = TEXT(' ');
// Write
if (!(Rights & 0x02))
NWRights[3] = TEXT(' ');
// Create
if (!(Rights & 0x08))
NWRights[4] = TEXT(' ');
// Delete (Erase)
if (!(Rights & 0x10))
NWRights[5] = TEXT(' ');
// Parental
if (!(Rights & 0x20))
NWRights[8] = TEXT(' ');
// Search
if (!(Rights & 0x40))
NWRights[7] = TEXT(' ');
// Modify
if (!(Rights & 0x80))
NWRights[6] = TEXT(' ');
// Supervisor (all rights set)
if ((Rights & 0xFB) != 0xFB)
NWRights[1] = TEXT(' ');
return NWRights;
} // NWRightsLog
/////////////////////////////////////////////////////////////////////////
NTSTATUS
MapNwRightsToNTAccess(
ULONG NWRights,
PRIGHTS_MAPPING pMap,
ACCESS_MASK *pAccessMask
)
/*++
Routine Description:
Map a NW Right to the appropriate NT AccessMask
Arguments:
NWRights - Netware rights we wish to map
pMap - pointer to structure that defines the mapping
Return Value:
The NT AccessMask corresponding to the NW Rights
--*/
{
PNW_TO_NT_MAPPING pNWToNtMap = pMap->Nw2NtMapping ;
ACCESS_MASK AccessMask = 0 ;
if (!pAccessMask)
return STATUS_INVALID_PARAMETER ;
*pAccessMask = 0x0 ;
// go thru the mapping structuring, OR-ing in bits along the way
while (pNWToNtMap->NWRight) {
if (pNWToNtMap->NWRight & NWRights)
AccessMask |= pNWToNtMap->NTAccess ;
pNWToNtMap++ ;
}
*pAccessMask = AccessMask ;
return STATUS_SUCCESS ;
} // MapNwRightsToNTAccess
/////////////////////////////////////////////////////////////////////////
DWORD
NWPrintServersEnum(
PRINT_SERVER_LIST **PS
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
PRINT_SERVER_LIST *psl;
PRINT_SERVER_BUFFER *pbuff;
DWORD NumRecs = DEF_NUM_RECS; // Default 200 names
DWORD Count = 0;
DWORD status = 0;
char szAnsiPrinterName[MAX_USER_NAME_LEN + 1];
TCHAR szPrinterName[MAX_USER_NAME_LEN + 1];
WORD wFoundUserType = 0;
DWORD dwObjectID = 0xFFFFFFFFL;
BYTE byPropertiesFlag = 0;
BYTE byObjectFlag = 0;
BYTE byObjectSecurity = 0;
NWCCODE ret;
psl = (PRINT_SERVER_LIST *) AllocMemory(sizeof(PRINT_SERVER_LIST) + (NumRecs * sizeof(PRINT_SERVER_BUFFER)));
if (!psl) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
pbuff = psl->PSList;
// init to NULL so doesn't have garbage if call fails
lstrcpyA(szAnsiPrinterName, "");
// Loop through bindery getting all the users.
while ((ret = NWScanObject(CachedConn, "*", OT_PRINT_SERVER, &dwObjectID, szAnsiPrinterName,
&wFoundUserType, &byPropertiesFlag,
&byObjectFlag, &byObjectSecurity)) == SUCCESSFUL) {
// Got user - now convert and save off the information
OemToChar(szAnsiPrinterName, szPrinterName);
lstrcpy(pbuff[Count].Name, szPrinterName);
Count++;
// Check if we have to re-allocate buffer
if (Count >= NumRecs) {
NumRecs += DEF_NUM_RECS;
psl = (PRINT_SERVER_LIST *) ReallocMemory((HGLOBAL) psl, sizeof(PRINT_SERVER_LIST) + (NumRecs * sizeof(PRINT_SERVER_BUFFER)));
pbuff = psl->PSList;
if (!psl) {
status = ERROR_NOT_ENOUGH_MEMORY;
break;
}
}
}
// Gotta clear this out from the last loop
if (Count)
ret = 0;
}
// check if error occured...
if (ret)
status = ret;
// Now slim down the list to just what we need.
if (!status) {
psl = (PRINT_SERVER_LIST *) ReallocMemory((HGLOBAL) psl, sizeof(PRINT_SERVER_LIST) + (Count * sizeof(PRINT_SERVER_BUFFER)));
if (!psl)
status = ERROR_NOT_ENOUGH_MEMORY;
}
psl->Count = Count;
*PS = psl;
return status;
} // NWPrintServersEnum
/////////////////////////////////////////////////////////////////////////
DWORD
NWPrintOpsEnum(
USER_LIST **lpUsers
)
/*++
Routine Description:
First need to enumerate all the print servers on the NetWare system
we are pointing to. Next loop through each of these print servers
and enumerate the print operators on each of them.
Arguments:
Return Value:
--*/
{
PRINT_SERVER_LIST *psl = NULL;
PRINT_SERVER_BUFFER *PSList;
ULONG pCount;
USER_LIST *Users = NULL;
USER_BUFFER *UserBuffer;
DWORD NumRecs = DEF_NUM_RECS; // Default 200 names
DWORD Count = 0;
DWORD ipsl = 0, iseg = 0;
DWORD status = 0;
char szAnsiUserName[MAX_USER_NAME_LEN + 1];
char szAnsiName[MAX_GROUP_NAME_LEN + 1];
TCHAR szUserName[MAX_USER_NAME_LEN + 1];
WORD wFoundUserType = 0;
DWORD dwObjectID = 0xFFFFFFFFL;
BYTE byPropertyFlags = 0;
BYTE byObjectFlag = 0;
BYTE byObjectSecurity = 0;
UCHAR Segment = 1;
DWORD bySegment[32];
BYTE byMoreSegments;
NWCCODE ret;
*lpUsers = NULL;
// Enumerate the print servers - if there are none, then there are no printer ops
NWPrintServersEnum(&psl);
if ((psl == NULL) || (psl->Count == 0)) {
if (psl != NULL)
FreeMemory(psl);
return 0;
}
// Got some servers - loop through them enumerating users
Users = (USER_LIST *) AllocMemory(sizeof(USER_LIST) + (sizeof(USER_BUFFER) * NumRecs));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
} else {
UserBuffer = Users->UserBuffer;
PSList = psl->PSList;
for (pCount = 0; pCount < psl->Count; pCount++) {
// init to NULL so doesn't have garbage if call fails
lstrcpyA(szAnsiUserName, "");
CharToOem(PSList[ipsl++].Name, szAnsiName);
// Loop through bindery getting all the users.
do {
if (!(ret = NWReadPropertyValue(CachedConn, szAnsiName, OT_PRINT_SERVER, PS_OPERATORS,
Segment, (BYTE *) bySegment, &byMoreSegments, &byPropertyFlags))) {
Segment++;
// loop through properties converting them to user names
iseg = 0;
while ((bySegment[iseg]) && (iseg < 32)) {
if (!(ret = NWGetObjectName(CachedConn, bySegment[iseg], szAnsiUserName, &wFoundUserType))) {
// Got user - now convert and save off the information
OemToChar(szAnsiUserName, szUserName);
// Map out Supervisor (already print-op privs)
if (lstrcmpi(szUserName, Lids(IDS_S_28))) {
lstrcpy(UserBuffer[Count].Name, szUserName);
lstrcpy(UserBuffer[Count].NewName, szUserName);
Count++;
}
// Check if we have to re-allocate buffer
if (Count >= NumRecs) {
NumRecs += DEF_NUM_RECS;
Users = (USER_LIST *) ReallocMemory((HGLOBAL) Users, sizeof(USER_LIST) + (sizeof(USER_BUFFER) * NumRecs));
if (!Users) {
status = ERROR_NOT_ENOUGH_MEMORY;
break;
}
UserBuffer = Users->UserBuffer;
}
}
iseg++;
}
} else // if NWReadPropertyValue
byMoreSegments = 0;
} while (byMoreSegments);
// Gotta clear this out from the last loop
if (Count)
ret = 0;
}
}
// check if error occured...
if (ret)
status = ret;
// Now slim down the list to just what we need.
if (!status) {
Users = (USER_LIST *) ReallocMemory((HGLOBAL) Users, sizeof(USER_LIST) + (sizeof(USER_BUFFER) * Count));
if (!Users)
status = ERROR_NOT_ENOUGH_MEMORY;
else {
// Sort the server list before putting it in the dialog
UserBuffer = Users->UserBuffer;
qsort((void *) UserBuffer, (size_t) Count, sizeof(USER_BUFFER), UserListCompare);
}
}
Users->Count = Count;
*lpUsers = Users;
return status;
} // NWPrintOpsEnum
/////////////////////////////////////////////////////////////////////////
VOID
NWServerTimeGet(
)
/*++
Routine Description:
Queries server for it's current local time which is then converted to
elasped minutes since 1985 in order to compare with the lNextResetTime
field of the LOGIN_CONTROL structure (which must be byte-aligned).
Arguments:
None.
Return Value:
None.
--*/
{
DWORD dwYear = 0;
DWORD dwMonth = 0;
DWORD dwDay = 0;
DWORD dwHour = 0;
DWORD dwMinute = 0;
DWORD dwSecond = 0;
DWORD dwDayOfWeek = 0;
DWORD dwServerTime = 0;
CachedServerTime = 0xffffffff; // re-initialize...
if (!NWGetFileServerDateAndTime(
CachedConn,
(LPBYTE)&dwYear,
(LPBYTE)&dwMonth,
(LPBYTE)&dwDay,
(LPBYTE)&dwHour,
(LPBYTE)&dwMinute,
(LPBYTE)&dwSecond,
(LPBYTE)&dwDayOfWeek))
{
if (NWTimeMap(dwDay, dwMonth, dwYear, 1985, &dwServerTime))
{
dwServerTime += dwHour * 3600;
dwServerTime += dwMinute * 60;
dwServerTime += dwSecond;
CachedServerTime = dwServerTime / 60; // convert to minutes...
}
}
}
/////////////////////////////////////////////////////////////////////////
BOOL
IsNCPServerFPNW(
NWCONN_HANDLE Conn
)
/*++
Routine Description:
Check if this an FPNW server by checking for a specific object
type and property.
Arguments:
Conn - connection id of ncp server.
Return Value:
Returns true if ncp server is fpnw.
--*/
{
NWCCODE ret;
BYTE bySegment[128];
BYTE byMoreSegments, byPropertyFlags;
memset(bySegment, 0, sizeof(bySegment));
ret = NWReadPropertyValue(
CachedConn,
MS_EXTENDED_NCPS,
0x3B06,
FPNW_PDC,
1,
bySegment,
&byMoreSegments,
&byPropertyFlags
);
return (ret == SUCCESSFUL) && (BOOL)(BYTE)bySegment[0];
}
Reference in New Issue Copy Permalink