summaryrefslogtreecommitdiffstats
path: root/private/nw/convert/nwconv/map.c
diff options
context:
space:
mode:
Diffstat (limited to 'private/nw/convert/nwconv/map.c')
-rw-r--r--private/nw/convert/nwconv/map.c1682
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
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-29 19:55:41 +0200