|
|
/*
+-------------------------------------------------------------------------+ | 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
|
