mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1682 lines
48 KiB
1682 lines
48 KiB
/*
|
|
+-------------------------------------------------------------------------+
|
|
| 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
|
|
|
|
|