able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/nw/convert/nwconv/transfer.c

2382 lines
72 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
+-------------------------------------------------------------------------+
| Netware to Windows NT Transfer Loop |
+-------------------------------------------------------------------------+
| (c) Copyright 1993-1994 |
| Microsoft Corp. |
| All rights reserved |
| |
| Program : [Transfer.c] |
| Programmer : Arthur Hanson |
| Original Program Date : [Jul 27, 1993] |
| Last Update : [Jun 16, 1994] |
| |
| Version: 1.00 |
| |
| Description: |
| |
| History: |
| arth June 16, 1994 1.00 Original Version. |
| |
+-------------------------------------------------------------------------+
*/
#include "globals.h"
#include <stdio.h>
#include <stdarg.h>
#include <limits.h>
#include <time.h>
#include "nwconv.h"
#include "convapi.h"
#include "ntnetapi.h"
#include "nwnetapi.h"
#include "userdlg.h"
#include "statbox.h"
#include "filedlg.h"
#include "map.h"
#define NWC_ERR_IGNORE 1
#define NWC_ERR_NAMELONG 2
#define NWC_ERR_DUPLICATE 3
#define NWC_ERR_NAMEINVALID 4
#define ILLEGAL_CHARS TEXT("\"\\/[]:;=,+*?<>")
// define for routines in fcopy.c
void ConvertFiles(HWND hDlg, BOOL TConversion, USER_LIST *Users, GROUP_LIST *Groups);
void ConvertFilesInit(HWND hDlg);
void VSharesCreate(DEST_SERVER_BUFFER *DServ, BOOL TConversion);
// Cache of user and group lists
typedef struct _LIST_CACHE {
struct _LIST_CACHE *next;
ULONG Count;
void *ul;
} LIST_CACHE;
static LIST_CACHE *UserCacheHead = NULL;
static LIST_CACHE *GroupCacheHead = NULL;
// Misc string holders
static LPTSTR LocalName = NULL;
static LPTSTR SourceServer, DestServer;
TCHAR UserServerName[MAX_SERVER_NAME_LEN + 3];
static TCHAR tmpStr[80];
static TCHAR tmpStr2[60];
static TCHAR ErrorText[256];
static TCHAR NewName[256];
static TCHAR pLine[256];
static CONVERT_OPTIONS *ConvOpt = NULL;
static FILE_OPTIONS *FileOptions = NULL;
static BOOL TConversion;
static BOOL WarningDlgForNTFS;
// Totals for stat box
static UINT TotErrors;
static UINT TotGroups;
static UINT TotUsers;
static UINT TotConversions;
UINT TotFiles;
time_t StartTime;
time_t CurrTime;
// User and Group list pointers
static USER_LIST *Users = NULL;
static USER_LIST *NTUsers = NULL;
static GROUP_LIST *Groups = NULL;
static GROUP_LIST *NTGroups = NULL;
static DWORD UserCount, NTUserCount;
static DWORD GroupCount, NTGroupCount;
static BOOL TransferCancel = FALSE;
static MAP_FILE *hMap;
// All of this is used for transfer lists in the conversion
#define USER_SERVER 0
#define USER_SERVER_PDC 1
#define USER_SERVER_TRUSTED 2
typedef struct _TRANSFER_BUFFER {
LPTSTR ServerName;
UINT UserServerType;
CONVERT_LIST *ConvertList;
} TRANSFER_BUFFER;
typedef struct _TRANSFER_LIST {
ULONG Count;
TRANSFER_BUFFER TList[];
} TRANSFER_LIST;
/*+-------------------------------------------------------------------------+
| ErrorIt()
|
+-------------------------------------------------------------------------+*/
void ErrorIt(LPTSTR szFormat, ...) {
static TCHAR tmpStr[1024];
va_list marker;
va_start(marker, szFormat);
wvsprintf(tmpStr, szFormat, marker);
#ifdef DEBUG
dprintf(TEXT("Errorit: %s\n"), tmpStr);
#endif
TotErrors++;
Status_TotErrors(TotErrors);
LogWriteErr(TEXT("%s"),tmpStr);
va_end(marker);
} // ErrorIt
/*+-------------------------------------------------------------------------+
| NTFS Check Routines |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| ShareListNTFSCheck()
|
+-------------------------------------------------------------------------+*/
BOOL ShareListNTFSCheck() {
CONVERT_LIST *ConvList;
DEST_SERVER_BUFFER *DServ;
SOURCE_SERVER_BUFFER *SServ;
SHARE_LIST *ShareList;
SHARE_BUFFER *SList;
VIRTUAL_SHARE_BUFFER *VShare;
DRIVE_BUFFER *Drive;
ULONG i;
FILE_OPTIONS *FileOptions;
// Go through the convert list checking for any shares to non NTFS drives
ConvList = ConvertListStart;
while (ConvList != NULL) {
DServ = ConvList->FileServ;
SServ = ConvList->SourceServ;
FileOptions = (FILE_OPTIONS *) ConvList->FileOptions;
if (FileOptions->TransferFileInfo) {
ShareList = SServ->ShareList;
if (ShareList != NULL) {
SList = ShareList->SList;
for (i = 0; i < ShareList->Count; i++) {
// if not flagged as okay for going to fat, then must check
if (SList[i].Convert && !SList[i].ToFat)
if (SList[i].DestShare != NULL)
if (SList[i].Virtual) {
VShare = (VIRTUAL_SHARE_BUFFER *) SList[i].DestShare;
Drive = VShare->Drive;
if ((Drive == NULL) || (Drive->Type != DRIVE_TYPE_NTFS))
return FALSE;
} else {
Drive = SList[i].DestShare->Drive;
if ((Drive == NULL) || (Drive->Type != DRIVE_TYPE_NTFS))
return FALSE;
}
} // for loop through shares
}
} // if FileOptions
ConvList = ConvList->next;
}
return TRUE;
} // ShareListNTFSCheck
/*+-------------------------------------------------------------------------+
| ShareListNTFSListboxFill()
|
+-------------------------------------------------------------------------+*/
void ShareListNTFSListboxFill(HWND hDlg) {
TCHAR AddLine[256];
CONVERT_LIST *ConvList;
DEST_SERVER_BUFFER *DServ;
SOURCE_SERVER_BUFFER *SServ;
SHARE_LIST *ShareList;
SHARE_BUFFER *SList;
VIRTUAL_SHARE_BUFFER *VShare;
DRIVE_BUFFER *Drive;
ULONG i;
HWND hCtrl;
FILE_OPTIONS *FileOptions;
// Go through the convert list checking for any shares to non NTFS drives
ConvList = ConvertListStart;
hCtrl = GetDlgItem(hDlg, IDC_LIST1);
while (ConvList != NULL) {
DServ = ConvList->FileServ;
SServ = ConvList->SourceServ;
FileOptions = (FILE_OPTIONS *) ConvList->FileOptions;
if (FileOptions->TransferFileInfo) {
ShareList = SServ->ShareList;
if (ShareList != NULL) {
SList = ShareList->SList;
for (i = 0; i < ShareList->Count; i++) {
// if not flagged as okay for going to fat, then must check
if (SList[i].Convert && !SList[i].ToFat)
if (SList[i].DestShare != NULL)
if (SList[i].Virtual) {
VShare = (VIRTUAL_SHARE_BUFFER *) SList[i].DestShare;
Drive = VShare->Drive;
if ((Drive == NULL) || (Drive->Type != DRIVE_TYPE_NTFS)) {
wsprintf(AddLine, TEXT("%s\\%s: -> \\\\%s\\%s"), SServ->Name, SList[i].Name, DServ->Name, VShare->Name);
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
}
} else {
Drive = SList[i].DestShare->Drive;
if ((Drive == NULL) || (Drive->Type != DRIVE_TYPE_NTFS)) {
wsprintf(AddLine, TEXT("%s\\%s: -> \\\\%s\\%s"), SServ->Name, SList[i].Name, DServ->Name, SList[i].DestShare->Name);
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
}
}
} // for loop through shares
}
} // if FileOptions
ConvList = ConvList->next;
}
} // ShareListNTFSListboxFill
/*+-------------------------------------------------------------------------+
| ShareListFATOK()
|
+-------------------------------------------------------------------------+*/
void ShareListFATOK() {
CONVERT_LIST *ConvList;
DEST_SERVER_BUFFER *DServ;
SOURCE_SERVER_BUFFER *SServ;
SHARE_LIST *ShareList;
SHARE_BUFFER *SList;
ULONG i;
FILE_OPTIONS *FileOptions;
// Go through the convert list checking for any shares to non NTFS drives
ConvList = ConvertListStart;
while (ConvList != NULL) {
DServ = ConvList->FileServ;
SServ = ConvList->SourceServ;
FileOptions = (FILE_OPTIONS *) ConvList->FileOptions;
if (FileOptions->TransferFileInfo) {
ShareList = SServ->ShareList;
if (ShareList != NULL) {
SList = ShareList->SList;
for (i = 0; i < ShareList->Count; i++) {
if (SList[i].Convert)
SList[i].ToFat = TRUE;
}
}
} // if FileOptions
ConvList = ConvList->next;
}
} // ShareListFATOK
/*+-------------------------------------------------------------------------+
| Space Check Routines |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| ShareListSpaceCheck()
|
+-------------------------------------------------------------------------+*/
BOOL ShareListSpaceCheck() {
CONVERT_LIST *ConvList;
DEST_SERVER_BUFFER *DServ;
SOURCE_SERVER_BUFFER *SServ;
SHARE_LIST *ShareList;
SHARE_BUFFER *SList;
VIRTUAL_SHARE_BUFFER *VShare;
DRIVE_BUFFER *Drive;
ULONG i;
FILE_OPTIONS *FileOptions;
// Go through the convert list checking for any shares to non NTFS drives
ConvList = ConvertListStart;
while (ConvList != NULL) {
DServ = ConvList->FileServ;
SServ = ConvList->SourceServ;
FileOptions = (FILE_OPTIONS *) ConvList->FileOptions;
if (FileOptions->TransferFileInfo) {
ShareList = SServ->ShareList;
if (ShareList != NULL) {
SList = ShareList->SList;
for (i = 0; i < ShareList->Count; i++) {
if (SList[i].Convert && (SList[i].DestShare != NULL))
if (SList[i].Virtual) {
VShare = (VIRTUAL_SHARE_BUFFER *) SList[i].DestShare;
Drive = VShare->Drive;
if ((Drive == NULL) || (Drive->AllocSpace > Drive->FreeSpace))
return FALSE;
} else {
Drive = SList[i].DestShare->Drive;
if ((Drive == NULL) || (Drive->AllocSpace > Drive->FreeSpace))
return FALSE;
}
} // for loop through shares
}
} // if FileOptions
ConvList = ConvList->next;
}
return TRUE;
} // ShareListSpaceCheck
/*+-------------------------------------------------------------------------+
| ShareListSpaceListboxFill()
|
+-------------------------------------------------------------------------+*/
void ShareListSpaceListboxFill(HWND hDlg) {
TCHAR AddLine[256];
TCHAR Free[25];
CONVERT_LIST *ConvList;
DEST_SERVER_BUFFER *DServ;
SOURCE_SERVER_BUFFER *SServ;
SHARE_LIST *ShareList;
SHARE_BUFFER *SList;
VIRTUAL_SHARE_BUFFER *VShare;
DRIVE_BUFFER *Drive;
ULONG i;
HWND hCtrl;
FILE_OPTIONS *FileOptions;
// Go through the convert list checking for any shares to non NTFS drives
ConvList = ConvertListStart;
hCtrl = GetDlgItem(hDlg, IDC_LIST1);
while (ConvList != NULL) {
DServ = ConvList->FileServ;
SServ = ConvList->SourceServ;
FileOptions = (FILE_OPTIONS *) ConvList->FileOptions;
if (FileOptions->TransferFileInfo) {
ShareList = SServ->ShareList;
if (ShareList != NULL) {
SList = ShareList->SList;
for (i = 0; i < ShareList->Count; i++) {
if (SList[i].Convert && (SList[i].DestShare != NULL))
if (SList[i].Virtual) {
VShare = (VIRTUAL_SHARE_BUFFER *) SList[i].DestShare;
Drive = VShare->Drive;
if (Drive != NULL) {
if (Drive->AllocSpace > Drive->FreeSpace) {
// List shares then space
wsprintf(AddLine, TEXT("%s\\%s: -> \\\\%s\\%s"), SServ->Name, SList[i].Name, DServ->Name, VShare->Name);
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
lstrcpy(Free, lToStr(Drive->FreeSpace));
wsprintf(AddLine, Lids(IDS_D_13), Free, lToStr(Drive->AllocSpace));
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
}
} else {
wsprintf(AddLine, TEXT("%s\\%s: -> \\\\%s\\%s"), SServ->Name, SList[i].Name, DServ->Name, VShare->Name);
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
wsprintf(AddLine, Lids(IDS_D_14));
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
}
} else {
Drive = SList[i].DestShare->Drive;
if (Drive != NULL) {
if (Drive->AllocSpace > Drive->FreeSpace) {
// List shares then space
wsprintf(AddLine, TEXT("%s\\%s: -> \\\\%s\\%s"), SServ->Name, SList[i].Name, DServ->Name, SList[i].DestShare->Name);
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
lstrcpy(Free, lToStr(Drive->FreeSpace));
wsprintf(AddLine, Lids(IDS_D_13), Free, lToStr(Drive->AllocSpace));
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
}
} else {
wsprintf(AddLine, TEXT("%s\\%s: -> \\\\%s\\%s"), SServ->Name, SList[i].Name, DServ->Name, SList[i].DestShare->Name);
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
wsprintf(AddLine, Lids(IDS_D_14));
SendMessage(hCtrl, LB_ADDSTRING, (WPARAM) 0, (LPARAM) AddLine);
}
} // if Virtual
} // for loop through shares
}
} // if FileOptions
ConvList = ConvList->next;
}
} // ShareListSpaceListboxFill
/*+-------------------------------------------------------------------------+
| Conversion Warning Dialog |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| DlgConversionWarning()
|
+-------------------------------------------------------------------------+*/
LRESULT CALLBACK DlgConversionWarning(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
int wmId, wmEvent;
switch (message) {
case WM_INITDIALOG:
// Center the dialog over the application window
CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER));
if (WarningDlgForNTFS) {
SendDlgItemMessage(hDlg, IDC_PANEL1, WM_SETTEXT, 0, (LPARAM) Lids(IDS_D_15));
ShareListNTFSListboxFill(hDlg);
} else {
SendDlgItemMessage(hDlg, IDC_PANEL1, WM_SETTEXT, 0, (LPARAM) Lids(IDS_D_16));
ShareListSpaceListboxFill(hDlg);
}
return (TRUE);
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
switch (wmId) {
case IDYES:
if (WarningDlgForNTFS)
ShareListFATOK();
EndDialog(hDlg, 0);
return (TRUE);
break;
case IDNO:
TransferCancel = TRUE;
EndDialog(hDlg, 0);
return (TRUE);
break;
}
break;
}
return (FALSE); // Didn't process the message
lParam;
} // DlgConversionWarning
/*+-------------------------------------------------------------------------+
| ConversionWarningDlg_Do()
|
+-------------------------------------------------------------------------+*/
void ConversionWarningDlg_Do(HWND hDlg) {
DLGPROC lpfnDlg;
lpfnDlg = MakeProcInstance((DLGPROC) DlgConversionWarning, hInst);
DialogBox(hInst, TEXT("AlertSel"), hDlg, lpfnDlg) ;
FreeProcInstance(lpfnDlg);
} // ConversionWarningDlg_Do
/*+-------------------------------------------------------------------------+
| NTFSCheck()
|
+-------------------------------------------------------------------------+*/
void NTFSCheck(HWND hDlg) {
WarningDlgForNTFS = TRUE;
if (!ShareListNTFSCheck())
ConversionWarningDlg_Do(hDlg);
} // NTFSCheck
/*+-------------------------------------------------------------------------+
| SpaceCheck()
|
+-------------------------------------------------------------------------+*/
void SpaceCheck(HWND hDlg) {
WarningDlgForNTFS = FALSE;
if (!ShareListSpaceCheck())
ConversionWarningDlg_Do(hDlg);
} // SpaceCheck
/*+-------------------------------------------------------------------------+
| End of Conversion Dialog |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| DlgConversionEnd()
|
+-------------------------------------------------------------------------+*/
LRESULT CALLBACK DlgConversionEnd(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
HANDLE hFile;
int wmId, wmEvent;
static char CmdLine[256];
HWND hCtrl;
switch (message) {
case WM_INITDIALOG:
// Center the dialog over the application window
CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER));
hCtrl = GetDlgItem(hDlg, IDC_VIEWLOG);
// check if logfile exists, if it does allow log file viewing...
hFile = CreateFileA( "LogFile.LOG", GENERIC_READ, 0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != (HANDLE) INVALID_HANDLE_VALUE)
CloseHandle( hFile );
else
EnableWindow(hCtrl, FALSE);
SendDlgItemMessage(hDlg, IDC_S_TOT_COMP, WM_SETTEXT, 0, (LPARAM) lToStr(TotConversions));
SendDlgItemMessage(hDlg, IDC_S_TOT_GROUPS, WM_SETTEXT, 0, (LPARAM) lToStr(TotGroups));
SendDlgItemMessage(hDlg, IDC_S_TOT_USERS, WM_SETTEXT, 0, (LPARAM) lToStr(TotUsers));
SendDlgItemMessage(hDlg, IDC_S_TOT_FILES, WM_SETTEXT, 0, (LPARAM) lToStr(TotFiles));
SendDlgItemMessage(hDlg, IDC_S_TOT_ERRORS, WM_SETTEXT, 0, (LPARAM) lToStr(TotErrors));
if (TransferCancel)
SendMessage(hDlg, WM_SETTEXT, (WPARAM) 0, (LPARAM) Lids(IDS_D_17));
return (TRUE);
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
switch (wmId) {
case IDOK:
case IDCANCEL:
EndDialog(hDlg, 0);
return (TRUE);
break;
case IDC_VIEWLOG:
lstrcpyA(CmdLine, "LogView ");
lstrcatA(CmdLine, "Error.LOG Summary.LOG LogFile.LOG");
WinExec(CmdLine, SW_SHOW);
return (TRUE);
break;
}
break;
}
return (FALSE); // Didn't process the message
lParam;
} // DlgConversionEnd
/*+-------------------------------------------------------------------------+
| ConversionEndDlg_Do()
|
+-------------------------------------------------------------------------+*/
void ConversionEndDlg_Do(HWND hDlg) {
DLGPROC lpfnDlg;
lpfnDlg = MakeProcInstance((DLGPROC) DlgConversionEnd, hInst);
DialogBox(hInst, TEXT("ConversionEnd"), hDlg, lpfnDlg) ;
FreeProcInstance(lpfnDlg);
} // ConversionEndDlg_Do
/*+-------------------------------------------------------------------------+
| User / Group lists and Cache routines |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| FindUserMatch()
|
| Searches through the user list using a binary search. Returns a
| pointer to the found user record or NULL if no match.
|
+-------------------------------------------------------------------------+*/
USER_BUFFER *FindUserMatch(LPTSTR Name, USER_LIST *UserList, BOOL NewName) {
LONG begin = 0;
LONG end;
LONG cur;
int match;
USER_BUFFER *UserBuffer;
if (UserList == NULL)
return NULL;
UserBuffer = UserList->UserBuffer;
end = UserList->Count - 1;
while (end >= begin) {
// go halfway in-between
cur = (begin + end) / 2;
// compare the two result into match
if (NewName)
match = lstrcmpi(Name, UserBuffer[cur].NewName);
else
match = lstrcmpi(Name, UserBuffer[cur].Name);
if (match < 0)
// move new begin
end = cur - 1;
else
begin = cur + 1;
if (match == 0)
return &UserBuffer[cur];
}
return NULL;
} // FindUserMatch
/*+-------------------------------------------------------------------------+
| FindGroupMatch()
|
| Searches through the group list using a binary search. Returns a
| pointer to the found group record or NULL if no match.
|
+-------------------------------------------------------------------------+*/
GROUP_BUFFER *FindGroupMatch(LPTSTR Name, GROUP_LIST *GroupList, BOOL NewName) {
LONG begin = 0;
LONG end;
LONG cur;
int match;
GROUP_BUFFER *GroupBuffer;
if (GroupList == NULL)
return NULL;
GroupBuffer = GroupList->GroupBuffer;
end = GroupList->Count - 1;
while (end >= begin) {
// go halfway in-between
cur = (begin + end) / 2;
// compare the two result into match
if (NewName)
match = lstrcmpi(Name, GroupBuffer[cur].NewName);
else
match = lstrcmpi(Name, GroupBuffer[cur].Name);
if (match < 0)
// move new begin
end = cur - 1;
else
begin = cur + 1;
if (match == 0)
return &GroupBuffer[cur];
}
return NULL;
} // FindGroupMatch
/*+-------------------------------------------------------------------------+
| The List Cache's are a linked list of previously converted user and
| group lists. This is mostly for when running trial conversions you can
| check if a previously transferred name conflicts with a new name (since
| the name won't actually be out on the destination server).
|
| The Cache is kept around while working with the same destination server
| or domain. Once a new domain/server is selected the cache and all lists
| should be freed.
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| ListCachePut()
|
+-------------------------------------------------------------------------+*/
BOOL ListCachePut(LIST_CACHE **CacheHead, void *ul, ULONG Count) {
LIST_CACHE *cc;
LIST_CACHE *pc;
cc = (LIST_CACHE *) AllocMemory(sizeof(LIST_CACHE));
if (cc == NULL)
return FALSE;
// Init the cache entry
cc->next = NULL;
cc->Count = Count;
cc->ul = ul;
// Now put it at the end of the chain
if (*CacheHead == NULL) {
*CacheHead = cc;
return TRUE;
}
pc = *CacheHead;
while (pc->next)
pc = pc->next;
pc->next = cc;
return TRUE;
} // ListCachePut
/*+-------------------------------------------------------------------------+
| ListCacheFree()
|
+-------------------------------------------------------------------------+*/
void ListCacheFree(LIST_CACHE **CacheHead) {
LIST_CACHE *cc;
LIST_CACHE *pc;
cc = *CacheHead;
while (cc) {
// Free the user list attached to this cache entry
FreeMemory(cc->ul);
// Save next cache entry
pc = cc->next;
// Free up the cache entry and loop
FreeMemory(cc);
cc = pc;
}
*CacheHead = NULL;
} // ListCacheFree
/*+-------------------------------------------------------------------------+
| UserCacheMatch()
|
+-------------------------------------------------------------------------+*/
BOOL UserCacheMatch(LPTSTR UserName) {
LIST_CACHE *cc;
BOOL match = FALSE;
cc = UserCacheHead;
// loop through the cache entries and try to match with each user list
while (cc && !match) {
if (FindUserMatch(UserName, (USER_LIST *) cc->ul, TRUE))
match = TRUE;
else
cc = cc->next;
}
return match;
} // UserCacheMatch
/*+-------------------------------------------------------------------------+
| GroupCacheMatch()
|
+-------------------------------------------------------------------------+*/
BOOL GroupCacheMatch(LPTSTR GroupName) {
LIST_CACHE *cc;
BOOL match = FALSE;
cc = GroupCacheHead;
// loop through the cache entries and try to match with each user list
while (cc && !match) {
if (FindGroupMatch(GroupName, (GROUP_LIST *) cc->ul, TRUE))
match = TRUE;
else
cc = cc->next;
}
return match;
} // GroupCacheMatch
/*+-------------------------------------------------------------------------+
| Logging Garbage |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| ConvertOptionsLog()
|
| Writes all the admin selected conversion options to the log file.
|
+-------------------------------------------------------------------------+*/
void ConvertOptionsLog() {
LogWriteLog(0, Lids(IDS_L_136));
if (ConvOpt->TransferUserInfo)
LogWriteLog(1, Lids(IDS_L_137), Lids(IDS_YES));
else
LogWriteLog(1, Lids(IDS_L_137), Lids(IDS_NO));
LogWriteLog(0, Lids(IDS_CRLF));
if (ConvOpt->TransferUserInfo) {
LogWriteLog(1, Lids(IDS_L_140));
if (ConvOpt->UseMappingFile) {
LogWriteLog(2, Lids(IDS_L_138), Lids(IDS_YES));
LogWriteLog(3, Lids(IDS_L_139), ConvOpt->MappingFile);
} else {
LogWriteLog(2, Lids(IDS_L_138), Lids(IDS_NO));
// Password Options
LogWriteLog(2, Lids(IDS_L_141));
switch (ConvOpt->PasswordOption) {
case 0: // Use NULL
LogWriteLog(0, Lids(IDS_L_142));
break;
case 1: // Password is username
LogWriteLog(0, Lids(IDS_L_143));
break;
case 2: // Use constant
LogWriteLog(0, Lids(IDS_L_144), ConvOpt->PasswordConstant);
break;
}
}
if (ConvOpt->ForcePasswordChange)
LogWriteLog(3, Lids(IDS_L_145), Lids(IDS_YES));
else
LogWriteLog(3, Lids(IDS_L_145), Lids(IDS_NO));
if (!ConvOpt->UseMappingFile) {
// User Names Options
LogWriteLog(2, Lids(IDS_L_146));
switch (ConvOpt->UserNameOption) {
case 0: // Don't transfer - log failures
LogWriteLog(0, Lids(IDS_L_148));
break;
case 1: // Ignore
LogWriteLog(0, Lids(IDS_L_149));
break;
case 2: // Overwrite with new info
LogWriteLog(0, Lids(IDS_L_151));
break;
case 3: // Pre-Pend constant
LogWriteLog(0, Lids(IDS_L_150), ConvOpt->UserConstant);
break;
}
LogWriteLog(0, Lids(IDS_CRLF));
// Group Names Options
LogWriteLog(2, Lids(IDS_L_147));
switch (ConvOpt->GroupNameOption) {
case 0: // Don't transfer - log failures
LogWriteLog(0, Lids(IDS_L_148));
break;
case 1: // Overwrite with new info
LogWriteLog(0, Lids(IDS_L_149));
break;
case 2: // Pre-Pend constant
LogWriteLog(0, Lids(IDS_L_150), ConvOpt->GroupConstant);
break;
}
LogWriteLog(0, Lids(IDS_CRLF));
}
if (ConvOpt->SupervisorDefaults)
LogWriteLog(2, Lids(IDS_L_152), Lids(IDS_YES));
else
LogWriteLog(2, Lids(IDS_L_152), Lids(IDS_NO));
if (ConvOpt->AdminAccounts)
LogWriteLog(2, Lids(IDS_L_153), Lids(IDS_YES));
else
LogWriteLog(2, Lids(IDS_L_153), Lids(IDS_NO));
if (ConvOpt->UseTrustedDomain && (ConvOpt->TrustedDomain != NULL))
LogWriteLog(2, Lids(IDS_L_154), ConvOpt->TrustedDomain->Name);
LogWriteLog(0, Lids(IDS_CRLF));
}
LogWriteLog(0, Lids(IDS_CRLF));
} // ConvertOptionsLog
/*+-------------------------------------------------------------------------+
| OptionsFileLog()
|
+-------------------------------------------------------------------------+*/
void OptionsFileLog() {
LogWriteLog(0, Lids(IDS_L_155));
if (FileOptions->TransferFileInfo)
LogWriteLog(1, Lids(IDS_L_156), Lids(IDS_YES));
else
LogWriteLog(1, Lids(IDS_L_156), Lids(IDS_NO));
LogWriteLog(0, Lids(IDS_CRLF));
} // OptionsFileLog
/*+-------------------------------------------------------------------------+
| ConvertPairLog()
|
+-------------------------------------------------------------------------+*/
void ConvertPairLog() {
LogWriteLog(0, Lids(IDS_LINE));
wsprintf(tmpStr, Lids(IDS_L_157), SourceServer);
LogWriteLog(0, Lids(IDS_BRACE), tmpStr);
wsprintf(tmpStr, Lids(IDS_L_158), DestServer);
LogWriteLog(0, Lids(IDS_BRACE), tmpStr);
LogWriteLog(0, Lids(IDS_LINE));
GetTime(tmpStr2);
wsprintf(tmpStr, Lids(IDS_L_159), tmpStr2);
LogWriteLog(0, Lids(IDS_BRACE), tmpStr);
LogWriteLog(0, Lids(IDS_LINE));
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteSummary(0, Lids(IDS_CRLF));
LogWriteSummary(0, TEXT("[%s -> %s]\r\n"), SourceServer, DestServer);
ErrorContextSet(TEXT("[%s -> %s]\r\n"), SourceServer, DestServer);
} // ConvertPairLog
/*+-------------------------------------------------------------------------+
| UsersLogNames()
|
+-------------------------------------------------------------------------+*/
void UsersLogNames(USER_LIST *Users) {
ULONG i;
DWORD UserCount;
USER_BUFFER *UserBuffer;
if (Users == NULL)
return;
UserCount = Users->Count;
UserBuffer = Users->UserBuffer;
if (UserCount) {
LogWriteLog(1, Lids(IDS_L_160));
LogWriteLog(1, Lids(IDS_L_161));
// Check Mapping File
for (i = 0; i < UserCount; i++) {
if (UserBuffer[i].IsNewName)
wsprintf(pLine, TEXT("%s -> %s"), UserBuffer[i].Name, UserBuffer[i].NewName);
else
wsprintf(pLine, TEXT("%s"), UserBuffer[i].NewName);
LogWriteLog(1, TEXT(" %-50s"), pLine);
if (UserBuffer[i].err) {
if (UserBuffer[i].err == NWC_ERR_NAMELONG)
LogWriteLog(0, Lids(IDS_L_162));
if (UserBuffer[i].err == NWC_ERR_DUPLICATE)
LogWriteLog(0, Lids(IDS_L_163));
if (UserBuffer[i].err == NWC_ERR_NAMEINVALID)
LogWriteLog(0, Lids(IDS_L_164));
}
// Need to check this seperatly - as it's not an error
if (UserBuffer[i].Overwrite)
LogWriteLog(0, Lids(IDS_L_163));
LogWriteLog(0, Lids(IDS_CRLF));
}
LogWriteLog(0, Lids(IDS_CRLF));
}
} // UsersLogNames
/*+-------------------------------------------------------------------------+
| UserNewName_Check()
|
+-------------------------------------------------------------------------+*/
void UserNewName_Check(USER_BUFFER *Users) {
// We have done any mappings that need to be done, now check for
// name validity if there is a new name...
if (Users->IsNewName)
if (UserCacheMatch(Users->NewName)) {
Users->err = NWC_ERR_DUPLICATE;
}
if (lstrlen(Users->NewName) > MAX_NT_USER_NAME_LEN) {
// Name is too long
Users->err = NWC_ERR_NAMELONG;
}
// Check if a valid name (no illegal characters)...
if ((int) wcscspn(Users->NewName, ILLEGAL_CHARS) < (int) lstrlen(Users->NewName))
Users->err = NWC_ERR_NAMEINVALID;
} // UserNewName_Check
/*+-------------------------------------------------------------------------+
| UserNames_Resolve()
|
+-------------------------------------------------------------------------+*/
void UserNames_Resolve(USER_BUFFER *Users) {
LPTSTR TheName;
LPTSTR ErrorText;
ULONG RetType;
// Figure out which name to use
if (Users->IsNewName)
TheName = Users->Name;
else
TheName = Users->NewName;
// If using mapping file then map the name appropriatly
if (ConvOpt->UseMappingFile) {
if (UserCacheMatch(TheName))
Users->err = NWC_ERR_DUPLICATE;
} else {
// check if the user name is in the destination list (duplicate)
if (UserCacheMatch(TheName)) {
// There was - so figure out based on conversion options what
// to do with it...
switch (ConvOpt->UserNameOption) {
case 0: // Log Errors
Users->err = NWC_ERR_DUPLICATE;
break;
case 1: // ignore
Users->err = NWC_ERR_IGNORE;
break;
case 2: // Overwrite
Users->Overwrite = TRUE;
break;
case 3: // Pre-Pend constant
lstrcpy(NewName, ConvOpt->UserConstant);
lstrcat(NewName, Users->Name);
lstrcpy(Users->NewName, NewName);
Users->IsNewName = TRUE;
break;
} // switch
}
}
do {
RetType = IDIGNORE;
UserNewName_Check(Users);
if (Users->err && (Users->err != NWC_ERR_IGNORE) && PopupOnError()) {
switch(Users->err) {
case NWC_ERR_NAMELONG:
ErrorText = Lids(IDS_L_165);
break;
case NWC_ERR_DUPLICATE:
ErrorText = Lids(IDS_L_166);
break;
case NWC_ERR_NAMEINVALID:
ErrorText = Lids(IDS_L_167);
break;
}
RetType = UserNameErrorDlg_Do(Lids(IDS_L_168), ErrorText, Users);
}
} while (RetType == IDRETRY);
if (RetType == IDABORT)
TransferCancel = TRUE;
} // UserNames_Resolve
/*+-------------------------------------------------------------------------+
| UserSave()
|
| Given a user-name, moves their account information from the source
| to the destination server.
|
+-------------------------------------------------------------------------+*/
BOOL UserSave(BOOL *NWInfo, LPTSTR origUserName, LPTSTR newUserName, NT_USER_INFO *NTInfo, void **OldInfo, BOOL Replace) {
NET_API_STATUS ret = 0;
void *NWUInfo;
FPNW_INFO fpnw;
static TCHAR ServerName[MAX_SERVER_NAME_LEN+3]; // +3 for leading slashes and ending NULL
*NWInfo = FALSE;
// Overlay NetWare info into record
NWUserInfoGet(origUserName, OldInfo);
NWUInfo = *OldInfo;
if (NWUInfo == NULL)
return FALSE;
*NWInfo = TRUE;
NWNetUserMapInfo(origUserName, NWUInfo, NTInfo);
// Force user to change password if required
if (ConvOpt->ForcePasswordChange)
NTInfo->password_expired = (DWORD) (-1L);
// Now get/map special FPNW info
if (ConvOpt->NetWareInfo) {
NWFPNWMapInfo(NWUInfo, &fpnw);
}
if (!TConversion)
if (Replace)
if (ConvOpt->NetWareInfo)
ret = NTUserInfoSet(NTInfo, &fpnw);
else
ret = NTUserInfoSet(NTInfo, NULL);
else
if (ConvOpt->NetWareInfo)
ret = NTUserInfoSave(NTInfo, &fpnw);
else
ret = NTUserInfoSave(NTInfo, NULL);
if (ret)
return FALSE;
else {
// now save out FPNW Info
if (ConvOpt->NetWareInfo)
NTSAMParmsSet(newUserName, fpnw, NTInfo->password, ConvOpt->ForcePasswordChange);
return TRUE;
}
} // UserSave
/*+-------------------------------------------------------------------------+
| UsersConvert()
|
+-------------------------------------------------------------------------+*/
void UsersConvert() {
static TCHAR Password[MAX_PW_LEN + 1];
USER_BUFFER *UserBuffer = NULL;
BOOL NWInfo;
DWORD status = 0;
DWORD i;
void *NW_UInfo;
static NT_USER_INFO NT_UInfo;
ULONG TotConv = 0;
Status_ConvTxt(Lids(IDS_D_18));
Status_ItemLabel(Lids(IDS_D_19));
Status_CurTot((UINT) UserCount);
LogWriteLog(0, Lids(IDS_L_169));
LogWriteLog(1, Lids(IDS_L_170), UserCount);
ErrorCategorySet(Lids(IDS_L_171));
if (Users == NULL)
return;
UserBuffer = Users->UserBuffer;
// This will update the status pane - but we will reset it afterwards
for (i = 0; i < UserCount; i++) {
// Don't update totals yet, but update item ref incase this takes
// awhile
Status_CurNum((UINT) i + 1);
Status_Item(UserBuffer[i].Name);
UserNames_Resolve(&UserBuffer[i]);
if (TransferCancel)
return;
}
UsersLogNames(Users);
i = 0;
while (i < UserCount) {
Status_CurNum((UINT) i + 1);
Status_Item(UserBuffer[i].Name);
lstrcpy(pLine, UserBuffer[i].Name);
if (UserBuffer[i].IsNewName)
wsprintf(pLine, TEXT("[%s -> %s]"), UserBuffer[i].Name, UserBuffer[i].NewName);
else
wsprintf(pLine, TEXT("[%s]"), UserBuffer[i].NewName);
LogWriteLog(1, TEXT("%-50s"), pLine);
ErrorItemSet(TEXT("%s\r\n"), pLine);
// If duplicate or other type error just do logging - don't try to save
if (UserBuffer[i].err) {
if (UserBuffer[i].err == NWC_ERR_DUPLICATE) {
LogWriteLog(0, Lids(IDS_L_172));
ErrorIt(Lids(IDS_L_173));
}
if (UserBuffer[i].err == NWC_ERR_NAMELONG) {
LogWriteLog(0, Lids(IDS_L_174));
ErrorIt(Lids(IDS_L_175));
}
if (UserBuffer[i].err == NWC_ERR_NAMEINVALID) {
LogWriteLog(0, Lids(IDS_L_176));
ErrorIt(Lids(IDS_L_177));
}
} else {
// Init the user record
NTUserRecInit(UserBuffer[i].NewName, &NT_UInfo);
// +-------------------------------------------------------------+
// | User name figured out - now map password |
// +-------------------------------------------------------------+
memset(Password, 0, sizeof(Password));
if (ConvOpt->UseMappingFile)
// If using map file, password is already set
lstrcpy(Password, UserBuffer[i].Password);
else
if (lstrlen(Password) == 0) {
// Didn't map password - so find what to use
switch (ConvOpt->PasswordOption) {
case 0: // No Password
// Don't need to do anything
break;
case 1: // Username
// BUGBUG: Name can be longer then password!!!
lstrcpy(Password, UserBuffer[i].NewName);
break;
case 2: // Constant
lstrcpy(Password, ConvOpt->PasswordConstant);
break;
} // switch
}
NT_UInfo.password = Password;
#ifdef DEBUG
dprintf(TEXT("User: %s\n"), UserBuffer[i].Name);
#endif
if (!UserSave(&NWInfo, UserBuffer[i].Name, UserBuffer[i].NewName, &NT_UInfo, &NW_UInfo, UserBuffer[i].Overwrite )) {
LogWriteLog(0, Lids(IDS_L_178));
ErrorIt(Lids(IDS_L_179));
} else {
// only increment total if actually converted...
TotUsers++;
TotConv++;
Status_TotUsers(TotUsers);
LogWriteLog(0, Lids(IDS_L_180));
LogWriteLog(0, Lids(IDS_CRLF));
// Converted - now need to save info to logs...
if (NWInfo) {
if (VerboseUserLogging())
NWUserInfoLog(UserBuffer[i].Name, NW_UInfo);
if (VerboseUserLogging())
NTUserRecLog(NT_UInfo);
}
}
LogWriteLog(0, Lids(IDS_CRLF));
}
i++;
}
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteSummary(1, Lids(IDS_L_181), lToStr(TotConv));
} // UsersConvert
/*+-------------------------------------------------------------------------+
| GroupSave()
|
+-------------------------------------------------------------------------+*/
BOOL GroupSave(LPTSTR Name, DWORD *Status) {
*Status = 0;
if (!TConversion)
if ((*Status = NTGroupSave(Name)))
return FALSE;
return TRUE;
} // GroupSave
/*+-------------------------------------------------------------------------+
| GroupNewName_Check()
|
+-------------------------------------------------------------------------+*/
void GroupNewName_Check(GROUP_BUFFER *Groups) {
// We have done any mappings that need to be done, now check for
// name validity if there is a new name...
if (Groups->IsNewName)
if (GroupCacheMatch(Groups->NewName)) {
Groups->err = NWC_ERR_DUPLICATE;
}
// make sure not too long
if (lstrlen(Groups->NewName) > MAX_NT_GROUP_NAME_LEN) {
// Name is too long
Groups->err = NWC_ERR_NAMELONG;
}
// Check if a valid name (no illegal characters)...
if ((int) wcscspn(Groups->NewName, ILLEGAL_CHARS) < (int) lstrlen(Groups->NewName))
Groups->err = NWC_ERR_NAMEINVALID;
} // GroupNewName_Check
/*+-------------------------------------------------------------------------+
| GroupNames_Resolve()
|
+-------------------------------------------------------------------------+*/
void GroupNames_Resolve(GROUP_BUFFER *Groups) {
LPTSTR TheName;
LPTSTR ErrorText;
ULONG RetType;
// Figure out which name to use
if (Groups->IsNewName)
TheName = Groups->Name;
else
TheName = Groups->NewName;
// If using mapping file then map the name appropriatly
if (ConvOpt->UseMappingFile) {
if (GroupCacheMatch(TheName))
Groups->err = NWC_ERR_DUPLICATE;
} else {
// check if the user name is in the destination list (duplicate)
if (GroupCacheMatch(TheName)) {
// There was - so figure out based on conversion options what
// to do with it...
switch (ConvOpt->GroupNameOption) {
case 0: // Log Errors
Groups->err = NWC_ERR_DUPLICATE;
break;
case 1: // ignore
Groups->err = NWC_ERR_IGNORE;
break;
case 2: // Pre-Pend constant
lstrcpy(NewName, ConvOpt->GroupConstant);
lstrcat(NewName, Groups->Name);
lstrcpy(Groups->NewName, NewName);
Groups->IsNewName = TRUE;
break;
} // switch
}
}
do {
RetType = IDIGNORE;
GroupNewName_Check(Groups);
if (Groups->err && (Groups->err != NWC_ERR_IGNORE) && PopupOnError()) {
switch(Groups->err) {
case NWC_ERR_NAMELONG:
ErrorText = Lids(IDS_L_182);
break;
case NWC_ERR_DUPLICATE:
ErrorText = Lids(IDS_L_183);
break;
case NWC_ERR_NAMEINVALID:
ErrorText = Lids(IDS_L_184);
break;
}
RetType = GroupNameErrorDlg_Do(Lids(IDS_L_185), ErrorText, Groups);
}
} while (RetType == IDRETRY);
if (RetType == IDABORT)
TransferCancel = TRUE;
} // GroupNames_Resolve
/*+-------------------------------------------------------------------------+
| GroupsConvert()
|
+-------------------------------------------------------------------------+*/
void GroupsConvert() {
USER_LIST *GUsers = NULL;
USER_BUFFER *GUserBuffer;
USER_BUFFER *pUser;
GROUP_BUFFER *pGroup;
GROUP_BUFFER *GroupBuffer = NULL;
DWORD GUserCount;
DWORD status = 0;
ULONG Count, i;
ULONG TotConv = 0;
LPTSTR NewName;
BOOL SecEquivTitle = FALSE;
BOOL SecEquivUser = FALSE;
TCHAR GroupTitle[TMP_STR_LEN_256];
// update status pane
Status_ConvTxt(Lids(IDS_D_20));
Status_ItemLabel(Lids(IDS_D_21));
ErrorCategorySet(Lids(IDS_L_186));
Status_CurTot((UINT) GroupCount);
LogWriteLog(0, Lids(IDS_L_187));
LogWriteLog(1, Lids(IDS_L_188), GroupCount);
if (Groups == NULL)
return;
GroupBuffer = Groups->GroupBuffer;
for (i = 0; i < GroupCount; i++) {
// Don't update totals yet, but update item ref incase this takes
// awhile
Status_CurNum((UINT) i + 1);
Status_Item(GroupBuffer[i].Name);
GroupNames_Resolve(&GroupBuffer[i]);
if (TransferCancel)
return;
}
i = 0;
while (i < GroupCount) {
// update status pane for this group
Status_CurNum((UINT) i + 1);
Status_Item(GroupBuffer[i].Name);
lstrcpy(pLine, GroupBuffer[i].Name);
#ifdef DEBUG
dprintf(TEXT("Working on Group: %s\r\n"), GroupBuffer[i].Name);
#endif
if (GroupBuffer[i].IsNewName)
wsprintf(pLine, TEXT("%s -> %s"), GroupBuffer[i].Name, GroupBuffer[i].NewName);
else
wsprintf(pLine, TEXT("%s"), GroupBuffer[i].NewName);
LogWriteLog(1, TEXT("%-50s"), pLine);
ErrorItemSet(TEXT("[%s]\r\n"), pLine);
// If duplicate or other type error just do logging - don't try
// to save...
if (GroupBuffer[i].err) {
if (GroupBuffer[i].err == NWC_ERR_DUPLICATE) {
LogWriteLog(0, Lids(IDS_L_163));
ErrorIt(Lids(IDS_L_189));
}
if (GroupBuffer[i].err == NWC_ERR_NAMELONG) {
LogWriteLog(0, Lids(IDS_L_162));
ErrorIt(Lids(IDS_L_190));
}
if (GroupBuffer[i].err == NWC_ERR_NAMEINVALID) {
LogWriteLog(0, Lids(IDS_L_164));
ErrorIt(Lids(IDS_L_191));
}
} else {
// Try to save it and get any errors...
if (!GroupSave(GroupBuffer[i].NewName, &status)) {
LogWriteLog(0, Lids(IDS_L_192));
ErrorIt(Lids(IDS_L_193));
} else {
// only increment total if actually converted...
TotGroups++;
TotConv++;
Status_TotGroups(TotGroups);
LogWriteLog(0, Lids(IDS_L_180));
}
}
LogWriteLog(0, Lids(IDS_CRLF));
i++;
}
LogWriteLog(0, Lids(IDS_CRLF));
ErrorCategorySet(Lids(IDS_L_194));
// +-------------------------------------------------------------+
// | Go through and add users to the groups |
// +-------------------------------------------------------------+
for (Count = 0; Count < GroupCount; Count++) {
GUserCount = 0;
if (!(status = NWGroupUsersEnum(GroupBuffer[Count].Name, &GUsers)) && (GUsers != NULL)) {
GUserCount = GUsers->Count;
GUserBuffer = GUsers->UserBuffer;
if (GUserCount > 0) {
wsprintf(GroupTitle, Lids(IDS_S_46), GroupBuffer[Count].NewName);
EscapeFormattingChars(GroupTitle,
sizeof(GroupTitle)/sizeof(GroupTitle[0])) ;
Status_ItemLabel(GroupTitle);
LogWriteLog(1, TEXT("[%s]\r\n"), GroupBuffer[Count].NewName);
}
for (i = 0; i < GUserCount; i++) {
pUser = FindUserMatch(GUserBuffer[i].Name, Users, FALSE);
if (pUser == NULL)
NewName = NWSpecialNamesMap(GUserBuffer[i].Name);
else
NewName = pUser->NewName;
LogWriteLog(2, TEXT("%-20s"), NewName);
Status_Item(NewName);
#ifdef DEBUG
dprintf(TEXT("Adding User [%s] to Group: %s\n"), NewName, GroupBuffer[Count].NewName );
#endif
if (!TConversion)
if (NTGroupUserAdd(GroupBuffer[Count].NewName, NewName, FALSE)) {
LogWriteLog(0, Lids(IDS_L_196));
ErrorIt(Lids(IDS_L_195), NewName, GroupBuffer[Count].NewName);
}
LogWriteLog(0, Lids(IDS_CRLF));
}
LogWriteLog(0, Lids(IDS_CRLF));
FreeMemory((LPBYTE) GUsers);
} else {
LogWriteLog(1, Lids(IDS_L_197), GroupBuffer[Count].Name);
ErrorIt(Lids(IDS_L_197), GroupBuffer[Count].Name);
}
} // loop adding users to groups
ErrorCategorySet(Lids(IDS_L_198));
// +-------------------------------------------------------------+
// | Convert Security Equivalences to Group Names |
// +-------------------------------------------------------------+
SecEquivTitle = FALSE;
for (Count = 0; Count < UserCount; Count++) {
GUserCount = 0;
SecEquivUser = FALSE;
if (!(status = NWUserEquivalenceEnum(Users->UserBuffer[Count].Name, &GUsers)) && (GUsers != NULL)) {
GUserCount = GUsers->Count;
GUserBuffer = GUsers->UserBuffer;
if (GUserCount > 0) {
for (i = 0; i < GUserCount; i++) {
pGroup = FindGroupMatch(GUserBuffer[i].Name, Groups, FALSE);
if (pGroup != NULL) {
if ((pGroup->err != NWC_ERR_NAMELONG) && (pGroup->err != NWC_ERR_NAMEINVALID))
if (!SecEquivTitle) {
SecEquivTitle = TRUE;
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(0, Lids(IDS_L_199));
}
if (!SecEquivUser) {
SecEquivUser = TRUE;
wsprintf(GroupTitle, Lids(IDS_S_47), Users->UserBuffer[Count].NewName);
EscapeFormattingChars(GroupTitle,
sizeof(GroupTitle)/sizeof(GroupTitle[0])) ;
Status_ItemLabel(GroupTitle);
LogWriteLog(1, TEXT("[%s]\r\n"), Users->UserBuffer[Count].NewName);
}
LogWriteLog(2, TEXT("%-20s"), pGroup->NewName);
Status_Item(pGroup->NewName);
#ifdef DEBUG
dprintf(TEXT("User [%s] Security Equivalence: %s\n"), Users->UserBuffer[Count].NewName, pGroup->NewName );
#endif
if (!TConversion)
if (NTGroupUserAdd(pGroup->NewName, Users->UserBuffer[Count].NewName, FALSE)) {
LogWriteLog(0, Lids(IDS_L_196));
ErrorIt(Lids(IDS_L_195), Users->UserBuffer[Count].NewName, pGroup->NewName);
}
LogWriteLog(0, Lids(IDS_CRLF));
} else {
// There was not a group match - check if this is supervisor
// equivalence
if (!lstrcmpi(GUserBuffer[i].Name, Lids(IDS_S_28))) {
// Check if we should add them
if (ConvOpt->AdminAccounts) {
if (!SecEquivTitle) {
SecEquivTitle = TRUE;
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(0, Lids(IDS_L_199));
}
if (!SecEquivUser) {
SecEquivUser = TRUE;
LogWriteLog(1, TEXT("[%s]\r\n"), Users->UserBuffer[Count].NewName);
}
LogWriteLog(2, TEXT("%-20s"), Lids(IDS_S_42));
if (!TConversion)
if (NTGroupUserAdd(Lids(IDS_S_42), Users->UserBuffer[Count].NewName, FALSE)) {
LogWriteLog(0, Lids(IDS_L_196));
ErrorIt(Lids(IDS_L_195), Users->UserBuffer[Count].NewName, Lids(IDS_S_42));
}
LogWriteLog(0, Lids(IDS_CRLF));
}
}
}
}
// Only put blank line if we logged this user
if (SecEquivUser)
LogWriteLog(0, Lids(IDS_CRLF));
}
FreeMemory((LPBYTE) GUsers);
}
} // Loop converting security equivalences
// Synchronize the domain - we need to synch as Print Operators are a
// local group
NTDomainSynch(CurrentConvertList->FileServ);
// Now set server to appropriate dest server (local group - so must
// be on dest server and not PDC or trusted domain)...
if ((status = NTServerSet(CurrentConvertList->FileServ->Name))) {
// Failed to set server so log it and loop to next server
LogWriteLog(0, Lids(IDS_L_209), CurrentConvertList->FileServ->Name);
ErrorIt(Lids(IDS_L_209), CurrentConvertList->FileServ->Name);
return;
}
ErrorCategorySet(Lids(IDS_L_200));
// +-------------------------------------------------------------+
// | Do Print Operators |
// +-------------------------------------------------------------+
SecEquivTitle = FALSE;
if (!(status = NWPrintOpsEnum(&GUsers)) && (GUsers != NULL)) {
GUserCount = GUsers->Count;
GUserBuffer = GUsers->UserBuffer;
if (GUserCount > 0) {
for (i = 0; i < GUserCount; i++) {
if (!SecEquivTitle) {
SecEquivTitle = TRUE;
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(0, Lids(IDS_L_201));
}
pUser = FindUserMatch(GUserBuffer[i].Name, Users, FALSE);
if ((pUser == NULL) || ((pUser->err != NWC_ERR_NAMELONG) && (pUser->err != NWC_ERR_NAMEINVALID))) {
if (pUser == NULL)
NewName = NWSpecialNamesMap(GUserBuffer[i].Name);
else
NewName = pUser->NewName;
LogWriteLog(2, TEXT("%-20s"), NewName);
#ifdef DEBUG
dprintf(TEXT("Adding User [%s] to Group: %s\n"), NewName, Lids(IDS_S_43) );
#endif
if (!TConversion)
if (NTGroupUserAdd(Lids(IDS_S_43), NewName, TRUE)) {
LogWriteLog(0, Lids(IDS_L_196));
ErrorIt(Lids(IDS_L_195), NewName, Lids(IDS_S_43));
}
LogWriteLog(0, Lids(IDS_CRLF));
}
}
}
}
LogWriteSummary(1, Lids(IDS_L_202), lToStr(TotConv));
} // GroupsConvert
/*+-------------------------------------------------------------------------+
| SupervisorDefaultsConvert()
|
+-------------------------------------------------------------------------+*/
void SupervisorDefaultsConvert(TRANSFER_LIST *tl) {
ULONG i;
void *Defaults;
BOOL ConvertDefaults = FALSE;
NT_DEFAULTS *NTDefaults = NULL;
NT_DEFAULTS CDefaults;
DEST_SERVER_BUFFER *oDServ = NULL;
TRANSFER_BUFFER *TList;
CONVERT_OPTIONS *ConvOpt;
if (tl == NULL)
return;
TList = tl->TList;
memset(&CDefaults, 0, sizeof(CDefaults));
LogWriteLog(0, Lids(IDS_LINE));
LogWriteLog(0, Lids(IDS_BRACE), Lids(IDS_L_203));
LogWriteLog(0, Lids(IDS_LINE));
// Loop through the server pairs for conversion - this is sorted in order of
// destination users servers.
for (i = 0; i < tl->Count; i++) {
CurrentConvertList = TList[i].ConvertList;
ConvOpt = (CONVERT_OPTIONS *) CurrentConvertList->ConvertOptions;
if (CurrentConvertList->FileServ != oDServ) {
// if this is not the first time through the loop, then we need to save
// off the converted defaults
if (ConvertDefaults && (oDServ != NULL)) {
ConvertDefaults = FALSE;
LogWriteLog(0, Lids(IDS_L_204), oDServ->Name);
if (NTDefaults != NULL) {
NTUserDefaultsLog(*NTDefaults);
if (!TConversion)
NTUserDefaultsSet(*NTDefaults);
}
}
oDServ = CurrentConvertList->FileServ;
// Point to dest server and get defaults
NTServerSet(CurrentConvertList->FileServ->Name);
NTUserDefaultsGet(&NTDefaults);
memset(&CDefaults, 0, sizeof(CDefaults));
if (NTDefaults != NULL)
memcpy(&CDefaults, NTDefaults, sizeof(CDefaults));
}
// Supervisor defaults
if (ConvOpt->SupervisorDefaults) {
// if not flagged for this dest server, then flag and write out original
// values
if (!ConvertDefaults) {
ConvertDefaults = TRUE;
if (NTDefaults != NULL) {
LogWriteLog(0, Lids(IDS_L_205), CurrentConvertList->FileServ->Name);
NTUserDefaultsLog(*NTDefaults);
}
}
NWServerSet(CurrentConvertList->SourceServ->Name);
NWUserDefaultsGet(&Defaults);
if (Defaults != NULL) {
LogWriteLog(0, Lids(IDS_L_206), CurrentConvertList->SourceServ->Name);
NWUserDefaultsLog(Defaults);
NWUserDefaultsMap(Defaults, &CDefaults);
// Now map in least restrictive values to the NT one
if (NTDefaults != NULL) {
if (CDefaults.min_passwd_len < NTDefaults->min_passwd_len)
NTDefaults->min_passwd_len = CDefaults.min_passwd_len;
if (CDefaults.max_passwd_age < NTDefaults->max_passwd_age)
NTDefaults->max_passwd_age = CDefaults.max_passwd_age;
if (CDefaults.force_logoff < NTDefaults->force_logoff)
NTDefaults->force_logoff = CDefaults.force_logoff;
}
FreeMemory(Defaults);
Defaults = NULL;
}
}
}
// Need to catch the last one through the loop
if (ConvertDefaults && (oDServ != NULL)) {
ConvertDefaults = FALSE;
LogWriteLog(0, Lids(IDS_L_204), oDServ->Name);
if (NTDefaults != NULL) {
NTUserDefaultsLog(*NTDefaults);
if (!TConversion)
NTUserDefaultsSet(*NTDefaults);
}
}
} // SupervisorDefaultsConvert
/*+-------------------------------------------------------------------------+
| TransferListCompare()
|
+-------------------------------------------------------------------------+*/
int __cdecl TransferListCompare(const void *arg1, const void *arg2) {
TRANSFER_BUFFER *TBarg1, *TBarg2;
TBarg1 = (TRANSFER_BUFFER *) arg1;
TBarg2 = (TRANSFER_BUFFER *) arg2;
return lstrcmpi( TBarg1->ServerName, TBarg2->ServerName);
} // TransferListCompare
/*+-------------------------------------------------------------------------+
| TransferListCreate()
|
+-------------------------------------------------------------------------+*/
TRANSFER_LIST *TransferListCreate() {
CONVERT_OPTIONS *ConvOpt;
static TRANSFER_LIST *tl;
TRANSFER_BUFFER *TList;
CONVERT_LIST *CList;
ULONG Count = 0;
tl = NULL;
CList = ConvertListStart;
while (CList != NULL) {
Count++;
CList = CList->next;
}
if (Count == 0)
return NULL;
tl = AllocMemory(sizeof(TRANSFER_LIST) + (sizeof(TRANSFER_BUFFER) * Count));
if (tl == NULL)
return NULL;
tl->Count = Count;
TList = tl->TList;
// init it all to NULL
memset(TList, 0, sizeof(TRANSFER_BUFFER) * Count);
Count = 0;
CList = ConvertListStart;
while (CList != NULL) {
TList[Count].ConvertList = CList;
// If going to a trusted domain then point to it's PDC for user transfers
ConvOpt = (CONVERT_OPTIONS *) CList->ConvertOptions;
if (ConvOpt->UseTrustedDomain && (ConvOpt->TrustedDomain != NULL) && (ConvOpt->TrustedDomain->PDCName != NULL)) {
TList[Count].UserServerType = USER_SERVER_TRUSTED;
TList[Count].ServerName = ConvOpt->TrustedDomain->PDCName;
} else
// If in a domain then point to the PDC for user transfers
if (CList->FileServ->InDomain && CList->FileServ->Domain) {
TList[Count].UserServerType = USER_SERVER_PDC;
TList[Count].ServerName = CList->FileServ->Domain->PDCName;
} else {
TList[Count].UserServerType = USER_SERVER;
TList[Count].ServerName = CList->FileServ->Name;
}
Count++;
CList = CList->next;
}
// Have setup the main transfer list - now need to sort it in order of the
// server names that users are being transfered to.
qsort((void *) TList, (size_t) tl->Count, sizeof(TRANSFER_BUFFER), TransferListCompare);
#ifdef DEBUG
dprintf(TEXT("\nTransfer List:\n"));
for (Count = 0; Count < tl->Count; Count++) {
dprintf(TEXT(" Name: %s "), TList[Count].ServerName);
switch (TList[Count].UserServerType) {
case USER_SERVER:
dprintf(TEXT("(Normal)\n"));
break;
case USER_SERVER_PDC:
dprintf(TEXT("(PDC)\n"));
break;
case USER_SERVER_TRUSTED:
dprintf(TEXT("(TRUSTED)\n"));
break;
}
}
dprintf(TEXT("\n"));
#endif
return tl;
} // TransferListCreate
/*+-------------------------------------------------------------------------+
| DoConversion()
|
| Main program that does the actuall conversion. Loops through the
| convert list and transfer the information.
|
+-------------------------------------------------------------------------+*/
void DoConversion(HWND hDlg, BOOL TrialConversion) {
TRANSFER_LIST *tl = NULL;
TRANSFER_BUFFER *TList;
LPTSTR oDServ = NULL;
DWORD status = 0;
UINT i;
BOOL GotUserList;
TCHAR sztime[40];
LPTSTR DomainName;
time(&StartTime);
TransferCancel = FALSE;
TConversion = TrialConversion;
// Check if going to non NTFS drives - if so, let user abort
NTFSCheck(hDlg);
if (TransferCancel)
return;
CursorHourGlass();
PanelDlg_Do(hDlg, Lids(IDS_D_22));
ConvertFilesInit(hDlg);
if (Panel_Cancel()) {
PanelDlgKill();
TransferCancel = TRUE;
CursorNormal();
return;
}
PanelDlgKill();
// Check if enough space on destination drives, if not allow user to abort
CursorNormal();
SpaceCheck(hDlg);
if (TransferCancel)
return;
CursorHourGlass();
tl = TransferListCreate();
TList = tl->TList;
DoStatusDlg(hDlg);
Status_TotConv((UINT) NumServerPairs);
Users = NULL;
NTUsers = NULL;
Groups = NULL;
NTGroups = NULL;
UserCount = 0;
NTUserCount = 0;
GroupCount = 0;
NTGroupCount= 0;
// Initialize global statistics
TotErrors = 0;
TotGroups = 0;
TotUsers = 0;
TotFiles = 0;
// Update statistics window
Status_TotComplete(0);
Status_TotGroups(TotGroups);
Status_TotUsers(TotUsers);
Status_TotFiles(TotFiles);
Status_TotErrors(TotErrors);
// Set up logs and do all the header stuff
LogInit();
if (TrialConversion) {
LogWriteLog(0, Lids(IDS_L_207));
} else {
LogWriteLog(0, Lids(IDS_L_208));
}
LogWriteSummary(0, Lids(IDS_CRLF));
LogWriteErr(Lids(IDS_CRLF));
LogWriteLog(0, Lids(IDS_CRLF));
// Log the list of servers to be converted
ErrorResetAll();
ConvertListLog();
// Loop through source servers and conglomerate defaults into dest servers
// and log the results
SupervisorDefaultsConvert(tl);
// +---------------------------------------------------------------------+
// | Done with init - loop through server pairs and do conversion |
// +---------------------------------------------------------------------+
// Get Local computer name
GetLocalName(&LocalName);
// Loop through the server pairs for conversion
for (i = 0; ((i < tl->Count) && !TransferCancel); i++) {
CurrentConvertList = TList[i].ConvertList;
// Get source and destination server - update logs and status window
Status_CurConv(i + 1);
SourceServer = CurrentConvertList->SourceServ->Name;
DestServer = CurrentConvertList->FileServ->Name;
Status_SrcServ(SourceServer);
Status_DestServ(DestServer);
// Log this server pair - section heading
ConvertPairLog();
// SetConvert options and log them out.
ConvOpt = (CONVERT_OPTIONS *) CurrentConvertList->ConvertOptions;
FileOptions = (FILE_OPTIONS *) CurrentConvertList->FileOptions;
ConvertOptionsLog();
OptionsFileLog();
// If our destination server has changed then update the caches
if (TList[i].ServerName != oDServ) {
oDServ = TList[i].ServerName;
GotUserList = TRUE;
ListCacheFree(&UserCacheHead);
ListCacheFree(&GroupCacheHead);
if ((status = NTServerSet(DestServer))) {
// Failed to set server so log it and loop to next server
LogWriteLog(0, Lids(IDS_L_209), DestServer);
ErrorIt(Lids(IDS_L_209), DestServer);
goto ConvDo_Loop;
}
// Put VShares here so it doesn't get lost in user info
if (FileOptions->TransferFileInfo)
VSharesCreate(CurrentConvertList->FileServ, TConversion);
// Get users on NT server and put in cache
if (status = NTUsersEnum(&NTUsers)) {
// Failed - make sure we don't try to convert users and log err
NTUsers = NULL;
NTUserCount = 0;
LogWriteLog(0, Lids(IDS_L_210), DestServer);
ErrorIt(Lids(IDS_L_210), DestServer);
GotUserList = FALSE;
} else
NTUserCount = NTUsers->Count;
if (!ListCachePut(&UserCacheHead, (void *) NTUsers, NTUserCount)) {
// Failed - but clean up NT List first
GotUserList = FALSE;
FreeMemory(NTUsers);
} else {
// Now get Groups (if users succeded) and put in group cache
if (status = NTGroupsEnum(&NTGroups)) {
// Failed - make sure we don't try to convert users and log err
NTGroupCount = 0;
NTGroups = NULL;
LogWriteLog(0, Lids(IDS_L_211), DestServer);
ErrorIt(Lids(IDS_L_211), DestServer);
FreeMemory(NTUsers);
GotUserList = FALSE;
} else
NTGroupCount = NTGroups->Count;
if (!ListCachePut(&GroupCacheHead, (void *) NTGroups, NTGroupCount)) {
// Failed - but clean up NT List first
GotUserList = FALSE;
FreeMemory(NTUsers);
FreeMemory(NTGroups);
}
}
}
wsprintf(UserServerName, TEXT("\\\\%s"), TList[i].ServerName);
if ((status = NTServerSet(TList[i].ServerName))) {
// Failed to set server so log it and loop to next server
LogWriteLog(0, Lids(IDS_L_209), TList[i].ServerName);
ErrorIt(Lids(IDS_L_209), TList[i].ServerName);
goto ConvDo_Loop;
}
if (ConvOpt->NetWareInfo) {
NTSAMClose();
if (ConvOpt->UseTrustedDomain && (ConvOpt->TrustedDomain != NULL))
DomainName = ConvOpt->TrustedDomain->Name;
else
if ((CurrentConvertList->FileServ->InDomain) && (CurrentConvertList->FileServ->Domain != NULL))
DomainName = CurrentConvertList->FileServ->Domain->Name;
else
DomainName = TEXT("");
if ((status = NTSAMConnect(TList[i].ServerName, DomainName))) {
// Failed to set server so log it and loop to next server
LogWriteLog(0, Lids(IDS_L_209), TList[i].ServerName);
ErrorIt(Lids(IDS_L_209), TList[i].ServerName);
goto ConvDo_Loop;
}
}
if ((status = NWServerSet(SourceServer))) {
// Failed to set server so log it and loop to next server
LogWriteLog(0, Lids(IDS_L_209), SourceServer);
ErrorIt(Lids(IDS_L_209), SourceServer);
goto ConvDo_Loop;
}
//
// If we are using mapping file then don't enum users and groups off
// the server. Get them from the mapping file instead.
//
hMap = NULL;
if (ConvOpt->UseMappingFile) {
//
// This is mapping file stuff
//
hMap = map_Open(ConvOpt->MappingFile);
if (hMap == NULL) {
ErrorIt(Lids(IDS_L_217), ConvOpt->MappingFile);
goto ConvDo_Loop;
}
if ((status = map_GroupsEnum(hMap, &Groups))) {
// Failed - make sure we don't try to convert users and log err
Groups = NULL;
GroupCount = 0;
LogWriteLog(0, Lids(IDS_L_219), ConvOpt->MappingFile);
ErrorIt(Lids(IDS_L_219), ConvOpt->MappingFile);
GotUserList = FALSE;
} else
GroupCount = Groups->Count;
if ((status = map_UsersEnum(hMap, &Users))) {
// Failed - make sure we don't try to convert users and log err
Users = NULL;
UserCount = 0;
LogWriteLog(0, Lids(IDS_L_218), ConvOpt->MappingFile);
ErrorIt(Lids(IDS_L_218), ConvOpt->MappingFile);
GotUserList = FALSE;
} else
UserCount = Users->Count;
} else {
//
// Enuming users and groups from NetWare Server instead of map file
//
if ((status = NWGroupsEnum(&Groups, TRUE))) {
// Failed - make sure we don't try to convert users and log err
Groups = NULL;
GroupCount = 0;
LogWriteLog(0, Lids(IDS_L_211), SourceServer);
ErrorIt(Lids(IDS_L_211), SourceServer);
GotUserList = FALSE;
} else
GroupCount = Groups->Count;
if ((status = NWUsersEnum(&Users, TRUE))) {
// Failed - make sure we don't try to convert users and log err
Users = NULL;
UserCount = 0;
LogWriteLog(0, Lids(IDS_L_210), SourceServer);
ErrorIt(Lids(IDS_L_210), SourceServer);
GotUserList = FALSE;
} else
UserCount = Users->Count;
}
if (GotUserList) {
// User and Groups
if (ConvOpt->TransferUserInfo) {
UsersConvert();
if (!TransferCancel)
GroupsConvert();
}
}
// Note GroupsConvert switches servers for Print Operators to the
// destination server (and not the PDC).
// Files
if (!(TransferCancel) && FileOptions->TransferFileInfo) {
ErrorCategorySet(Lids(IDS_L_212));
// Now set server to appropriate file dest server
if ((status = NTServerSet(CurrentConvertList->FileServ->Name))) {
// Failed to set server so log it and loop to next server
LogWriteLog(0, Lids(IDS_L_209), CurrentConvertList->FileServ->Name);
ErrorIt(Lids(IDS_L_209), CurrentConvertList->FileServ->Name);
goto ConvDo_Loop;
}
Status_BytesTxt(Lids(IDS_L_213));
Status_Bytes(TEXT("0"));
Status_TotBytes(TEXT("0"));
Status_BytesSep(Lids(IDS_L_214));
ConvertFiles(hDlg, TConversion, Users, Groups);
Status_BytesTxt(TEXT(""));
Status_Bytes(TEXT(""));
Status_TotBytes(TEXT(""));
Status_BytesSep(TEXT(""));
}
NWServerFree();
ConvDo_Loop:
Status_TotComplete(i);
if (Users) {
FreeMemory(Users);
UserCount = 0;
}
if (Groups) {
FreeMemory(Groups);
GroupCount = 0;
}
if (hMap != NULL)
map_Close(hMap);
} // for loop through transfer list
// Free up our caches
ListCacheFree(&UserCacheHead);
ListCacheFree(&GroupCacheHead);
// Log out the finish time
LogWriteSummary(0, Lids(IDS_CRLF));
LogWriteSummary(0, Lids(IDS_CRLF));
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(0, Lids(IDS_CRLF));
GetTime(sztime);
if (TransferCancel) {
LogWriteLog(0, Lids(IDS_L_215), sztime);
LogWriteSummary(0, Lids(IDS_L_215), sztime);
} else {
LogWriteLog(0, Lids(IDS_L_216), sztime);
LogWriteSummary(0, Lids(IDS_L_216), sztime);
}
if (tl != NULL)
FreeMemory(tl);
NTSAMClose();
StatusDlgKill();
CursorNormal();
TotConversions = i;
ConversionEndDlg_Do(hDlg);
} // DoConversion
/*+-------------------------------------------------------------------------+
| ConversionSuccessful()
|
+-------------------------------------------------------------------------+*/
BOOL ConversionSuccessful() {
if (TotErrors || TransferCancel)
return FALSE;
else
return TRUE;
} // ConversionSuccesful
Reference in a new issue Copy permalink