diff options
author | Adam <you@example.com> | 2020-05-17 05:51:50 +0200 |
---|---|---|
committer | Adam <you@example.com> | 2020-05-17 05:51:50 +0200 |
commit | e611b132f9b8abe35b362e5870b74bce94a1e58e (patch) | |
tree | a5781d2ec0e085eeca33cf350cf878f2efea6fe5 /private/nw/convert/nwconv/map.c | |
download | NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.gz NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.bz2 NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.lz NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.xz NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.zst NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.zip |
Diffstat (limited to '')
-rw-r--r-- | private/nw/convert/nwconv/map.c | 1682 |
1 files changed, 1682 insertions, 0 deletions
diff --git a/private/nw/convert/nwconv/map.c b/private/nw/convert/nwconv/map.c new file mode 100644 index 000000000..74530ca84 --- /dev/null +++ b/private/nw/convert/nwconv/map.c @@ -0,0 +1,1682 @@ +/* + +-------------------------------------------------------------------------+ + | User Options Dialog | + +-------------------------------------------------------------------------+ + | (c) Copyright 1993-1994 | + | Microsoft Corp. | + | All rights reserved | + | | + | Program : [MAP.c] | + | Programmer : Arthur Hanson | + | Original Program Date : [Sep 28, 1994] | + | Last Update : [Sep 28, 1994] | + | | + | Version: 1.00 | + | | + | Description: | + | | + | History: | + | arth Sep 28, 1994 1.00 Original Version. | + | | + +-------------------------------------------------------------------------+ +*/ + + +#include "globals.h" +#include "convapi.h" +#include "ntnetapi.h" +#include "nwnetapi.h" +#include "map.h" +#include "nwlog.h" +#include "nwconv.h" + +// from userdlg.c +DWORD UserFileGet(HWND hwnd, LPTSTR FilePath); + +// The map file is kept as a doubly-linked list of sections, each of which has +// a doubly-linked list of lines in that section. A header is used to point to +// the first section, and also contains a pointer to any lines that appear +// before the first section (usually only comment lines) - it also keeps the +// current line and section pointer. +// +// All the linked lists have a dummy header and tail, with the tail pointing +// back on itself (this simplifies the logic for list manipulation)... +// +// +-------------+ +----------------+ +// | Dummy | | Dummy | +// | head node v v tail node | +// | +-----------+ +-----------+ +-----------+ | +// | | Node 1 |-->| Node 2 |-->| Node 3 |----+ +// +--| (not used)|<--| (data) |<--| (not used)| +// +-----------+ +-----------+ +-----------+ +// +// The dummy head/tail nodes make it easy to keep track of the start and +// end of the list (we never have to worry about updating the head and tail +// pointers in the owning data structures, since they never change). It does, +// however, make for some obtuse cases in the add/delete node code. + +typedef struct _LINKED_LIST { + struct _LINKED_LIST *prev; + struct _LINKED_LIST *next; + +} LINKED_LIST; + +typedef struct _LINK_HEAD { + LINKED_LIST *Head; + LINKED_LIST *Tail; + + LINKED_LIST *Current; + ULONG Count; + + TCHAR Name[]; +} LINK_HEAD; + + +static TCHAR MappingFile[MAX_PATH + 1]; +static TCHAR PasswordConstant[MAX_PW_LEN + 1]; +static BOOL DoUsers = TRUE; +static BOOL DoGroups = TRUE; +static UINT PasswordOption = 0; +static LPTSTR SourceServ; + +/*+-------------------------------------------------------------------------+ + | Common Linked List Routines + +-------------------------------------------------------------------------+*/ + +/*+-------------------------------------------------------------------------+ + | ll_Init() + | + +-------------------------------------------------------------------------+*/ +LINKED_LIST *ll_Init(ULONG Size) { + LINKED_LIST *llHead; + LINKED_LIST *llTail; + + llHead = (LINKED_LIST *) AllocMemory(Size); + if (llHead == NULL) + return NULL; + + llTail = (LINKED_LIST *) AllocMemory(Size); + if (llTail == NULL) { + FreeMemory(llHead); + return NULL; + } + + llHead->prev = llHead; + llHead->next = llTail; + + llTail->next = llTail; + llTail->prev = llHead; + + return llHead; + +} // ll_Init + + +/*+-------------------------------------------------------------------------+ + | ll_Next() + | + +-------------------------------------------------------------------------+*/ +LINKED_LIST *ll_Next(void *vllCurrent) { + LINKED_LIST *llCurrent; + + llCurrent = (LINKED_LIST *) vllCurrent; + + if ((llCurrent == NULL) || (llCurrent->next == NULL) || (llCurrent->prev == NULL)) + return NULL; + + llCurrent = llCurrent->next; + + if (llCurrent->next == llCurrent) + return NULL; + else + return llCurrent; + +} // ll_Next + + +/*+-------------------------------------------------------------------------+ + | ll_Prev() + | + +-------------------------------------------------------------------------+*/ +LINKED_LIST *ll_Prev(void *vllCurrent) { + LINKED_LIST *llCurrent; + + llCurrent = (LINKED_LIST *) vllCurrent; + + if ((llCurrent == NULL) || (llCurrent->next == NULL) || (llCurrent->prev == NULL)) + return NULL; + + llCurrent = llCurrent->prev; + + if (llCurrent->prev == llCurrent) + return NULL; + else + return llCurrent; + +} // ll_Prev + + +/*+-------------------------------------------------------------------------+ + | ll_InsertAfter() + | + +-------------------------------------------------------------------------+*/ +LINKED_LIST *ll_InsertAfter(void *vllCurrent, void *vllNew) { + LINKED_LIST *llCurrent; + LINKED_LIST *llNew; + + llCurrent = (LINKED_LIST *) vllCurrent; + llNew = (LINKED_LIST *) vllNew; + + if ((vllCurrent == NULL) || (llNew == NULL)) + return NULL; + + // change pointers to insert it into the list + llNew->next = llCurrent->next; + + // check if at end of list + if (llCurrent->next == llCurrent) + llNew->prev = llCurrent->prev; + else + llNew->prev = llCurrent; + + llNew->prev->next = llNew; + llNew->next->prev = llNew; + return llNew; +} // ll_InsertAfter + + +/*+-------------------------------------------------------------------------+ + | ll_InsertBefore() + | + +-------------------------------------------------------------------------+*/ +LINKED_LIST *ll_InsertBefore(void *vllCurrent, void *vllNew) { + LINKED_LIST *llCurrent; + LINKED_LIST *llNew; + + llCurrent = (LINKED_LIST *) vllCurrent; + llNew = (LINKED_LIST *) vllNew; + + if ((vllCurrent == NULL) || (llNew == NULL)) + return NULL; + + // change pointers to insert it into the list + llNew->prev = llCurrent->prev; + + // check if at start of list + if (llCurrent->prev = llCurrent) + llNew->next = llCurrent->next; + else + llNew->next = llCurrent; + + llNew->prev->next = llNew; + llNew->next->prev = llNew; + return llNew; +} // ll_InsertBefore + + +/*+-------------------------------------------------------------------------+ + | ll_Delete() + | + +-------------------------------------------------------------------------+*/ +LINKED_LIST *ll_Delete(void *vllCurrent) { + LINKED_LIST *llCurrent; + + llCurrent = (LINKED_LIST *) vllCurrent; + + if ((llCurrent == NULL) || (llCurrent->next == NULL) || (llCurrent->prev == NULL)) + return NULL; + + // make sure not on one of the dummy end headers + if ((llCurrent->next == llCurrent) || (llCurrent->prev == llCurrent)) + return NULL; + + // changed pointers to remove it from list + llCurrent->prev->next = llCurrent->next; + llCurrent->next->prev = llCurrent->prev; + + // Get which one to return as new current record - we generally want to + // go to the previous record - unless we deleted the first record, in + // which case get the next record. If there are no records, then return + // the list head + llCurrent = llCurrent->prev; + + // check if at start of list + if (llCurrent->prev == llCurrent) + llCurrent = llCurrent->next; + + // make sure not at end of list (may have moved here if empty list) - if + // so we want to return the starting node + if (llCurrent->next == llCurrent) + llCurrent = llCurrent->prev; + + return llCurrent; +} // ll_Delete + + +/*+-------------------------------------------------------------------------+ + | ll_Home() + | + +-------------------------------------------------------------------------+*/ +LINKED_LIST *ll_Home(void *vllCurrent) { + LINKED_LIST *llCurrent; + + llCurrent = (LINKED_LIST *) vllCurrent; + if (llCurrent == NULL) + return (LINKED_LIST *) NULL; + + // make sure at start of list + while (llCurrent->prev != llCurrent) + llCurrent = llCurrent->prev; + + return llCurrent; + +} // ll_Home + + +/*+-------------------------------------------------------------------------+ + | ll_End() + | + +-------------------------------------------------------------------------+*/ +LINKED_LIST *ll_End(void *vllCurrent) { + LINKED_LIST *llCurrent; + + llCurrent = (LINKED_LIST *) vllCurrent; + if (llCurrent == NULL) + return (LINKED_LIST *) NULL; + + // make sure at end of list + while (llCurrent->next != llCurrent) + llCurrent = llCurrent->next; + + return llCurrent; + +} // ll_End + + +/*+-------------------------------------------------------------------------+ + | ll_ListFree() + | + +-------------------------------------------------------------------------+*/ +void ll_ListFree(void *vllHead) { + LINKED_LIST *llCurrent; + LINKED_LIST *llNext; + + llCurrent = (LINKED_LIST *) vllHead; + if (llCurrent == NULL) + return; + + // make sure at start of list + while (llCurrent->prev != llCurrent) + llCurrent = llCurrent->prev; + + // walk the chain - freeing it + while ((llCurrent != NULL) && (llCurrent->next != llCurrent)) { + llNext = llCurrent->next; + FreeMemory(llCurrent); + llCurrent = llNext; + } + + // at the ending node - kill it as well + FreeMemory(llCurrent); + +} // ll_ListFree + + + + +/*+-------------------------------------------------------------------------+ + | List Routines + +-------------------------------------------------------------------------+*/ + +/*+-------------------------------------------------------------------------+ + | map_LineListInit() + | + +-------------------------------------------------------------------------+*/ +MAP_LINE *map_LineListInit() { + MAP_LINE *NewHead; + MAP_LINE *NewTail; + + // Create our linked list + NewHead = (MAP_LINE *) ll_Init(sizeof(MAP_LINE)); + if (NewHead == NULL) + return (MAP_LINE *) NULL; + + NewTail = NewHead->next; + + // Now init them as appropriate + NewHead->Line = NULL; + NewTail->Line = NULL; + + return NewHead; + +} // map_LineListInit + + +/*+-------------------------------------------------------------------------+ + | map_SectionListInit() + | + +-------------------------------------------------------------------------+*/ +MAP_SECTION *map_SectionListInit() { + MAP_SECTION *NewHead; + MAP_SECTION *NewTail; + + // Create our linked list + NewHead = (MAP_SECTION *) ll_Init(sizeof(MAP_SECTION)); + if (NewHead == NULL) + return (MAP_SECTION *) NULL; + + NewTail = NewHead->next; + + // Now init them as appropriate + NewHead->Name = NULL; + NewTail->Name = NULL; + + NewHead->FirstLine = NewHead->LastLine = NewTail->FirstLine = NewTail->LastLine = NULL; + NewHead->LineCount = NewTail->LineCount = 0; + + return NewHead; + +} // map_SectionListInit + + +/*+-------------------------------------------------------------------------+ + | map_LineListFree() + | + +-------------------------------------------------------------------------+*/ +void map_LineListFree(MAP_LINE *CurrentLine) { + MAP_LINE *NextLine; + + if (CurrentLine == NULL) + return; + + // make sure at start of list + while (CurrentLine->prev != CurrentLine) + CurrentLine = CurrentLine->prev; + + // walk the chain - freeing it + while ((CurrentLine != NULL) && (CurrentLine->next != CurrentLine)) { + NextLine = CurrentLine->next; + + if (CurrentLine->Line != NULL) + FreeMemory(CurrentLine->Line); + + FreeMemory(CurrentLine); + CurrentLine = NextLine; + } + + // at the ending node - kill it as well + FreeMemory(CurrentLine); + +} // map_LineListFree + + +/*+-------------------------------------------------------------------------+ + | map_SectionListFree() + | + +-------------------------------------------------------------------------+*/ +void map_SectionListFree(MAP_SECTION *CurrentSection) { + MAP_SECTION *NextSection; + + if (CurrentSection == NULL) + return; + + // make sure at start of list + while (CurrentSection->prev != CurrentSection) + CurrentSection = CurrentSection->prev; + + // walk the chain - freeing it + while ((CurrentSection != NULL) && (CurrentSection->next != CurrentSection)) { + NextSection = CurrentSection->next; + + map_LineListFree(CurrentSection->FirstLine); + + if (CurrentSection->Name != NULL) + FreeMemory(CurrentSection->Name); + + FreeMemory(CurrentSection); + CurrentSection = NextSection; + } + + // at the ending node - kill it as well + FreeMemory(CurrentSection); + +} // map_SectionListFree + + + + +/*+-------------------------------------------------------------------------+ + | Section Routines + +-------------------------------------------------------------------------+*/ + +/*+-------------------------------------------------------------------------+ + | map_SectionInit() + | + +-------------------------------------------------------------------------+*/ +MAP_SECTION *map_SectionInit(LPTSTR Section) { + MAP_SECTION *NewSection; + MAP_LINE *FirstLine; + + NewSection = (MAP_SECTION *) AllocMemory(sizeof(MAP_SECTION)); + if (NewSection == NULL) + return (MAP_SECTION *) NULL; + + // Init the section name + NewSection->Name = (LPTSTR) AllocMemory((lstrlen(Section) + 1) * sizeof(TCHAR)); + + if (NewSection->Name == NULL) { + FreeMemory(NewSection); + return (MAP_SECTION *) NULL; + } + + // Now create the line list + FirstLine = map_LineListInit(); + if (FirstLine == NULL) { + FreeMemory(NewSection->Name); + FreeMemory(NewSection); + return (MAP_SECTION *) NULL; + } + + lstrcpy(NewSection->Name, Section); + NewSection->LineCount = 0; + NewSection->FirstLine = FirstLine; + NewSection->LastLine = FirstLine->next; + + return NewSection; +} // map_SectionInit + + +/*+-------------------------------------------------------------------------+ + | map_SectionAdd() + | + +-------------------------------------------------------------------------+*/ +void map_SectionAdd(MAP_FILE *hMap, LPTSTR Section) { + MAP_SECTION *NewSection; + + NewSection = map_SectionInit(Section); + if (NewSection == NULL) + return; + + // Add it to the section list + ll_InsertBefore((void *) hMap->LastSection, (void *) NewSection); + + // Init it so the added section is currently selected + hMap->CurrentSection = NewSection; + hMap->CurrentLine = hMap->CurrentSection->FirstLine; + +} // map_SectionAdd + + +/*+-------------------------------------------------------------------------+ + | map_SectionDelete() + | + +-------------------------------------------------------------------------+*/ +void map_SectionDelete(MAP_FILE *hMap) { + MAP_SECTION *CurrentSection; + MAP_SECTION *NewSection; + + // if no section is currently selected then get out + CurrentSection = hMap->CurrentSection; + if (CurrentSection == NULL) + return; + + // Remove this from the chain + NewSection = (MAP_SECTION *) ll_Delete((void *) CurrentSection); + + // walk the lines and remove them... + map_LineListFree(CurrentSection->FirstLine); + + // All lines have been removed, so remove section header itself + FreeMemory(CurrentSection->Name); + FreeMemory(CurrentSection); + + // Update Section count + if (hMap->SectionCount > 0) + hMap->SectionCount--; + +} // map_SectionDelete + + +/*+-------------------------------------------------------------------------+ + | map_SectionInsertBefore() + | + +-------------------------------------------------------------------------+*/ +void map_SectionInsertBefore(MAP_FILE *hMap, LPTSTR Section) { + MAP_SECTION *CurrentSection; + + if (hMap->CurrentSection == NULL) + return; + + CurrentSection = map_SectionInit(Section); + if (CurrentSection == NULL) + return; + + ll_InsertBefore((void *) hMap->CurrentSection, (void *) CurrentSection); + +} // map_SectionInsertBefore + + +/*+-------------------------------------------------------------------------+ + | map_SectionInsertAfter() + | + +-------------------------------------------------------------------------+*/ +void map_SectionInsertAfter(MAP_FILE *hMap, LPTSTR Section) { + MAP_SECTION *CurrentSection; + + if (hMap->CurrentSection == NULL) + return; + + CurrentSection = map_SectionInit(Section); + if (CurrentSection == NULL) + return; + + ll_InsertAfter((void *) hMap->CurrentSection, (void *) CurrentSection); + +} // map_SectionInsertAfter + + +/*+-------------------------------------------------------------------------+ + | map_SectionNext() + | + +-------------------------------------------------------------------------+*/ +MAP_SECTION *map_SectionNext(MAP_FILE *hMap) { + MAP_SECTION *CurrentSection; + + if (hMap->CurrentSection == NULL) + return NULL; + + CurrentSection = (MAP_SECTION *) ll_Next((void *) hMap->CurrentSection); + if (CurrentSection != NULL) + hMap->CurrentSection = CurrentSection; + + return CurrentSection; +} // map_SectionNext + + +/*+-------------------------------------------------------------------------+ + | map_SectionPrev() + | + +-------------------------------------------------------------------------+*/ +MAP_SECTION *map_SectionPrev(MAP_FILE *hMap) { + MAP_SECTION *CurrentSection; + + if (hMap->CurrentSection == NULL) + return NULL; + + CurrentSection = (MAP_SECTION *) ll_Prev((void *) hMap->CurrentSection); + + if (CurrentSection != NULL) + hMap->CurrentSection = CurrentSection; + + return CurrentSection; +} // map_SectionPrev + + +/*+-------------------------------------------------------------------------+ + | map_SectionFind() + | + +-------------------------------------------------------------------------+*/ +MAP_SECTION *map_SectionFind(MAP_FILE *hMap, LPTSTR Section) { + MAP_SECTION *CurrentSection; + + CurrentSection = hMap->FirstSection; + while (CurrentSection && lstrcmpi(CurrentSection->Name, Section)) + CurrentSection = (MAP_SECTION *) ll_Next((void *) CurrentSection); + + if (CurrentSection != NULL) { + hMap->CurrentSection = CurrentSection; + hMap->CurrentLine = hMap->CurrentSection->FirstLine; + } + + return CurrentSection; +} // map_SectionFind + + +/*+-------------------------------------------------------------------------+ + | map_SectionHome() + | + +-------------------------------------------------------------------------+*/ +void map_SectionHome(MAP_FILE *hMap) { + hMap->CurrentSection = hMap->FirstSection; + + hMap->CurrentLine = hMap->CurrentSection->FirstLine; +} // map_SectionHome + + +/*+-------------------------------------------------------------------------+ + | map_SectionEnd() + | + +-------------------------------------------------------------------------+*/ +void map_SectionEnd(MAP_FILE *hMap) { + MAP_SECTION *CurrentSection; + + CurrentSection = hMap->FirstSection; + while (CurrentSection && (CurrentSection->next != NULL)) + CurrentSection = CurrentSection->next; + + hMap->CurrentSection = CurrentSection; + hMap->CurrentLine = CurrentSection->FirstLine; +} // map_SectionEnd + + + + +/*+-------------------------------------------------------------------------+ + | Line Routines + +-------------------------------------------------------------------------+*/ + +/*+-------------------------------------------------------------------------+ + | map_LineInit() + | + +-------------------------------------------------------------------------+*/ +MAP_LINE *map_LineInit(LPTSTR Line) { + MAP_LINE *NewLine; + + NewLine = (MAP_LINE *) AllocMemory(sizeof(MAP_LINE)); + if (NewLine == NULL) + return (MAP_LINE *) NULL; + + NewLine->Line = (LPTSTR) AllocMemory((lstrlen(Line) + 1) * sizeof(TCHAR)); + + if (NewLine->Line == NULL) { + FreeMemory(NewLine); + return (MAP_LINE *) NULL; + } + + lstrcpy(NewLine->Line, Line); + return NewLine; + +} // map_LineInit + + +/*+-------------------------------------------------------------------------+ + | map_LineAdd() + | + +-------------------------------------------------------------------------+*/ +MAP_LINE *map_LineAdd(MAP_FILE *hMap, LPTSTR Line) { + MAP_LINE *NewLine; + + // make sure there is something to add it to + if ((hMap->CurrentSection == NULL) || (hMap->CurrentSection->LastLine == NULL)) + return (MAP_LINE *) NULL; + + // Create the new line + NewLine = map_LineInit(Line); + + if (NewLine->Line == NULL) + return (MAP_LINE *) NULL; + + // ...and add it to our list + ll_InsertBefore((void *) hMap->CurrentSection->LastLine, (void *) NewLine); + + // Init it so the added line is currently selected + hMap->CurrentLine = NewLine; + hMap->CurrentSection->LineCount++; + return NewLine; + +} // map_LineAdd + + +/*+-------------------------------------------------------------------------+ + | map_LineDelete() + | + +-------------------------------------------------------------------------+*/ +void map_LineDelete(MAP_FILE *hMap) { + MAP_LINE *CurrentLine; + MAP_LINE *NewLine; + + // if no section is currently selected then get out + if ((hMap->CurrentSection == NULL) || (hMap->CurrentLine == NULL)) + return; + + CurrentLine = hMap->CurrentLine; + NewLine = (MAP_LINE *) ll_Delete((void *) CurrentLine); + + // All lines have been removed, so remove section header itself + FreeMemory(CurrentLine->Line); + FreeMemory(CurrentLine); + + // update hMap + if (NewLine != NULL) + hMap->CurrentLine = NewLine; + else + hMap->CurrentLine = hMap->CurrentSection->FirstLine; + + if (hMap->CurrentSection->LineCount > 0) + hMap->CurrentSection->LineCount--; + +} // map_LineDelete + + +/*+-------------------------------------------------------------------------+ + | map_LineInsertBefore() + | + +-------------------------------------------------------------------------+*/ +void map_LineInsertBefore(MAP_FILE *hMap, LPTSTR Line) { + MAP_LINE *NewLine; + + if ((hMap->CurrentSection == NULL) || (hMap->CurrentLine == NULL)) + return; + + NewLine = map_LineInit(Line); + if (NewLine == NULL) + return; + + ll_InsertBefore((void *) hMap->CurrentLine, (void *) NewLine); +} // map_LineInsertBefore + + +/*+-------------------------------------------------------------------------+ + | map_LineInsertAfter() + | + +-------------------------------------------------------------------------+*/ +void map_LineInsertAfter(MAP_FILE *hMap, LPTSTR Line) { + MAP_LINE *NewLine; + + if ((hMap->CurrentSection == NULL) || (hMap->CurrentLine == NULL)) + return; + + NewLine = map_LineInit(Line); + if (NewLine == NULL) + return; + + ll_InsertAfter((void *) hMap->CurrentLine, (void *) NewLine); +} // map_LineInsertAfter + + +/*+-------------------------------------------------------------------------+ + | map_LineNext() + | + +-------------------------------------------------------------------------+*/ +MAP_LINE *map_LineNext(MAP_FILE *hMap) { + MAP_LINE *CurrentLine; + + if ((hMap->CurrentSection == NULL) || (hMap->CurrentLine == NULL)) + return NULL; + + CurrentLine = (MAP_LINE *) ll_Next((void *) hMap->CurrentLine); + if (CurrentLine != NULL) + hMap->CurrentLine = CurrentLine; + + return CurrentLine; +} // map_LineNext + + +/*+-------------------------------------------------------------------------+ + | map_LinePrev() + | + +-------------------------------------------------------------------------+*/ +MAP_LINE *map_LinePrev(MAP_FILE *hMap) { + MAP_LINE *CurrentLine; + + if ((hMap->CurrentSection == NULL) || (hMap->CurrentLine == NULL)) + return NULL; + + CurrentLine = (MAP_LINE *) ll_Prev((void *) hMap->CurrentLine); + if (CurrentLine != NULL) + hMap->CurrentLine = CurrentLine; + + return CurrentLine; +} // map_LinePrev + + +/*+-------------------------------------------------------------------------+ + | map_LineHome() + | + +-------------------------------------------------------------------------+*/ +void map_LineHome(MAP_FILE *hMap) { + + if ((hMap->CurrentSection == NULL) || (hMap->CurrentLine == NULL)) + return; + + hMap->CurrentLine = (MAP_LINE *) ll_Home((void *) hMap->CurrentLine); +} // map_LineHome + + +/*+-------------------------------------------------------------------------+ + | map_LineEnd() + | + +-------------------------------------------------------------------------+*/ +void map_LineEnd(MAP_FILE *hMap) { + if ((hMap->CurrentSection == NULL) || (hMap->CurrentLine == NULL)) + return; + + hMap->CurrentLine = (MAP_LINE *) ll_End((void *) hMap->CurrentLine); +} // map_LineEnd + + + + +/*+-------------------------------------------------------------------------+ + | Map File Routines + +-------------------------------------------------------------------------+*/ + +/*+-------------------------------------------------------------------------+ + | map_Home() + | + +-------------------------------------------------------------------------+*/ +void map_Home(MAP_FILE *hMap) { + hMap->CurrentSection = hMap->FirstSection; + +} // map_Home + + +/*+-------------------------------------------------------------------------+ + | map_End() + | + +-------------------------------------------------------------------------+*/ +void map_End(MAP_FILE *hMap) { + MAP_SECTION *CurrentSection; + MAP_LINE *CurrentLine = NULL; + + CurrentSection = hMap->FirstSection; + while (CurrentSection->next != NULL) + CurrentSection = CurrentSection->next; + + CurrentLine = CurrentSection->FirstLine; + + if (CurrentLine != NULL) + while (CurrentLine->next != NULL) + CurrentLine = CurrentLine->next; + + hMap->CurrentSection = CurrentSection; + hMap->CurrentLine = CurrentLine; +} // map_End + + +/*+-------------------------------------------------------------------------+ + | map_Open() + | + +-------------------------------------------------------------------------+*/ +MAP_FILE *map_Open(TCHAR *FileName) { + MAP_FILE *hMap = NULL; + HANDLE hFile = NULL; + char *FileCache = NULL; + char *chA; + char *pchA; + DWORD wrote; + char lpszA[MAX_LINE_LEN + 1]; + TCHAR lpsz[MAX_LINE_LEN + 1]; + TCHAR tmpStr[MAX_LINE_LEN + 1]; + char FileNameA[MAX_PATH + 1]; + ULONG Size; + TCHAR *ch; + TCHAR *pch; + TCHAR *lch; + DWORD FSize; + + MAP_SECTION *CurrentSection = NULL; + MAP_LINE *CurrentLine = NULL; + + WideCharToMultiByte(CP_ACP, 0, FileName, -1, FileNameA, sizeof(FileNameA), NULL, NULL); + + hFile = CreateFileA( FileNameA, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, NULL); + + if (hFile == (HANDLE) INVALID_HANDLE_VALUE) + return hMap; + + FSize = GetFileSize(hFile, NULL); + + FileCache = (char *) AllocMemory(FSize + 1); + if (FileCache == NULL) + goto map_OpenExit; + + hMap = (MAP_FILE *) AllocMemory(sizeof(MAP_FILE) + ((lstrlen(FileName) + 1) * sizeof(TCHAR))); + if (hMap == NULL) + goto map_OpenExit; + + // Init the section list + CurrentSection = map_SectionListInit(); + if (CurrentSection == NULL) { + FreeMemory(hMap); + hMap = NULL; + goto map_OpenExit; + } + + hMap->FirstSection = CurrentSection; + hMap->CurrentSection = CurrentSection; + hMap->LastSection = CurrentSection->next; + + // Init the header info + if (hMap != NULL) { + hMap->hf = hFile; + hMap->Modified = FALSE; + hMap->CurrentLine = NULL; + hMap->SectionCount = 0; + + lstrcpy(hMap->Name, FileName); + } + + memset(FileCache, 0, FSize + 1); + + // Read in the whole file then parse it - it shouldn't be that large, a + // very full NW server generated ~20K map file + if (!ReadFile(hFile, FileCache, FSize, &wrote, NULL)) + goto map_OpenExit; + + // Now walk and parse the buffer - remember it's in ASCII + chA = FileCache; + while (*chA) { + // Get past any white space junk at beginning of line + while(*chA && ((*chA == ' ') || (*chA == '\t'))) + chA++; + + // transfer a line of text + Size = 0; + pchA = lpszA; + while (*chA && (*chA != '\n') && (*chA != '\r') && (Size < MAX_LINE_LEN)) + *pchA++ = *chA++; + + *pchA = '\0'; + if (*chA == '\r') + chA++; + if (*chA == '\n') + chA++; + + // ...convert line to Unicode + MultiByteToWideChar(CP_ACP, 0, lpszA, -1, lpsz, sizeof(lpsz) ); + + // + // Now have a line of text - figure out what it is and update data + // structures + // + + // ...Check for section header + ch = lpsz; + lch = pch = tmpStr; + if (*ch == TEXT(SECTION_BEGIN_CHAR)) { + // Find end section brace - keeping track of last non-white space char + // anything after end-section-brace is discarded. Any trailing/ + // leading whitespace in section header is removed + ch++; // get past section-begin + + // remove any leading whitespace + while(*ch && ((*ch == TEXT(' ')) || (*ch == TEXT('\t')))) + ch++; + + // transfer it to tmpStr (via pch pointer) + while (*ch && (*ch != TEXT(SECTION_END_CHAR))) { + // keep track of last non-whitespace + if ((*ch != TEXT(' ')) && (*ch != TEXT('\t'))) { + lch = pch; + lch++; + } + + *pch++ = *ch++; + } + + // NULL terminate before last section of whitespace + *lch = TEXT('\0'); + + // Allocate a new section-header block and init + map_SectionAdd(hMap, tmpStr); + } else { + // Not section header, so normal line - copy to tmpStr via pch pointer + while (*ch) { + // keep track of last non-whitespace + if ((*ch != TEXT(' ')) && (*ch != TEXT('\t'))) { + lch = pch; + lch++; + } + + *pch++ = *ch++; + } + + // NULL terminate before last section of whitespace + *lch = TEXT('\0'); + + // ...add it to the list + map_LineAdd(hMap, tmpStr); + } + + // Done with the line of text, so just loop back up to parse next + // line + } + +map_OpenExit: + + FreeMemory(FileCache); + return hMap; + +} // map_Open + + +/*+-------------------------------------------------------------------------+ + | map_Close() + | + +-------------------------------------------------------------------------+*/ +void map_Close(MAP_FILE *hMap) { + // If file modified then re-write file. + if ( hMap->Modified ) + ; + + // Write out cache of file, close it and clean up all the data structures + CloseHandle( hMap->hf ); + hMap = NULL; +} // map_Close + + +/*+-------------------------------------------------------------------------+ + | ParseWord() + | + +-------------------------------------------------------------------------+*/ +void ParseWord(TCHAR **lpch, LPTSTR tmpStr) { + TCHAR *ch; + TCHAR *lch; + TCHAR *pch; + + ch = *lpch; + lch = pch = tmpStr; + + // remove any leading whitespace + while(*ch && ((*ch == TEXT(' ')) || (*ch == TEXT('\t')))) + ch++; + + // transfer it to tmpStr (via pch pointer) + while (*ch && (*ch != TEXT(WORD_DELIMITER))) { + // keep track of last non-whitespace + if ((*ch != TEXT(' ')) && (*ch != TEXT('\t'))) { + lch = pch; + lch++; + } + + *pch++ = *ch++; + } + + if (*ch == TEXT(WORD_DELIMITER)) + ch++; + + // NULL terminate before last section of whitespace + *lch = TEXT('\0'); + *lpch = ch; + +} // ParseWord + + +/*+-------------------------------------------------------------------------+ + | map_ParseUser() + | + +-------------------------------------------------------------------------+*/ +void map_ParseUser(LPTSTR Line, LPTSTR Name, LPTSTR NewName, LPTSTR Password) { + TCHAR *pch = Line; + + lstrcpy(Name, TEXT("")); + lstrcpy(NewName, TEXT("")); + lstrcpy(Password, TEXT("")); + + if (Line == NULL) + return; + + ParseWord(&pch, Name); + if (lstrlen(Name) >= MAX_USER_NAME_LEN) + lstrcpy(Name, TEXT("")); + + ParseWord(&pch, NewName); + if (lstrlen(NewName) >= MAX_USER_NAME_LEN) + lstrcpy(NewName, TEXT("")); + + ParseWord(&pch, Password); + if (lstrlen(Password) > MAX_PW_LEN) + lstrcpy(Password, TEXT("")); + +} // map_ParseUser + + +/*+-------------------------------------------------------------------------+ + | map_ParseGroup() + | + +-------------------------------------------------------------------------+*/ +void map_ParseGroup(LPTSTR Line, LPTSTR Name, LPTSTR NewName) { + TCHAR *pch = Line; + + lstrcpy(Name, TEXT("")); + lstrcpy(NewName, TEXT("")); + + if (Line == NULL) + return; + + ParseWord(&pch, Name); + if (lstrlen(Name) >= MAX_GROUP_NAME_LEN) + lstrcpy(Name, TEXT("")); + + ParseWord(&pch, NewName); + if (lstrlen(NewName) >= MAX_GROUP_NAME_LEN) + lstrcpy(NewName, TEXT("")); + +} // map_ParseGroup + + +/*+-------------------------------------------------------------------------+ + | map_UsersEnum() + | + +-------------------------------------------------------------------------+*/ +DWORD map_UsersEnum(MAP_FILE *hMap, USER_LIST **lpUsers) { + DWORD ret = 0; + USER_LIST *UserList = NULL; + USER_BUFFER *UserBuffer = NULL; + MAP_SECTION *CurrentSection = NULL; + MAP_LINE *CurrentLine = NULL; + ULONG Entries = 0; + ULONG ActualEntries = 0; + TCHAR Name[MAX_LINE_LEN + 1]; + TCHAR NewName[MAX_LINE_LEN + 1]; + TCHAR Password[MAX_LINE_LEN + 1]; + ULONG i; + + CurrentSection = map_SectionFind(hMap, Lids(IDS_M_7)); + if (CurrentSection != NULL) + Entries = CurrentSection->LineCount; + + UserList = AllocMemory(sizeof(USER_LIST) + (sizeof(USER_BUFFER) * Entries)); + + if (!UserList) { + ret = ERROR_NOT_ENOUGH_MEMORY; + } else { + UserBuffer = UserList->UserBuffer; + + for (i = 0; i < Entries; i++) { + CurrentLine = map_LineNext(hMap); + + if (CurrentLine != NULL) { + map_ParseUser(CurrentLine->Line, Name, NewName, Password); + + if (lstrlen(Name)) { + lstrcpy(UserBuffer[ActualEntries].Name, Name); + lstrcpy(UserBuffer[ActualEntries].NewName, NewName); + lstrcpy(UserBuffer[ActualEntries].Password, Password); + + if (lstrcmpi(Name, NewName)) + UserBuffer[ActualEntries].IsNewName = TRUE; + + ActualEntries++; + } + } + } + + if (ActualEntries != Entries) + UserList = (USER_LIST *) ReallocMemory((HGLOBAL) UserList, sizeof(USER_LIST) + (sizeof(USER_BUFFER)* ActualEntries)); + + if (UserList == NULL) + ret = ERROR_NOT_ENOUGH_MEMORY; + else { + // Sort the server list before putting it in the dialog + UserBuffer = UserList->UserBuffer; + qsort((void *) UserBuffer, (size_t) ActualEntries, sizeof(USER_BUFFER), UserListCompare); + UserList->Count = ActualEntries; + } + + *lpUsers = UserList; + } + + return ret; +} // map_UsersEnum + + +/*+-------------------------------------------------------------------------+ + | map_GroupsEnum() + | + +-------------------------------------------------------------------------+*/ +DWORD map_GroupsEnum(MAP_FILE *hMap, GROUP_LIST **lpGroups) { + DWORD ret = 0; + GROUP_LIST *GroupList = NULL; + GROUP_BUFFER *GroupBuffer = NULL; + MAP_SECTION *CurrentSection = NULL; + MAP_LINE *CurrentLine = NULL; + ULONG Entries = 0; + ULONG ActualEntries = 0; + TCHAR Name[MAX_LINE_LEN + 1]; + TCHAR NewName[MAX_LINE_LEN + 1]; + ULONG i; + + + CurrentSection = map_SectionFind(hMap, Lids(IDS_M_8)); + if (CurrentSection != NULL) + Entries = CurrentSection->LineCount; + + GroupList = AllocMemory(sizeof(GROUP_LIST) + (sizeof(GROUP_BUFFER) * Entries)); + + if (!GroupList) { + ret = ERROR_NOT_ENOUGH_MEMORY; + } else { + GroupBuffer = GroupList->GroupBuffer; + + for (i = 0; i < Entries; i++) { + CurrentLine = map_LineNext(hMap); + + if (CurrentLine != NULL) { + map_ParseGroup(CurrentLine->Line, Name, NewName); + + if (lstrlen(Name)) { + lstrcpy(GroupBuffer[ActualEntries].Name, Name); + lstrcpy(GroupBuffer[ActualEntries].NewName, NewName); + + if (lstrcmpi(Name, NewName)) + GroupBuffer[ActualEntries].IsNewName = TRUE; + + ActualEntries++; + } + } + } + + if (ActualEntries != Entries) + GroupList = (GROUP_LIST *) ReallocMemory((HGLOBAL) GroupList, sizeof(GROUP_LIST) + (sizeof(GROUP_BUFFER)* ActualEntries)); + + if (GroupList == NULL) + ret = ERROR_NOT_ENOUGH_MEMORY; + else + GroupList->Count = ActualEntries; + + *lpGroups = GroupList; + } + + return ret; +} // map_GroupsEnum + + +/*+-------------------------------------------------------------------------+ + | MapFileWrite() + | + +-------------------------------------------------------------------------+*/ +BOOL MapFileWrite(HANDLE hFile, LPTSTR String) { + DWORD wrote; + static char tmpStr[MAX_LINE_LEN + 1]; + + WideCharToMultiByte(CP_ACP, 0, String, -1, tmpStr, sizeof(tmpStr), NULL, NULL); + + if (!WriteFile(hFile, tmpStr, strlen(tmpStr), &wrote, NULL)) + return FALSE; + + return TRUE; +} // MapFileWrite + + +/*+-------------------------------------------------------------------------+ + | MapFileOpen() + | + +-------------------------------------------------------------------------+*/ +HANDLE MapFileOpen(LPTSTR FileNameW) { + int ret; + HANDLE hFile = NULL; + char FileName[MAX_PATH + 1]; + + WideCharToMultiByte(CP_ACP, 0, FileNameW, -1, FileName, sizeof(FileName), NULL, NULL); + + DeleteFile(FileNameW); + + // Now do the actual creation with error handling... + do { + ret = IDOK; + hFile = CreateFileA( FileName, GENERIC_WRITE, 0, NULL, CREATE_NEW, + FILE_ATTRIBUTE_NORMAL, NULL ); + + if (hFile == INVALID_HANDLE_VALUE) + ret = ErrorBoxRetry(Lids(IDS_MAPCREATEFAIL)); + + } while(ret == IDRETRY); + + return(hFile); + +} // MapFileOpen + + + +/*+-------------------------------------------------------------------------+ + | MappingFileCreate() + | + | Creates a mapping file. This allows the admin to specify for each + | user a new username and password. + | + +-------------------------------------------------------------------------+*/ +BOOL MappingFileCreate(LPTSTR FileName, LPTSTR Server) { + BOOL status = FALSE; + DWORD ret = 0; + USER_LIST *Users; + DWORD UserCount; + GROUP_LIST *Groups; + GROUP_BUFFER *GroupBuffer; + USER_BUFFER *UserBuffer; + DWORD GroupCount; + int Count; + HANDLE hFile = NULL; + static TCHAR tmpStr[MAX_LINE_LEN + 1]; + static TCHAR tmpStr2[MAX_LINE_LEN + 1]; + + // Create Empty map file + hFile = MapFileOpen(FileName); + if (hFile == INVALID_HANDLE_VALUE) + return FALSE; + + CursorHourGlass(); + + // Now write out header gunk + status = MapFileWrite(hFile, Lids(IDS_LINE)); + wsprintf(tmpStr, Lids(IDS_M_1), Server); + wsprintf(tmpStr2, Lids(IDS_BRACE), tmpStr); + if (status) + status = MapFileWrite(hFile, tmpStr2); + + wsprintf(tmpStr, Lids(IDS_BRACE), Lids(IDS_M_2)); + if (status) + status = MapFileWrite(hFile, tmpStr); + + wsprintf(tmpStr, Lids(IDS_BRACE), TEXT("")); + if (status) + status = MapFileWrite(hFile, tmpStr); + + wsprintf(tmpStr, Lids(IDS_BRACE), Lids(IDS_M_3)); + if (status) + status = MapFileWrite(hFile, tmpStr); + + wsprintf(tmpStr, Lids(IDS_BRACE), Lids(IDS_M_4)); + if (status) + status = MapFileWrite(hFile, tmpStr); + + wsprintf(tmpStr, Lids(IDS_BRACE), TEXT("")); + if (status) + status = MapFileWrite(hFile, tmpStr); + + if (status) + status = MapFileWrite(hFile, Lids(IDS_LINE)); + + // [USERS] section header + if (DoUsers && status) + status = MapFileWrite(hFile, Lids(IDS_M_5)); + + // If anything went wrong with writing header, get out + if (!status) { + CursorNormal(); + return FALSE; + } + + // Header is all done - now lets do the actual users and such + if (!(ret = NWServerSet(Server))) { + // + // If users were selected then put them into the map file + // + if (DoUsers) { + if (!NWUsersEnum(&Users, FALSE) && (Users != NULL)) { + UserCount = Users->Count; + UserBuffer = Users->UserBuffer; + + for (Count = 0; Count < (int) UserCount; Count++) { + if (status) { + switch(PasswordOption) { + case 0: // No password + wsprintf(tmpStr, TEXT("%s, %s,\r\n"), UserBuffer[Count].Name, UserBuffer[Count].Name); + break; + + case 1: // Password is username + wsprintf(tmpStr, TEXT("%s, %s, %s\r\n"), UserBuffer[Count].Name, UserBuffer[Count].Name, UserBuffer[Count].Name); + break; + + case 2: // Password is constant + wsprintf(tmpStr, TEXT("%s, %s, %s\r\n"), UserBuffer[Count].Name, UserBuffer[Count].Name, PasswordConstant); + break; + } + status = MapFileWrite(hFile, tmpStr); + } + } + + FreeMemory((LPBYTE) Users); + } + } + + // + // If groups were selected then put them in map file + // + if (DoGroups) { + // [GROUPS] section header + if (status) + status = MapFileWrite(hFile, Lids(IDS_M_6)); + + if (!NWGroupsEnum(&Groups, FALSE) && (Groups != NULL)) { + GroupCount = Groups->Count; + GroupBuffer = Groups->GroupBuffer; + + for (Count = 0; Count < (int) GroupCount; Count++) { + if (status) { + wsprintf(tmpStr, TEXT("%s, %s\r\n"), GroupBuffer[Count].Name, GroupBuffer[Count].Name); + status = MapFileWrite(hFile, tmpStr); + } + } + + FreeMemory((LPBYTE) Groups); + } + + } + + NWServerFree(); + } + + CloseHandle( hFile ); + CursorNormal(); + return status; + +} // MappingFileCreate + + +/*+-------------------------------------------------------------------------+ + | MappingFileNameResolve() + | + +-------------------------------------------------------------------------+*/ +BOOL MappingFileNameResolve(HWND hDlg) { + HWND hCtrl; + static char FileNameA[MAX_PATH + 1]; + static char CmdLine[MAX_PATH + 1 + 12]; // Editor + file + TCHAR drive[MAX_DRIVE + 1]; + TCHAR dir[MAX_PATH + 1]; + TCHAR fname[MAX_PATH + 1]; + TCHAR ext[_MAX_EXT + 1]; + UINT uReturn; + BOOL ret = TRUE; + + // First check filename + hCtrl = GetDlgItem(hDlg, IDC_MAPPINGFILE); + * (WORD *)MappingFile = sizeof(MappingFile); + SendMessage(hCtrl, EM_GETLINE, 0, (LPARAM) MappingFile); + lsplitpath(MappingFile, drive, dir, fname, ext); + + // remake path so it is fully qualified + if ((drive[0] == TEXT('\0')) && (dir[0] == TEXT('\0'))) + lstrcpy(dir, ProgPath); + + if (ext[0] == TEXT('\0')) + lstrcpy(ext, Lids(IDS_S_36)); + + lmakepath(MappingFile, drive, dir, fname, ext); + + if (MappingFileCreate(MappingFile, SourceServ)) { + if (MessageBox(hDlg, Lids(IDS_MAPCREATED), Lids(IDS_APPNAME), MB_YESNO | MB_ICONQUESTION) == IDYES) { + + WideCharToMultiByte(CP_ACP, 0, MappingFile, -1, FileNameA, sizeof(FileNameA), NULL, NULL); + + wsprintfA(CmdLine, "Notepad %s", FileNameA); + uReturn = WinExec(CmdLine, SW_SHOW); + } + } else { + MessageBox(hDlg, Lids(IDS_MAPCREATEFAIL), Lids(IDS_TXTWARNING), MB_OK); + ret = FALSE; + } + + return ret; + +} // MappingFileNameResolve + + +/*+-------------------------------------------------------------------------+ + | MapCreate() + | + +-------------------------------------------------------------------------+*/ +LRESULT CALLBACK MapCreateProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { + HWND hCtrl; + int wmId, wmEvent; + static short UserNameTab, GroupNameTab, PasswordsTab, DefaultsTab; + + switch (message) { + + case WM_INITDIALOG: + // Center the dialog over the application window + CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER)); + + // limit edit field lengths + hCtrl = GetDlgItem(hDlg, IDC_MAPPINGFILE); + PostMessage(hCtrl, EM_LIMITTEXT, (WPARAM) MAX_PATH, 0); + hCtrl = GetDlgItem(hDlg, IDC_PWCONST); + PostMessage(hCtrl, EM_LIMITTEXT, (WPARAM) MAX_PW_LEN, 0); + + // set mapping file name and init OK button appropriatly + hCtrl = GetDlgItem(hDlg, IDC_MAPPINGFILE); + SendMessage(hCtrl, WM_SETTEXT, 0, (LPARAM) MappingFile); + hCtrl = GetDlgItem(hDlg, IDC_MAPPINGFILE); + + if (SendMessage(hCtrl, EM_LINELENGTH, 0, 0)) { + hCtrl = GetDlgItem(hDlg, IDOK); + EnableWindow(hCtrl, TRUE); + } else { + hCtrl = GetDlgItem(hDlg, IDOK); + EnableWindow(hCtrl, FALSE); + } + + // check Users and Groups checkbox's + hCtrl = GetDlgItem(hDlg, IDC_USERS); + SendMessage(hCtrl, BM_SETCHECK, 1, 0); + hCtrl = GetDlgItem(hDlg, IDC_GROUPS); + SendMessage(hCtrl, BM_SETCHECK, 1, 0); + CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO3, IDC_RADIO1); + return (TRUE); + + case WM_COMMAND: + wmId = LOWORD(wParam); + wmEvent = HIWORD(wParam); + + switch (wmId) { + // [OK] button + case IDOK: + // Figure out what password option is checked... + hCtrl = GetDlgItem(hDlg, IDC_RADIO1); + if (SendMessage(hCtrl, BM_GETCHECK, 0, 0) == 1) + PasswordOption = 0; + + hCtrl = GetDlgItem(hDlg, IDC_RADIO2); + if (SendMessage(hCtrl, BM_GETCHECK, 0, 0) == 1) + PasswordOption = 1; + + hCtrl = GetDlgItem(hDlg, IDC_RADIO3); + if (SendMessage(hCtrl, BM_GETCHECK, 0, 0) == 1) + PasswordOption = 2; + + hCtrl = GetDlgItem(hDlg, IDC_PWCONST); + * (WORD *)PasswordConstant = sizeof(PasswordConstant); + SendMessage(hCtrl, EM_GETLINE, 0, (LPARAM) PasswordConstant); + + EnableWindow(hDlg, FALSE); + MappingFileNameResolve(hDlg); + EnableWindow(hDlg, TRUE); + EndDialog(hDlg, 0); + return (TRUE); + break; + + // [CANCEL] button + case IDCANCEL: + EndDialog(hDlg, 0); + return (TRUE); + break; + + // [HELP] button + case IDHELP: + WinHelp(hDlg, HELP_FILE, HELP_CONTEXT, (DWORD) IDC_HELP_CMAP); + return (TRUE); + break; + + // Checkbox for Users + case IDC_USERS: + DoUsers = !DoUsers; + + hCtrl = GetDlgItem(hDlg, IDC_RADIO1); + EnableWindow(hCtrl, DoUsers); + hCtrl = GetDlgItem(hDlg, IDC_RADIO2); + EnableWindow(hCtrl, DoUsers); + hCtrl = GetDlgItem(hDlg, IDC_RADIO3); + EnableWindow(hCtrl, DoUsers); + hCtrl = GetDlgItem(hDlg, IDC_PWCONST); + EnableWindow(hCtrl, DoUsers); + + return (TRUE); + break; + + // Checkbox for Groups + case IDC_GROUPS: + DoGroups = !DoGroups; + return (TRUE); + break; + + // Edit field for password constant + case IDC_PWCONST: + + if (wmEvent == EN_CHANGE) + CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO3, IDC_RADIO3); + + break; + + // Edit field for password constant + case IDC_MAPPINGFILE: + if (wmEvent == EN_CHANGE) { + hCtrl = GetDlgItem(hDlg, IDC_MAPPINGFILE); + + if (SendMessage(hCtrl, EM_LINELENGTH, 0, 0)) { + hCtrl = GetDlgItem(hDlg, IDOK); + EnableWindow(hCtrl, TRUE); + } else { + hCtrl = GetDlgItem(hDlg, IDOK); + EnableWindow(hCtrl, FALSE); + } + + } + break; + + // [...] button for mapping file + case IDC_BTNMAPPINGFILE: + // Let the user browse for a file + if (!UserFileGet(hDlg, MappingFile)) { + hCtrl = GetDlgItem(hDlg, IDC_MAPPINGFILE); + SendMessage(hCtrl, WM_SETTEXT, 0, (LPARAM) MappingFile); + SetFocus(hCtrl); + } + return (TRUE); + break; + + } + break; + } + + return (FALSE); // Didn't process the message + + lParam; +} // MapCreateProc + + + +/*+-------------------------------------------------------------------------+ + | MapFileCreate() + | + +-------------------------------------------------------------------------+*/ +BOOL MapFileCreate(HWND hDlg, LPTSTR FileName, LPTSTR Server) { + DLGPROC lpfnDlg; + + DoUsers = TRUE; + DoGroups = TRUE; + PasswordOption = 0; + lstrcpy(MappingFile, FileName); + lstrcpy(PasswordConstant, TEXT("")); + SourceServ = Server; + + lpfnDlg = MakeProcInstance((DLGPROC)MapCreateProc, hInst); + DialogBox(hInst, TEXT("MAPCreate"), hDlg, lpfnDlg) ; + FreeProcInstance(lpfnDlg); + + lstrcpy(FileName, MappingFile); + return TRUE; +} // MapFileCreate + + |