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

2095 lines
59 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*
+-------------------------------------------------------------------------+
| Server Linked List Manipulation Routines |
+-------------------------------------------------------------------------+
| (c) Copyright 1993-1994 |
| Microsoft Corp. |
| All rights reserved |
| |
| Program : [ServList.c] |
| Programmer : Arthur Hanson |
| Original Program Date : [Feb 15, 1994] |
| Last Update : [Jun 16, 1994] |
| |
| Version: 1.00 |
| |
| Description: |
| Bunch of similar utility functions for adding to, deleting from, |
| saving and restoring data lists. |
| |
| |
| History: |
| arth Jun 16, 1994 1.00 Original Version. |
| |
+-------------------------------------------------------------------------+
*/
#include "globals.h"
#include "convapi.h"
#include "columnlb.h"
#include "ntnetapi.h"
#include "nwnetapi.h"
#include "userdlg.h"
#include "filedlg.h"
// define from SBrowse.c -> for SourceShareListFixup
BOOL MapShare(SHARE_BUFFER *Share, DEST_SERVER_BUFFER *DServ);
static ULONG NumDServs = 0;
static ULONG NumSServs = 0;
static ULONG NumDomains = 0;
// Note: Most of these routines are a bunch of doubly-linked list functions
// as such it should be possible to condense them to use some common
// functions for add/delete/insert. However virtual-shares will have
// to be different as the Virtual BOOL has to be the first field.
/*+-------------------------------------------------------------------------+
| Routines for Directory/File Trees |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| TreeSave()
|
+-------------------------------------------------------------------------+*/
void _TreeSaveR(HANDLE hFile, DIR_BUFFER *Dir) {
DIR_BUFFER *DList;
ULONG Size;
ULONG i;
DWORD wrote;
if (Dir == NULL)
return;
// First save out the file list for this node
if (Dir->FileList) {
WriteFile(hFile, &Dir->FileList->Count, sizeof(Dir->FileList->Count), &wrote, NULL);
Size = sizeof(FILE_LIST) + (Dir->FileList->Count * sizeof(FILE_BUFFER));
WriteFile(hFile, Dir->FileList, Size, &wrote, NULL);
}
if (Dir->DirList) {
DList = Dir->DirList->DirBuffer;
// first write out this dirlist then recurse down tree.
WriteFile(hFile, &Dir->DirList->Count, sizeof(Dir->DirList->Count), &wrote, NULL);
Size = sizeof(DIR_LIST) + (Dir->DirList->Count * sizeof(DIR_BUFFER));
WriteFile(hFile, Dir->DirList, Size, &wrote, NULL);
for (i = 0; i < Dir->DirList->Count; i++)
_TreeSaveR(hFile, &DList[i]);
}
} // _TreeSaveR
void TreeSave(HANDLE hFile, DIR_BUFFER *Dir) {
DWORD wrote;
if (Dir == NULL)
return;
// Make sure we save the minimum amount
TreePrune(Dir);
// write out the actual dir
WriteFile(hFile, Dir, sizeof(DIR_BUFFER), &wrote, NULL);
// now save it's child info recursively
_TreeSaveR(hFile, Dir);
} // TreeSave
/*+-------------------------------------------------------------------------+
| TreeLoad()
|
+-------------------------------------------------------------------------+*/
void _TreeLoadR(HANDLE hFile, DIR_BUFFER *Dir) {
DIR_LIST *DList;
DIR_BUFFER *DBuff;
FILE_LIST *FList;
FILE_BUFFER *FBuff;
ULONG Size;
ULONG i;
DWORD wrote;
ULONG Count;
if (Dir == NULL)
return;
// First save out the file list for this node
if (Dir->FileList) {
ReadFile(hFile, &Count, sizeof(Count), &wrote, NULL);
Size = sizeof(FILE_LIST) + (sizeof(FILE_BUFFER) * Count);
FList = AllocMemory(Size);
ReadFile(hFile, FList, Size, &wrote, NULL);
// Read it in, now fixup the internal pointers.
FList->parent = Dir;
FBuff = FList->FileBuffer;
for (i = 0; i < FList->Count; i++)
FBuff[i].parent = FList;
Dir->FileList = FList;
}
if (Dir->DirList) {
ReadFile(hFile, &Count, sizeof(Count), &wrote, NULL);
Size = sizeof(DIR_LIST) + (sizeof(DIR_BUFFER) * Count);
DList = AllocMemory(Size);
ReadFile(hFile, DList, Size, &wrote, NULL);
// Read it in, now fixup the internal pointers.
DList->parent = Dir;
DBuff = DList->DirBuffer;
for (i = 0; i < DList->Count; i++)
DBuff[i].parent = DList;
Dir->DirList = DList;
// Now recurse into children and fix them up
for (i = 0; i < DList->Count; i++)
_TreeLoadR(hFile, &DBuff[i]);
}
} // _TreeLoadR
void TreeLoad(HANDLE hFile, DIR_BUFFER **pDir) {
DIR_BUFFER *Dir;
DWORD wrote;
if (pDir == NULL)
return;
// Allocate space for the new root
Dir = AllocMemory(sizeof(DIR_BUFFER));
if (Dir == NULL)
return;
memset(Dir, 0, sizeof(DIR_BUFFER));
// set passed in var to new memory and read in values from file
*pDir = Dir;
ReadFile(hFile, Dir, sizeof(DIR_BUFFER), &wrote, NULL);
// now recursively load child information
_TreeLoadR(hFile, Dir);
} // TreeLoad
/*+-------------------------------------------------------------------------+
| Routines for User Lists |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| UserListCompare()
|
+-------------------------------------------------------------------------+*/
int __cdecl UserListCompare(const void *arg1, const void *arg2) {
USER_BUFFER *ULarg1, *ULarg2;
ULarg1 = (USER_BUFFER *) arg1;
ULarg2 = (USER_BUFFER *) arg2;
// This works as the first item of the structure is the string
return lstrcmpi( ULarg1->Name, ULarg2->Name);
} // UserListCompare
/*+-------------------------------------------------------------------------+
| Routines for Share Lists |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| ShareListDelete()
|
+-------------------------------------------------------------------------+*/
void ShareListDelete(SHARE_LIST *ShareList) {
SHARE_BUFFER *SList;
VIRTUAL_SHARE_BUFFER *VShare;
ULONG i;
if (ShareList == NULL)
return;
SList = ShareList->SList;
for (i = 0; i < ShareList->Count; i++) {
if (SList[i].Root != NULL) {
TreeDelete(SList[i].Root);
FreeMemory(SList[i].Root);
}
// Note: SList[i].Drive points to a dest server drive, so we don't
// free it here.
if (!ShareList->Fixup)
if (SList[i].Virtual) {
VShare = (VIRTUAL_SHARE_BUFFER *) SList[i].DestShare;
if ((VShare != NULL) && VShare->UseCount)
VShare->UseCount--;
}
}
} // ShareListDelete
/*+-------------------------------------------------------------------------+
| SourceShareListFixup()
|
+-------------------------------------------------------------------------+*/
void SourceShareListFixup(DEST_SERVER_BUFFER *DServ, SHARE_LIST *ShareList) {
TCHAR tmpName[MAX_SHARE_NAME_LEN + 1];
SHARE_BUFFER *SList;
ULONG i;
DWORD *VMap = NULL;
if (ShareList == NULL)
return;
ShareList->Fixup = FALSE;
// Generate Virtual Share Map
VShareListIndexMapGet(DServ, &VMap);
SList = ShareList->SList;
for (i = 0; i < ShareList->Count; i++) {
if (SList[i].DestShare != NULL)
if (SList[i].Virtual)
SList[i].DestShare = (SHARE_BUFFER *) VMap[(DWORD) SList[i].DestShare - 1];
else {
// Not a virtual share - now need to take name from path and rematch it
// to the new destination share list (dest sharename was stored in
// path in the ShareListSave routine).
lstrcpy(tmpName, SList[i].Name);
lstrcpy(SList[i].Name, SList[i].Path);
// clear out path and the old DestShare
memset(SList[i].Path, 0, sizeof(SList[i].Path));
SList[i].DestShare = NULL;
// Now map it to a dest share
MapShare(&SList[i], DServ);
// Restore real name
lstrcpy(SList[i].Name, tmpName);
}
}
if (VMap != NULL)
FreeMemory(VMap);
} // SourceShareListFixup
/*+-------------------------------------------------------------------------+
| DestShareListFixup()
|
+-------------------------------------------------------------------------+*/
void DestShareListFixup(DEST_SERVER_BUFFER *DServ) {
SHARE_BUFFER *SList, *oSList;
SHARE_LIST *oShareList;
ULONG i, oi;
DRIVE_LIST *DList;
DRIVE_BUFFER *DBuff;
BOOL match;
if (DServ->ShareList == NULL)
return;
if (DServ->ShareList->Fixup == FALSE)
return; // do not fixup twice...
DServ->ShareList->Fixup = FALSE;
DList = DServ->DriveList;
DBuff = DList->DList;
oShareList = DServ->ShareList;
NTSharesEnum(&DServ->ShareList, DServ->DriveList);
if (DServ->ShareList == NULL)
return;
SList = DServ->ShareList->SList;
oSList = oShareList->SList;
for (i = 0; i < DServ->ShareList->Count; i++) {
match = FALSE;
oi = 0;
while ((!match) && (oi < oShareList->Count)) {
if (!lstrcmpi(SList[i].Name, oSList[oi].Name)) {
SList[i].Convert = oSList[oi].Convert;
SList[i].HiddenFiles = oSList[oi].HiddenFiles;
SList[i].SystemFiles = oSList[oi].SystemFiles;
match = TRUE;
}
oi++;
}
}
FreeMemory(oShareList);
} // DestShareListFixup
/*+-------------------------------------------------------------------------+
| ShareListSave()
|
+-------------------------------------------------------------------------+*/
void ShareListSave(HANDLE hFile, SHARE_LIST *ShareList) {
SHARE_BUFFER *SList;
VIRTUAL_SHARE_BUFFER *VShare;
DWORD wrote;
ULONG Size, i;
DWORD *sb = NULL;
if (ShareList == NULL)
return;
Size = sizeof(SHARE_LIST) + (ShareList->Count * sizeof(SHARE_BUFFER));
WriteFile(hFile, &Size, sizeof(Size), &wrote, NULL);
// Need to make a temp array to hold DestShare info
sb = AllocMemory(ShareList->Count * sizeof(DWORD));
SList = ShareList->SList;
// Copy DestShares to temp holding place and replace them with
// their index
for (i = 0; i < ShareList->Count; i++) {
sb[i] = (DWORD) SList[i].DestShare;
if (SList[i].DestShare != NULL)
if (SList[i].Virtual) {
VShare = (VIRTUAL_SHARE_BUFFER *) SList[i].DestShare;
SList[i].DestShare = (SHARE_BUFFER *) (VShare->Index + 1);
} else {
// put the dest sharename into the path (temporarily) so that on load
// we have the name to match to the new share list. Can't match just
// the sharename to dest-sharename as the admin may have pointed it to
// a new one.
lstrcpy(SList[i].Path, SList[i].DestShare->Name);
SList[i].DestShare = (SHARE_BUFFER *) (SList[i].DestShare->Index + 1);
}
}
ShareList->Fixup = TRUE;
WriteFile(hFile, ShareList, Size, &wrote, NULL);
ShareList->Fixup = FALSE;
// Restore DestShare pointers
for (i = 0; i < ShareList->Count; i++)
SList[i].DestShare = (SHARE_BUFFER *) sb[i];
if (sb != NULL)
FreeMemory(sb);
// Share list array is saved out - now save out linked information
for (i = 0; i < ShareList->Count; i++)
if (SList[i].Root != NULL)
TreeSave(hFile, SList[i].Root);
} // ShareListSave
/*+-------------------------------------------------------------------------+
| ShareListLoad()
|
+-------------------------------------------------------------------------+*/
void ShareListLoad(HANDLE hFile, SHARE_LIST **lpShareList) {
SHARE_BUFFER *SList;
SHARE_LIST *ShareList;
ULONG Size, i;
DWORD wrote;
// Get how long this record is
ReadFile(hFile, &Size, sizeof(Size), &wrote, NULL);
ShareList = AllocMemory(Size);
if (ShareList == NULL)
return;
ReadFile(hFile, ShareList, Size, &wrote, NULL);
// Share list array is read in - now load linked information
SList = ShareList->SList;
for (i = 0; i < ShareList->Count; i++)
if (SList[i].Root != NULL) {
SList[i].Root = NULL;
TreeLoad(hFile, &SList[i].Root);
}
*lpShareList = ShareList;
#ifdef DEBUG
dprintf(TEXT("<Share List Load>\n"));
dprintf(TEXT(" Number of Entries: %lu\n\n"), ShareList->Count);
for (i = 0; i < ShareList->Count; i++) {
dprintf(TEXT(" Name: %s\n"), SList[i].Name);
dprintf(TEXT(" Path: %s\n"), SList[i].Path);
}
dprintf(TEXT("\n"));
#endif
} // ShareListLoad
/*+-------------------------------------------------------------------------+
| ShareListLog()
|
+-------------------------------------------------------------------------+*/
void ShareListLog(SHARE_LIST *ShareList, BOOL DestServer) {
ULONG i;
if ((ShareList == NULL) || (ShareList->Count == 0))
return;
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(1, Lids(IDS_L_125));
for (i = 0; i < ShareList->Count; i++) {
LogWriteLog(2, TEXT("%s\r\n"), ShareList->SList[i].Name);
if (DestServer)
LogWriteLog(3, Lids(IDS_L_8), ShareList->SList[i].Path);
}
LogWriteLog(0, Lids(IDS_CRLF));
} // ShareListLog
/*+-------------------------------------------------------------------------+
| Routines for Source Server List |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| SServListAdd()
|
+-------------------------------------------------------------------------+*/
SOURCE_SERVER_BUFFER *SServListAdd(LPTSTR ServerName) {
SOURCE_SERVER_BUFFER *tmpPtr;
ULONG Size;
Size = sizeof(SOURCE_SERVER_BUFFER) + ((lstrlen(ServerName) + 3) * sizeof(TCHAR));
tmpPtr = AllocMemory(Size);
if (tmpPtr != NULL) {
// init it to NULL's
memset(tmpPtr, 0, Size);
tmpPtr->Name = (LPTSTR) ((BYTE *) tmpPtr + sizeof(SOURCE_SERVER_BUFFER));
tmpPtr->LName = tmpPtr->Name;
lstrcpy(tmpPtr->Name, TEXT("\\\\"));
tmpPtr->Name += 2;
lstrcpy(tmpPtr->Name, ServerName);
// link it into the list
if (!SServListStart)
SServListStart = SServListEnd = tmpPtr;
else {
SServListEnd->next = tmpPtr;
tmpPtr->prev = SServListEnd;
SServListEnd = tmpPtr;
}
NumSServs++;
}
return (tmpPtr);
} // SServListAdd
/*+-------------------------------------------------------------------------+
| SServListDelete()
|
+-------------------------------------------------------------------------+*/
void SServListDelete(SOURCE_SERVER_BUFFER *tmpPtr) {
SOURCE_SERVER_BUFFER *PrevPtr;
SOURCE_SERVER_BUFFER *NextPtr;
if (tmpPtr == NULL)
return;
// Delete any attached share list first
ShareListDelete(tmpPtr->ShareList);
// Free any admin share we made
NWUseDel(tmpPtr->Name);
// Now unlink the actual server record
PrevPtr = tmpPtr->prev;
NextPtr = tmpPtr->next;
if (PrevPtr)
PrevPtr->next = NextPtr;
if (NextPtr)
NextPtr->prev = PrevPtr;
// Check if at end of list
if (SServListEnd == tmpPtr)
SServListEnd = PrevPtr;
// Check if at start of list
if (SServListStart == tmpPtr)
SServListStart = NextPtr;
FreeMemory(tmpPtr);
NumSServs--;
if (!NumSServs)
SServListStart = SServListEnd = NULL;
} // SServListDelete
/*+-------------------------------------------------------------------------+
| SServListDeleteAll()
|
+-------------------------------------------------------------------------+*/
void SServListDeleteAll() {
SOURCE_SERVER_BUFFER *ServList;
SOURCE_SERVER_BUFFER *ServListNext;
// Now remove the entries from the internal list
ServList = SServListStart;
while (ServList) {
ServListNext = ServList->next;
SServListDelete(ServList);
ServList = ServListNext;
}
} // SServListDeleteAll
/*+-------------------------------------------------------------------------+
| SServListFind()
|
+-------------------------------------------------------------------------+*/
SOURCE_SERVER_BUFFER *SServListFind(LPTSTR ServerName) {
BOOL Found = FALSE;
SOURCE_SERVER_BUFFER *ServList;
ServList = SServListStart;
while ((ServList && !Found)) {
if (!lstrcmpi(ServList->Name, ServerName))
Found = TRUE;
else
ServList = ServList->next;
}
if (!Found)
ServList = NULL;
return (ServList);
} // SServListFind
/*+-------------------------------------------------------------------------+
| SServListIndex()
|
| The index routines place an index number into each item of the list,
| and is called just before saving out the list. This is so when we
| read them in we can reference pointer links. In their normal state
| these data structures are cross referenced via pointers, but once
| saved/restored the pointers have no meaning, so we use the index to
| re-reference the pointers to the correct data items when they are
| read back in.
|
+-------------------------------------------------------------------------+*/
void SServListIndex() {
SOURCE_SERVER_BUFFER *ServList;
USHORT Count = 0;
ServList = SServListStart;
while (ServList) {
ServList->Index = Count++;
ServList = ServList->next;
}
} // SServListIndex
/*+-------------------------------------------------------------------------+
| SServListIndexMapGet()
|
+-------------------------------------------------------------------------+*/
void SServListIndexMapGet(DWORD **pMap) {
DWORD *Map = NULL;
SOURCE_SERVER_BUFFER *ServList;
Map = AllocMemory(NumSServs * sizeof(DWORD));
*pMap = Map;
if (Map == NULL)
return;
ServList = SServListStart;
while (ServList) {
Map[ServList->Index] = (DWORD) ServList;
ServList = ServList->next;
}
} // SServListIndexMapGet
/*+-------------------------------------------------------------------------+
| SServListFixup()
|
+-------------------------------------------------------------------------+*/
void SServListFixup() {
// There is nothing to fixup in the source server list right now - the
// share list is done later...
} // SServListFixup
/*+-------------------------------------------------------------------------+
| SServListSave()
|
+-------------------------------------------------------------------------+*/
void SServListSave(HANDLE hFile) {
DWORD wrote;
ULONG Size;
SOURCE_SERVER_BUFFER *ServList;
ServList = SServListStart;
while (ServList) {
Size = (lstrlen(ServList->Name) + 3) * sizeof(TCHAR);
Size += sizeof(SOURCE_SERVER_BUFFER);
WriteFile(hFile, &Size, sizeof(Size), &wrote, NULL);
WriteFile(hFile, ServList, Size, &wrote, NULL);
// Now save out linked information
ShareListSave(hFile, ServList->ShareList);
ServList = ServList->next;
}
} // SServListSave
/*+-------------------------------------------------------------------------+
| SServListLoad()
|
+-------------------------------------------------------------------------+*/
void SServListLoad(HANDLE hFile) {
BOOL Continue = TRUE;
ULONG Size;
SOURCE_SERVER_BUFFER *tmpPtr;
DWORD wrote;
while (Continue) {
// Get how long this record is
ReadFile(hFile, &Size, sizeof(Size), &wrote, NULL);
tmpPtr = AllocMemory(Size);
if (tmpPtr == NULL)
return;
// Read in the record
ReadFile(hFile, tmpPtr, Size, &wrote, NULL);
// See if there are more records
if (tmpPtr->next == NULL)
Continue = FALSE;
// clear out the old links - and fixup new ones
tmpPtr->next = NULL;
tmpPtr->prev = NULL;
tmpPtr->LName = (LPTSTR) ((BYTE *) tmpPtr + sizeof(SOURCE_SERVER_BUFFER));
tmpPtr->Name = tmpPtr->LName + 2;
// link it into the list
if (!SServListStart)
SServListStart = SServListEnd = tmpPtr;
else {
SServListEnd->next = tmpPtr;
tmpPtr->prev = SServListEnd;
SServListEnd = tmpPtr;
}
#ifdef DEBUG
dprintf(TEXT("<Source Server Load>\n"));
dprintf(TEXT(" Name: %s\n"), tmpPtr->Name);
dprintf(TEXT(" Version: %u.%u\n\n"), (UINT) tmpPtr->VerMaj, (UINT) tmpPtr->VerMin);
#endif
// Now load in linked information
if (tmpPtr->ShareList != NULL) {
tmpPtr->ShareList = NULL;
ShareListLoad(hFile, &tmpPtr->ShareList);
}
NumSServs++;
}
} // SServListLoad
/*+-------------------------------------------------------------------------+
| Routines for Destination Server List |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| DServListAdd()
|
+-------------------------------------------------------------------------+*/
DEST_SERVER_BUFFER *DServListAdd(LPTSTR ServerName) {
DEST_SERVER_BUFFER *tmpPtr;
ULONG Size, strlen1;
strlen1 = (lstrlen(ServerName) + 3) * sizeof(TCHAR);
Size = sizeof(DEST_SERVER_BUFFER) + strlen1;
tmpPtr = AllocMemory(Size);
if (tmpPtr != NULL) {
// init it to NULL's
memset(tmpPtr, 0, Size);
tmpPtr->Name = (LPTSTR) ((BYTE *) tmpPtr + sizeof(DEST_SERVER_BUFFER));
tmpPtr->LName = tmpPtr->Name;
lstrcpy(tmpPtr->Name, TEXT("\\\\"));
tmpPtr->Name += 2;
lstrcpy(tmpPtr->Name, ServerName);
// link it into the list
if (!DServListStart)
DServListStart = DServListEnd = tmpPtr;
else {
DServListEnd->next = tmpPtr;
tmpPtr->prev = DServListEnd;
DServListEnd = tmpPtr;
}
NumDServs++;
}
return (tmpPtr);
} // DServListAdd
/*+-------------------------------------------------------------------------+
| DServListDelete()
|
+-------------------------------------------------------------------------+*/
void DServListDelete(DEST_SERVER_BUFFER *tmpPtr) {
DEST_SERVER_BUFFER *PrevPtr;
DEST_SERVER_BUFFER *NextPtr;
if (tmpPtr == NULL)
return;
if (tmpPtr->UseCount) {
// Decrement use count, only delete if actually gone.
tmpPtr->UseCount--;
if (tmpPtr->UseCount)
return;
}
// Delete any attached share list first
ShareListDelete(tmpPtr->ShareList);
// ...and virtual share list
VShareListDeleteAll(tmpPtr);
// ...and any drive list
if (tmpPtr->DriveList)
FreeMemory(tmpPtr->DriveList);
// ... domain as well
DomainListDelete(tmpPtr->Domain);
// -- don't free for user convenience, we will clean up at end, otherwise
// user must enter in password if delete/add
// Free any admin share we made
// NTUseDel(tmpPtr->Name);
// Now unlink the actual server record
PrevPtr = tmpPtr->prev;
NextPtr = tmpPtr->next;
if (PrevPtr)
PrevPtr->next = NextPtr;
if (NextPtr)
NextPtr->prev = PrevPtr;
// Check if at end of list
if (DServListEnd == tmpPtr)
DServListEnd = PrevPtr;
// Check if at start of list
if (DServListStart == tmpPtr)
DServListStart = NextPtr;
FreeMemory(tmpPtr);
NumDServs--;
if (!NumDServs)
DServListStart = DServListEnd = NULL;
} // DServListDelete
/*+-------------------------------------------------------------------------+
| DServListDeleteAll()
|
+-------------------------------------------------------------------------+*/
void DServListDeleteAll() {
DEST_SERVER_BUFFER *ServList;
DEST_SERVER_BUFFER *ServListNext;
// Now remove the entries from the internal list
ServList = DServListStart;
while (ServList) {
ServListNext = ServList->next;
ServList->UseCount = 0;
DServListDelete(ServList);
ServList = ServListNext;
}
} // DServListDeleteAll
/*+-------------------------------------------------------------------------+
| DServListFind()
|
+-------------------------------------------------------------------------+*/
DEST_SERVER_BUFFER *DServListFind(LPTSTR ServerName) {
BOOL Found = FALSE;
DEST_SERVER_BUFFER *ServList;
ServList = DServListStart;
while ((ServList && !Found)) {
if (!lstrcmpi(ServList->Name, ServerName))
Found = TRUE;
else
ServList = ServList->next;
}
if (!Found)
ServList = NULL;
return (ServList);
} // DServListFind
/*+-------------------------------------------------------------------------+
| DServListIndex()
|
+-------------------------------------------------------------------------+*/
void DServListIndex() {
DEST_SERVER_BUFFER *ServList;
USHORT Count = 0;
ServList = DServListStart;
while (ServList) {
ServList->Index = Count++;
// Now index the virtual shares for this server
VShareListIndex(ServList);
ServList = ServList->next;
}
} // DServListIndex
/*+-------------------------------------------------------------------------+
| DServListIndexMapGet()
|
+-------------------------------------------------------------------------+*/
void DServListIndexMapGet(DWORD **pMap) {
DWORD *Map = NULL;
DEST_SERVER_BUFFER *ServList;
Map = AllocMemory(NumDServs * sizeof(DWORD));
*pMap = Map;
if (Map == NULL)
return;
ServList = DServListStart;
while (ServList) {
Map[ServList->Index] = (DWORD) ServList;
ServList = ServList->next;
}
} // DServListIndexMapGet
/*+-------------------------------------------------------------------------+
| DServListFixup()
|
+-------------------------------------------------------------------------+*/
void DServListFixup() {
DEST_SERVER_BUFFER *ServList;
DWORD *DMap = NULL;
DomainListIndexMapGet(&DMap);
if (DMap == NULL)
return;
// Just need to fixup the domain list pointers
ServList = DServListStart;
while (ServList) {
if (ServList->Domain != NULL)
ServList->Domain = (DOMAIN_BUFFER *) DMap[(DWORD) ServList->Domain - 1];
ServList = ServList->next;
}
FreeMemory(DMap);
} // DServListFixup
/*+-------------------------------------------------------------------------+
| DServListSave()
|
+-------------------------------------------------------------------------+*/
void DServListSave(HANDLE hFile) {
DWORD wrote;
ULONG Size;
DEST_SERVER_BUFFER *ServList;
DOMAIN_BUFFER *db;
ServList = DServListStart;
while (ServList) {
Size = (lstrlen(ServList->Name) + 3) * sizeof(TCHAR);
Size += sizeof(DEST_SERVER_BUFFER);
WriteFile(hFile, &Size, sizeof(Size), &wrote, NULL);
// Need to de-reference the domain pointers to their index, and after
// saving restore them.
db = ServList->Domain;
if (ServList->Domain != NULL)
ServList->Domain = (DOMAIN_BUFFER *) (ServList->Domain->Index + 1);
WriteFile(hFile, ServList, Size, &wrote, NULL);
ServList->Domain = db;
// Now save out linked information
ShareListSave(hFile, ServList->ShareList);
VShareListSave(hFile, ServList);
ServList = ServList->next;
}
} // DServListSave
/*+-------------------------------------------------------------------------+
| DServListLoad()
|
+-------------------------------------------------------------------------+*/
void DServListLoad(HANDLE hFile) {
BOOL Continue = TRUE;
ULONG Size;
DEST_SERVER_BUFFER *tmpPtr;
DWORD wrote;
while (Continue) {
// Get how long this record is
ReadFile(hFile, &Size, sizeof(Size), &wrote, NULL);
tmpPtr = AllocMemory(Size);
if (tmpPtr == NULL)
return;
// Read in the record
ReadFile(hFile, tmpPtr, Size, &wrote, NULL);
// See if there are more records
if (tmpPtr->next == NULL)
Continue = FALSE;
// clear out the old links - and fixup new ones
tmpPtr->next = NULL;
tmpPtr->prev = NULL;
tmpPtr->LName = (LPTSTR) ((BYTE *) tmpPtr + sizeof(DEST_SERVER_BUFFER));
tmpPtr->Name = tmpPtr->LName + 2;
// link it into the list
if (!DServListStart)
DServListStart = DServListEnd = tmpPtr;
else {
DServListEnd->next = tmpPtr;
tmpPtr->prev = DServListEnd;
DServListEnd = tmpPtr;
}
// The drive list is no longer valid - so clear it out.
tmpPtr->DriveList = NULL;
#ifdef DEBUG
dprintf(TEXT("<Dest Server Load>\n"));
dprintf(TEXT(" Name: %s\n"), tmpPtr->Name);
dprintf(TEXT(" Version: %u.%u\n\n"), (UINT) tmpPtr->VerMaj, (UINT) tmpPtr->VerMin);
#endif
// Now load in linked information
if (tmpPtr->ShareList != NULL) {
tmpPtr->ShareList = NULL;
ShareListLoad(hFile, &tmpPtr->ShareList);
}
if (tmpPtr->VShareStart != NULL) {
tmpPtr->NumVShares = 0;
tmpPtr->VShareStart = tmpPtr->VShareEnd = NULL;
VShareListLoad(hFile, tmpPtr);
}
NumDServs++;
}
} // DServListLoad
/*+-------------------------------------------------------------------------+
| DServListSpaceFree()
|
+-------------------------------------------------------------------------+*/
void DServListSpaceFree() {
DEST_SERVER_BUFFER *ServList;
DRIVE_BUFFER *Drive;
DRIVE_LIST *DList;
ULONG i;
ServList = DServListStart;
while (ServList) {
DList = ServList->DriveList;
if (DList != NULL) {
Drive = DList->DList;
for (i = 0; i < DList->Count; i++)
Drive[i].AllocSpace = 0;
}
ServList = ServList->next;
}
} // DServListSpaceFree
/*+-------------------------------------------------------------------------+
| Routines for Virtual Share Lists |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| VShareListAdd()
|
+-------------------------------------------------------------------------+*/
VIRTUAL_SHARE_BUFFER *VShareListAdd(DEST_SERVER_BUFFER *DServ, LPTSTR ShareName, LPTSTR Path) {
VIRTUAL_SHARE_BUFFER *tmpPtr;
ULONG Size, strlen1;
// base struct + both strings and 2 ending NULL's
strlen1 = ((lstrlen(ShareName)+ 1) * sizeof(TCHAR));
Size = sizeof(VIRTUAL_SHARE_BUFFER) + strlen1;
tmpPtr = AllocMemory(Size);
if (tmpPtr != NULL) {
// init it to NULL's
memset(tmpPtr, 0, Size);
tmpPtr->VFlag = TRUE;
tmpPtr->Name = (LPTSTR) ((BYTE *) tmpPtr + sizeof(VIRTUAL_SHARE_BUFFER));
lstrcpy(tmpPtr->Name, ShareName);
lstrcpy(tmpPtr->Path, Path);
// link it into the list
if (!DServ->VShareStart)
DServ->VShareStart = DServ->VShareEnd = tmpPtr;
else {
DServ->VShareEnd->next = tmpPtr;
tmpPtr->prev = DServ->VShareEnd;
DServ->VShareEnd = tmpPtr;
}
DServ->NumVShares++;
}
return (tmpPtr);
} // VShareListAdd
/*+-------------------------------------------------------------------------+
| VShareListDelete()
|
+-------------------------------------------------------------------------+*/
void VShareListDelete(DEST_SERVER_BUFFER *DServ, VIRTUAL_SHARE_BUFFER *tmpPtr) {
VIRTUAL_SHARE_BUFFER *PrevPtr;
VIRTUAL_SHARE_BUFFER *NextPtr;
if (tmpPtr == NULL)
return;
if (tmpPtr->UseCount) {
// Decrement use count, only delete if actually gone.
tmpPtr->UseCount--;
if (tmpPtr->UseCount > 0)
return;
}
PrevPtr = tmpPtr->prev;
NextPtr = tmpPtr->next;
if (PrevPtr)
PrevPtr->next = NextPtr;
if (NextPtr)
NextPtr->prev = PrevPtr;
// Check if at end of list
if (DServ->VShareEnd == tmpPtr)
DServ->VShareEnd = PrevPtr;
// Check if at start of list
if (DServ->VShareStart == tmpPtr)
DServ->VShareStart = NextPtr;
FreeMemory(tmpPtr);
DServ->NumVShares--;
if (!DServ->NumVShares)
DServ->VShareStart = DServ->VShareEnd = NULL;
} // VShareListDelete
/*+-------------------------------------------------------------------------+
| VShareListDeleteAll()
|
+-------------------------------------------------------------------------+*/
void VShareListDeleteAll(DEST_SERVER_BUFFER *DServ) {
VIRTUAL_SHARE_BUFFER *ShareList;
VIRTUAL_SHARE_BUFFER *ShareListNext;
// Now remove the entries from the internal list
ShareList = DServ->VShareStart;
while (ShareList) {
ShareListNext = ShareList->next;
// Flag to zero to make sure destroyed
ShareList->UseCount = 0;
VShareListDelete(DServ, ShareList);
ShareList = ShareListNext;
}
} // VShareListDeleteAll
/*+-------------------------------------------------------------------------+
| VShareListIndex()
|
+-------------------------------------------------------------------------+*/
void VShareListIndex(DEST_SERVER_BUFFER *DServ) {
VIRTUAL_SHARE_BUFFER *ShareList;
USHORT Count = 0;
ShareList = DServ->VShareStart;
while (ShareList) {
ShareList->Index = Count++;
ShareList = ShareList->next;
}
} // VShareListIndex
/*+-------------------------------------------------------------------------+
| VShareListIndexMapGet()
|
+-------------------------------------------------------------------------+*/
void VShareListIndexMapGet(DEST_SERVER_BUFFER *DServ, DWORD **pMap) {
DWORD *Map = NULL;
VIRTUAL_SHARE_BUFFER *ShareList;
Map = AllocMemory( DServ->NumVShares * sizeof(DWORD) );
*pMap = Map;
if (Map == NULL)
return;
ShareList = DServ->VShareStart;
while (ShareList) {
Map[ShareList->Index] = (DWORD) ShareList;
ShareList = ShareList->next;
}
} // VShareListIndexMapGet
/*+-------------------------------------------------------------------------+
| VShareListSave()
|
+-------------------------------------------------------------------------+*/
void VShareListSave(HANDLE hFile, DEST_SERVER_BUFFER *DServ) {
DWORD wrote;
ULONG Size;
VIRTUAL_SHARE_BUFFER *ShareList;
ShareList = DServ->VShareStart;
while (ShareList) {
Size = (lstrlen(ShareList->Name) + 1) * sizeof(TCHAR);
Size += sizeof(VIRTUAL_SHARE_BUFFER);
WriteFile(hFile, &Size, sizeof(Size), &wrote, NULL);
WriteFile(hFile, ShareList, Size, &wrote, NULL);
ShareList = ShareList->next;
}
} // VShareListSave
/*+-------------------------------------------------------------------------+
| VShareListLoad()
|
+-------------------------------------------------------------------------+*/
void VShareListLoad(HANDLE hFile, DEST_SERVER_BUFFER *DServ) {
BOOL Continue = TRUE;
ULONG Size;
VIRTUAL_SHARE_BUFFER *tmpPtr;
DWORD wrote;
while (Continue) {
// Get how long this record is
ReadFile(hFile, &Size, sizeof(Size), &wrote, NULL);
tmpPtr = AllocMemory(Size);
if (tmpPtr == NULL)
return;
// Read in the record
ReadFile(hFile, tmpPtr, Size, &wrote, NULL);
// See if there are more records
if (tmpPtr->next == NULL)
Continue = FALSE;
// clear out the old links - and fixup new ones
tmpPtr->next = NULL;
tmpPtr->prev = NULL;
tmpPtr->Name = (LPTSTR) ((BYTE *) tmpPtr + sizeof(VIRTUAL_SHARE_BUFFER));
tmpPtr->Drive = NULL;
// link it into the list
if (!DServ->VShareStart)
DServ->VShareStart = DServ->VShareEnd = tmpPtr;
else {
DServ->VShareEnd->next = tmpPtr;
tmpPtr->prev = DServ->VShareEnd;
DServ->VShareEnd = tmpPtr;
}
DServ->NumVShares++;
}
} // VShareListLoad
/*+-------------------------------------------------------------------------+
| VShareListFixup()
|
+-------------------------------------------------------------------------+*/
void VShareListFixup(DEST_SERVER_BUFFER *DServ) {
VIRTUAL_SHARE_BUFFER *VShare;
USHORT Count = 0;
DWORD di;
DRIVE_LIST *Drives;
DRIVE_BUFFER *DList;
ULONG TotalDrives;
TCHAR Drive[2];
if (DServ->DriveList == NULL)
return;
TotalDrives = 0;
Drives = DServ->DriveList;
Drive[1] = TEXT('\0');
DList = Drives->DList;
TotalDrives = Drives->Count;
VShare = DServ->VShareStart;
while (VShare) {
VShare->Drive = NULL;
// Scan drive list looking for match to share path
for (di = 0; di < TotalDrives; di++) {
// Get first char from path - should be drive letter
Drive[0] = *VShare->Path;
if (!lstrcmpi(Drive, DList[di].Drive))
VShare->Drive = &DList[di];
}
VShare = VShare->next;
}
} // VShareListFixup
/*+-------------------------------------------------------------------------+
| Routines for Domain Lists |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| DomainListAdd()
|
+-------------------------------------------------------------------------+*/
DOMAIN_BUFFER *DomainListAdd(LPTSTR DomainName, LPTSTR PDCName) {
DOMAIN_BUFFER *tmpPtr;
ULONG Size, strlen1, strlen2;
// base struct + both strings and 2 ending NULL's
strlen1 = ((lstrlen(DomainName) + 1) * sizeof(TCHAR));
strlen2 = ((lstrlen(PDCName) + 1) * sizeof(TCHAR));
Size = sizeof(DOMAIN_BUFFER) + strlen1 + strlen2;
tmpPtr = AllocMemory(Size);
if (tmpPtr != NULL) {
// init it to NULL's
memset(tmpPtr, 0, Size);
tmpPtr->Name = (LPTSTR) ((BYTE *) tmpPtr + sizeof(DOMAIN_BUFFER));
tmpPtr->PDCName = (LPTSTR) ((BYTE *) tmpPtr + sizeof(DOMAIN_BUFFER) + strlen1);
lstrcpy(tmpPtr->Name, DomainName);
lstrcpy(tmpPtr->PDCName, PDCName);
// link it into the list
if (!DomainListStart)
DomainListStart = DomainListEnd = tmpPtr;
else {
DomainListEnd->next = tmpPtr;
tmpPtr->prev = DomainListEnd;
DomainListEnd = tmpPtr;
}
NumDomains++;
}
return (tmpPtr);
} // DomainListAdd
/*+-------------------------------------------------------------------------+
| DomainListDelete()
|
+-------------------------------------------------------------------------+*/
void DomainListDelete(DOMAIN_BUFFER *tmpPtr) {
DOMAIN_BUFFER *PrevPtr;
DOMAIN_BUFFER *NextPtr;
if (tmpPtr == NULL)
return;
if (tmpPtr->UseCount) {
// Decrement use count, only delete if actually gone.
tmpPtr->UseCount--;
if (tmpPtr->UseCount)
return;
}
PrevPtr = tmpPtr->prev;
NextPtr = tmpPtr->next;
if (PrevPtr)
PrevPtr->next = NextPtr;
if (NextPtr)
NextPtr->prev = PrevPtr;
// Check if at end of list
if (DomainListEnd == tmpPtr)
DomainListEnd = PrevPtr;
// Check if at start of list
if (DomainListStart == tmpPtr)
DomainListStart = NextPtr;
FreeMemory(tmpPtr);
NumDomains--;
if (!NumDomains)
DomainListStart = DomainListEnd = NULL;
} // DomainListDelete
/*+-------------------------------------------------------------------------+
| DomainListDeleteAll()
|
+-------------------------------------------------------------------------+*/
void DomainListDeleteAll() {
DOMAIN_BUFFER *DomList;
DOMAIN_BUFFER *DomListNext;
// Now remove the entries from the internal list
DomList = DomainListStart;
while (DomList) {
DomListNext = DomList->next;
DomList->UseCount = 0;
DomainListDelete(DomList);
DomList = DomListNext;
}
} // DomainListDeleteAll
/*+-------------------------------------------------------------------------+
| DomainListFind()
|
+-------------------------------------------------------------------------+*/
DOMAIN_BUFFER *DomainListFind(LPTSTR DomainName) {
BOOL Found = FALSE;
DOMAIN_BUFFER *DomainList;
DomainList = DomainListStart;
while ((DomainList && !Found)) {
if (!lstrcmpi(DomainList->Name, DomainName))
Found = TRUE;
else
DomainList = DomainList->next;
}
if (!Found)
DomainList = NULL;
return (DomainList);
} // DomainListFind
/*+-------------------------------------------------------------------------+
| DomainListIndex()
|
+-------------------------------------------------------------------------+*/
void DomainListIndex() {
DOMAIN_BUFFER *DomList;
USHORT Count = 0;
DomList = DomainListStart;
while (DomList) {
DomList->Index = Count++;
DomList = DomList->next;
}
} // DomainListIndex
/*+-------------------------------------------------------------------------+
| DomainListIndexMapGet()
|
+-------------------------------------------------------------------------+*/
void DomainListIndexMapGet(DWORD **pMap) {
DWORD *Map = NULL;
DOMAIN_BUFFER *DomList;
Map = AllocMemory(NumDomains * sizeof(DWORD));
*pMap = Map;
if (Map == NULL)
return;
DomList = DomainListStart;
while (DomList) {
Map[DomList->Index] = (DWORD) DomList;
DomList = DomList->next;
}
} // DomainListIndexMapGet
/*+-------------------------------------------------------------------------+
| DomainListSave()
|
+-------------------------------------------------------------------------+*/
void DomainListSave(HANDLE hFile) {
DWORD wrote;
ULONG Size;
DOMAIN_BUFFER *DomList;
WriteFile(hFile, &NumDomains, sizeof(NumDomains), &wrote, NULL);
DomList = DomainListStart;
while (DomList) {
Size = (lstrlen(DomList->Name) + 1) * sizeof(TCHAR);
Size += (lstrlen(DomList->PDCName) + 1) * sizeof(TCHAR);
Size += sizeof(DOMAIN_BUFFER);
WriteFile(hFile, &Size, sizeof(Size), &wrote, NULL);
WriteFile(hFile, DomList, Size, &wrote, NULL);
DomList = DomList->next;
}
} // DomainListSave
/*+-------------------------------------------------------------------------+
| DomainListLoad()
|
+-------------------------------------------------------------------------+*/
void DomainListLoad(HANDLE hFile) {
BOOL Continue = TRUE;
ULONG Size, namelen;
DOMAIN_BUFFER *tmpPtr;
DWORD wrote;
ReadFile(hFile, &NumDomains, sizeof(NumDomains), &wrote, NULL);
if (NumDomains == 0)
Continue = FALSE;
NumDomains = 0;
while (Continue) {
// Get how long this record is
ReadFile(hFile, &Size, sizeof(Size), &wrote, NULL);
tmpPtr = AllocMemory(Size);
if (tmpPtr == NULL)
return;
// Read in the record
ReadFile(hFile, tmpPtr, Size, &wrote, NULL);
// See if there are more records
if (tmpPtr->next == NULL)
Continue = FALSE;
// clear out the old links - and fixup new ones
tmpPtr->next = NULL;
tmpPtr->prev = NULL;
tmpPtr->Name = (LPTSTR) ((BYTE *) tmpPtr + sizeof(DOMAIN_BUFFER));
namelen = ((lstrlen(tmpPtr->Name) + 1) * sizeof(TCHAR));
tmpPtr->PDCName = (LPTSTR) ((BYTE *) tmpPtr + sizeof(DOMAIN_BUFFER) + namelen);
#ifdef DEBUG
dprintf(TEXT("<Domain List Load>\n"));
dprintf(TEXT(" Name: %s\n"), tmpPtr->Name);
dprintf(TEXT(" PDC Name: %s\n\n"), tmpPtr->PDCName);
#endif
// link it into the list
if (!DomainListStart)
DomainListStart = DomainListEnd = tmpPtr;
else {
DomainListEnd->next = tmpPtr;
tmpPtr->prev = DomainListEnd;
DomainListEnd = tmpPtr;
}
NumDomains++;
}
} // DomainListLoad
/*+-------------------------------------------------------------------------+
| Routines for Convert Lists |
+-------------------------------------------------------------------------+*/
/*+-------------------------------------------------------------------------+
| ConvertListAdd()
|
| Allocates and inserts a new record for holding a server pair and
| associated conversion options.
|
| Comments:
| The convert list is a doubly linked list of records. Each record
| contains the source and destination server (server-pair) and a
| pointer to the conversion specific information. The exact info
| is specific to the platform being converted from (source server type)
|
+-------------------------------------------------------------------------+*/
CONVERT_LIST *ConvertListAdd(SOURCE_SERVER_BUFFER *SourceServer, DEST_SERVER_BUFFER *DestServer) {
CONVERT_OPTIONS *cvo;
CONVERT_LIST *tmpPtr;
CONVERT_LIST *cPtr;
BOOL match = FALSE;
tmpPtr = AllocMemory(sizeof(CONVERT_LIST));
if (tmpPtr != NULL) {
// zero it out
memset(tmpPtr, 0, sizeof(CONVERT_LIST));
tmpPtr->SourceServ = SourceServer;
tmpPtr->FileServ = DestServer;
// initialize the conversion options
UserOptionsInit(&tmpPtr->ConvertOptions);
// Set NetWareInfo based on current FPNW setting...
cvo = (CONVERT_OPTIONS *) tmpPtr->ConvertOptions;
cvo->NetWareInfo = DestServer->IsFPNW;
FileOptionsInit(&tmpPtr->FileOptions);
// link it into the list - we want to link right after another
// convert to this same server, or to the same domain. otherwise
// tag it onto the end of the list.
if (!ConvertListStart)
ConvertListStart = ConvertListEnd = tmpPtr;
else {
// Have some files in the list - find out if destination server
// is already in the list and if so append after it.
if (DestServer->UseCount > 1) {
// should be in the list so find it.
cPtr = ConvertListStart;
while (cPtr && !match) {
if (!lstrcmpi(DestServer->Name, cPtr->FileServ->Name))
match = TRUE;
else
cPtr = cPtr->next;
}
if (match) {
// have a match - so go to the end of the matching pairs...
while (cPtr && match) {
if (lstrcmpi(DestServer->Name, cPtr->FileServ->Name))
match = FALSE;
else
cPtr = cPtr->next;
}
match = !match;
}
}
// if didn't find a server match - look for a domain match
if (!match) {
if (DestServer->InDomain && DestServer->Domain) {
// should be in the list so find it.
cPtr = ConvertListStart;
while (cPtr && !match) {
if (cPtr->FileServ->InDomain && cPtr->FileServ->Domain)
if (!lstrcmpi(DestServer->Domain->Name, cPtr->FileServ->Domain->Name))
match = TRUE;
if (!match)
cPtr = cPtr->next;
}
if (match) {
// have a match - so go to the end of the matching pairs...
while (cPtr && match) {
if (cPtr->FileServ->InDomain && cPtr->FileServ->Domain) {
if (lstrcmpi(DestServer->Domain->Name, cPtr->FileServ->Domain->Name))
match = FALSE;
} else
match = FALSE;
if (match)
cPtr = cPtr->next;
}
match = !match;
}
}
}
// if match then in middle of buffer, else use end
if (match && (cPtr != ConvertListEnd)) {
tmpPtr->prev = cPtr->prev;
tmpPtr->next = cPtr;
cPtr->prev->next = tmpPtr;
} else {
// only one in list so add at end
ConvertListEnd->next = tmpPtr;
tmpPtr->prev = ConvertListEnd;
ConvertListEnd = tmpPtr;
}
}
NumServerPairs++;
}
return (tmpPtr);
} // ConvertListAdd
/*+-------------------------------------------------------------------------+
| ConvertListDelete()
|
| Removes and deallocates a convert list entry from the conversion
| list.
|
+-------------------------------------------------------------------------+*/
void ConvertListDelete(CONVERT_LIST *tmpPtr) {
CONVERT_LIST *PrevPtr;
CONVERT_LIST *NextPtr;
// First get rid of the source and destination server this is pointing to -
// those routines take care of freeing up chained data structures. Also
// DServList will only be delete if it's UseCount goes to 0.
SServListDelete(tmpPtr->SourceServ);
DServListDelete(tmpPtr->FileServ);
// Now unlink the actual convert list record
PrevPtr = tmpPtr->prev;
NextPtr = tmpPtr->next;
if (PrevPtr)
PrevPtr->next = NextPtr;
if (NextPtr)
NextPtr->prev = PrevPtr;
// Check if at end of list
if (ConvertListEnd == tmpPtr)
ConvertListEnd = PrevPtr;
// Check if at start of list
if (ConvertListStart == tmpPtr)
ConvertListStart = NextPtr;
FreeMemory(tmpPtr->ConvertOptions);
FreeMemory(tmpPtr);
NumServerPairs--;
if (!NumServerPairs)
ConvertListStart = ConvertListEnd = NULL;
} // ConvertListDelete
/*+-------------------------------------------------------------------------+
| ConvertListDeleteAll()
|
| Removes and deallocates all the convert list entrys and removes them
| from the listbox.
|
+-------------------------------------------------------------------------+*/
void ConvertListDeleteAll() {
CONVERT_LIST *ConvList;
CONVERT_LIST *ConvListNext;
// Now remove the entries from the internal list
ConvList = ConvertListStart;
while (ConvList) {
ConvListNext = ConvList->next;
ConvertListDelete(ConvList);
ConvList = ConvListNext;
}
} // ConvertListDeleteAll
/*+-------------------------------------------------------------------------+
| ConvertListSaveAll()
|
+-------------------------------------------------------------------------+*/
void ConvertListSaveAll(HANDLE hFile) {
DWORD wrote;
SOURCE_SERVER_BUFFER *ss;
DEST_SERVER_BUFFER *ds;
// First need to walk source and dest server lists and re-synch the
// index numbers as we can't use pointers loading them back in.
SServListIndex();
DServListIndex(); // Takes care of the VShares
DomainListIndex();
// Done with re-synch of indexes - do actual saving.
CurrentConvertList = ConvertListStart;
while (CurrentConvertList) {
// Need to de-reference the server pointers to their index, and after
// saving restore them.
ss = CurrentConvertList->SourceServ;
ds = CurrentConvertList->FileServ;
CurrentConvertList->SourceServ = (SOURCE_SERVER_BUFFER *) CurrentConvertList->SourceServ->Index;
CurrentConvertList->FileServ = (DEST_SERVER_BUFFER *) CurrentConvertList->FileServ->Index;
WriteFile(hFile, CurrentConvertList, sizeof(CONVERT_LIST), &wrote, NULL);
CurrentConvertList->SourceServ = ss;
CurrentConvertList->FileServ = ds;
// Now the options
UserOptionsSave(hFile, CurrentConvertList->ConvertOptions);
FileOptionsSave(hFile, CurrentConvertList->FileOptions);
CurrentConvertList = CurrentConvertList->next;
}
// Saved out the convert list - now need to save out the linked
// information (these routines save their linked info as well).
DomainListSave(hFile);
DServListSave(hFile);
SServListSave(hFile);
} // ConvertListSaveAll
/*+-------------------------------------------------------------------------+
| ConvertListLoadAll()
|
+-------------------------------------------------------------------------+*/
void ConvertListLoadAll(HANDLE hFile) {
CONVERT_LIST *tmpPtr;
BOOL Continue = TRUE;
DWORD wrote;
while (Continue) {
tmpPtr = AllocMemory(sizeof(CONVERT_LIST));
if (tmpPtr == NULL)
return;
// Read in the record
ReadFile(hFile, tmpPtr, sizeof(CONVERT_LIST), &wrote, NULL);
// See if there are more records
if (tmpPtr->next == NULL)
Continue = FALSE;
// clear out the old links - and fixup new ones
tmpPtr->next = NULL;
tmpPtr->prev = NULL;
tmpPtr->ConvertOptions = NULL;
tmpPtr->FileOptions = NULL;
// Read in options - note the trusted domain must be fixed up later
// after the domain list is read in
UserOptionsLoad(hFile, &tmpPtr->ConvertOptions);
FileOptionsLoad(hFile, &tmpPtr->FileOptions);
// link it into the list
if (!ConvertListStart)
ConvertListStart = ConvertListEnd = tmpPtr;
else {
ConvertListEnd->next = tmpPtr;
tmpPtr->prev = ConvertListEnd;
ConvertListEnd = tmpPtr;
}
NumServerPairs++;
}
// Loaded the convert list - now need to bring in the linked
// information (these routines load their linked info as well).
DomainListLoad(hFile);
DServListLoad(hFile);
SServListLoad(hFile);
} // ConvertListLoadAll
/*+-------------------------------------------------------------------------+
| ConvertListFixup()
|
+-------------------------------------------------------------------------+*/
void ConvertListFixup(HWND hWnd) {
BOOL ok = TRUE;
DWORD *SMap = NULL;
DWORD *DMap = NULL;
CONVERT_LIST *NextList;
CONVERT_OPTIONS *cvto;
// Generate Source and Destination server Index -> pointer maps
DServListIndexMapGet(&DMap);
SServListIndexMapGet(&SMap);
if ((DMap == NULL) || (SMap == NULL))
return;
CurrentConvertList = ConvertListStart;
while (CurrentConvertList) {
CurrentConvertList->FileServ = (DEST_SERVER_BUFFER *) DMap[(DWORD) CurrentConvertList->FileServ];
CurrentConvertList->SourceServ = (SOURCE_SERVER_BUFFER *) SMap[(DWORD) CurrentConvertList->SourceServ];
CurrentConvertList = CurrentConvertList->next;
}
// Free up the index maps
FreeMemory(DMap);
FreeMemory(SMap);
// Fixed the convert list - now need to fix the linked information
// (these routines fix-up their linked info as well).
DServListFixup();
SServListFixup();
// For the user options later on
DomainListIndexMapGet(&DMap);
// Now validate each of the machines
CurrentConvertList = ConvertListStart;
while (CurrentConvertList) {
ok = TRUE;
if (!NTServerValidate(hWnd, CurrentConvertList->FileServ->Name))
ok = FALSE;
if (ok)
if (!NWServerValidate(hWnd, CurrentConvertList->SourceServ->Name, FALSE))
ok = FALSE;
NextList = CurrentConvertList->next;
if (!ok) {
ConvertListDelete(CurrentConvertList);
} else {
// The connections were okay to these so resynch their information
NWServerInfoReset(CurrentConvertList->SourceServ);
NTServerInfoReset(hWnd, CurrentConvertList->FileServ, TRUE);
DestShareListFixup(CurrentConvertList->FileServ);
VShareListFixup(CurrentConvertList->FileServ);
SourceShareListFixup(CurrentConvertList->FileServ, CurrentConvertList->SourceServ->ShareList);
// need to fixup the trusted domain in the user options to the new
// domain list...
cvto = (CONVERT_OPTIONS *) CurrentConvertList->ConvertOptions;
if (cvto->UseTrustedDomain)
cvto->TrustedDomain = (DOMAIN_BUFFER *) DMap[(DWORD) cvto->TrustedDomain];
else
cvto->TrustedDomain = NULL;
}
CurrentConvertList = NextList;
}
// Free up the domain index map
FreeMemory(DMap);
} // ConvertListFixup
/*+-------------------------------------------------------------------------+
| ConvertListLog()
|
+-------------------------------------------------------------------------+*/
void ConvertListLog() {
DEST_SERVER_BUFFER *DServ = NULL;
SOURCE_SERVER_BUFFER *SServ = NULL;
ULONG i;
CurrentConvertList = ConvertListStart;
// Log format is:
//
// Number of Servers = 1
//
// [Servers]
// From: Source1 To: Dest1
// From: Source2 To: Dest2
LogWriteLog(0, Lids(IDS_L_126), NumServerPairs);
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(0, Lids(IDS_L_127));
LogWriteSummary(0, Lids(IDS_L_126), NumServerPairs);
LogWriteSummary(0, Lids(IDS_CRLF));
LogWriteSummary(0, Lids(IDS_L_127));
// Loop through the conversion pairs (they are already in order)
while (CurrentConvertList) {
LogWriteLog(1, Lids(IDS_L_128), CurrentConvertList->SourceServ->Name, CurrentConvertList->FileServ->Name);
LogWriteSummary(1, Lids(IDS_L_128), CurrentConvertList->SourceServ->Name, CurrentConvertList->FileServ->Name);
CurrentConvertList = CurrentConvertList->next;
}
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteSummary(0, Lids(IDS_CRLF));
// Now write detailed info on each server
CurrentConvertList = ConvertListStart;
// header for this section
LogWriteLog(0, Lids(IDS_LINE));
LogWriteLog(0, Lids(IDS_BRACE), Lids(IDS_L_129));
LogWriteLog(0, Lids(IDS_LINE));
LogWriteLog(0, Lids(IDS_CRLF));
while (CurrentConvertList) {
// Make sure to only log each source server once
if (DServ != CurrentConvertList->FileServ) {
// remember this new server
DServ = CurrentConvertList->FileServ;
LogWriteLog(0, TEXT("[%s]\r\n"), CurrentConvertList->FileServ->Name);
LogWriteLog(1, Lids(IDS_L_130));
LogWriteLog(1, Lids(IDS_L_131), DServ->VerMaj, DServ->VerMin);
if (DServ->DriveList) {
LogWriteLog(0, Lids(IDS_CRLF));
LogWriteLog(1, Lids(IDS_L_132));
for (i = 0; i < DServ->DriveList->Count; i++) {
LogWriteLog(2, TEXT("%s: [%4s] %s\r\n"), DServ->DriveList->DList[i].Drive, DServ->DriveList->DList[i].DriveType, DServ->DriveList->DList[i].Name);
LogWriteLog(3, Lids(IDS_L_133), lToStr(DServ->DriveList->DList[i].FreeSpace));
}
}
// Log Shares
ShareListLog(DServ->ShareList, TRUE);
}
// Now for the source server
SServ = CurrentConvertList->SourceServ;
LogWriteLog(0, TEXT("[%s]\r\n"), CurrentConvertList->SourceServ->Name);
LogWriteLog(1, Lids(IDS_L_134));
LogWriteLog(1, Lids(IDS_L_135), (UINT) SServ->VerMaj, (UINT) SServ->VerMin);
ShareListLog(SServ->ShareList, FALSE);
CurrentConvertList = CurrentConvertList->next;
}
} // ConvertListLog
/*+-------------------------------------------------------------------------+
| UserServerNameGet()
|
+-------------------------------------------------------------------------+*/
LPTSTR UserServerNameGet(DEST_SERVER_BUFFER *DServ, void *COpt) {
CONVERT_OPTIONS *ConvOpt;
LPTSTR ServName = NULL;
ConvOpt = (CONVERT_OPTIONS *) COpt;
// If going to a trusted domain then point to it's PDC for user transfers
if (ConvOpt->UseTrustedDomain && (ConvOpt->TrustedDomain != NULL) && (ConvOpt->TrustedDomain->PDCName != NULL)) {
ServName = ConvOpt->TrustedDomain->PDCName;
} else
// If in a domain then point to the PDC for user transfers
if (DServ->InDomain && DServ->Domain) {
ServName = DServ->Domain->PDCName;
} else {
ServName = DServ->Name;
}
return ServName;
} // UserServerNameGet
Reference in New Issue Copy Permalink