/*++

    Copyright (c) 1994  Microsoft Corporation

Module Name:

    FindClnt.C

Abstract:

    Displays the Searching for clients dialog box and looks for the selected
    client distribution tree returning the path and type of path found.

Author:

    Bob Watson (a-robw)

Revision History:

    24 Jun 94    Written

--*/
//
//  Windows Include Files
//

#include <windows.h>
#include <stdio.h>
#include <malloc.h>
#include <tchar.h>      // unicode macros
#include <lmcons.h>     // lanman API constants
#include <lmerr.h>      // lanman error returns
#include <lmshare.h>    // sharing API prototypes
#include <lmapibuf.h>   // lanman buffer API prototypes
//
//  app include files
//
#include "otnboot.h"
#include "otnbtdlg.h"
//
// local dialog box messages
//
#define     NCDU_SEARCH_FOR_CLIENTS       (WM_USER+101)
//
//      Search Phases
#define     SEARCH_REGISTRY         (0x00000001)
#define     SEARCH_SHARED_DIRS      (0x00000002)
#define     SEARCH_HARD_DRIVES      (0x00000004)
#define     SEARCH_CD_ROM           (0x00000008)
#define     SEARCH_LAST_PHASE       SEARCH_CD_ROM
//
//  module static variables
//
static BOOL     bSearchForClients;  // flag to trip out of search
static HCURSOR  hOrigCursor = NULL; // cursor to save/restore

LONG
GetDistributionPath (
    IN  HWND        hwndDlg,        // handle to dialog box window
    IN  DWORD       dwSearchType,   // type of dir to find: Client/tools
    IN  OUT LPTSTR  szPath,         // buffer to return path in (Req'd)
    IN  DWORD       dwPathLen,      // size of path buffer in chars
    IN  PLONG       plPathType      // pointer to buffer recieving path type (opt)
)
/*++

Routine Description:

    Gets the default distribution file path for loading the dialog box
        entries with.

Arguments:

    IN  HWND        hwndDlg
        handle to parent dialog box window
    IN  DWORD       dwSearchType
        type of dir to find: Client/tools
    IN  OUT LPTSTR  szPath
        buffer to return path in (Req'd)
    IN  DWORD       dwPathLen
        size of path buffer in chars
    IN  PLONG       plPathType
        pointer to buffer recieving path type (opt)

Return Value:

    ERROR_SUCCESS if file found
    ERROR_FILE_NOT_FOUND if unable to find file

--*/
{
    FDT_DATA    Fdt;
    UINT        nDBReturn;

    // build data structure for search

    Fdt.szPathBuffer = szPath;
    Fdt.dwPathBufferLen = dwPathLen;
    Fdt.plPathType = plPathType;
    Fdt.dwSearchType = dwSearchType;

    nDBReturn = (UINT)DialogBoxParam (
        (HINSTANCE)GetWindowLongPtr(hwndDlg, GWLP_HINSTANCE),
        MAKEINTRESOURCE(NCDU_FINDING_CLIENT_DIRS_DLG),
        hwndDlg,
        FindClientsDlgProc,
        (LPARAM)&Fdt);

    if (nDBReturn == IDOK) {
        return ERROR_SUCCESS;
    } else {
        return ERROR_FILE_NOT_FOUND;
    }
}

static
LPCTSTR
GetLastPathFromRegistry (
    IN  DWORD   dwSearchType
)
/*++

Routine Description:

    looks up the last path (server\share) for either the tools directory
        or the client tree as it appears in the registry. If unable to
        find both components of the selected search, then an empty string
        is returned.

Arguments:

    IN  DWORD   dwSearchType
        FDT_TOOLS_TREE  for server tools path
        FDT_CLIENT_TREE for client distribution path

Return Value:

    pointer to a read only string that contains the desired path if
        one was stored in the registry or an empty string if not.

--*/
{
    static  TCHAR    szLastPath[MAX_PATH];
    HKEY    hkeyUserInfo;
    HKEY    hkeyAppInfo;

    LONG    lStatus;
    DWORD   dwBufLen;

    // open registry key containing net apps

    lStatus = RegOpenKeyEx (
        HKEY_CURRENT_USER,
        cszUserInfoKey,
        0L,
        KEY_READ,
        &hkeyUserInfo);

    if (lStatus != ERROR_SUCCESS) {
        // unable to open key so return an empty buffer
        szLastPath[0] = 0;
    } else {
        // open registry key containing this app's info
        lStatus = RegOpenKeyEx (
            hkeyUserInfo,
            szAppName,
            0L,
            KEY_READ,
            &hkeyAppInfo);

        if (lStatus != ERROR_SUCCESS) {
            // unable to open key so return an empty buffer
            szLastPath[0] = 0;
        } else {
            // initialize path variable
            lstrcpy (szLastPath, cszDoubleBackslash);

            // get server name from registry
            dwBufLen = MAX_COMPUTERNAME_LENGTH + 1;
            lStatus = RegQueryValueEx (
                hkeyAppInfo,
                (LPTSTR)(dwSearchType == FDT_TOOLS_TREE ? cszLastToolsServer : cszLastClientServer),
                (LPDWORD)NULL,
                (LPDWORD)NULL,
                (LPBYTE)&szLastPath[lstrlen(szLastPath)],
                &dwBufLen);

            if (lStatus != ERROR_SUCCESS) {
                // unable to read value so return an empty buffer
                szLastPath[0] = 0;
            } else {
                // get sharepoint name from registry
                lstrcat (szLastPath, cszBackslash);
                dwBufLen = MAX_SHARENAME + 1;
                lStatus = RegQueryValueEx (
                    hkeyAppInfo,
                    (LPTSTR)(dwSearchType == FDT_TOOLS_TREE ? cszLastToolsSharepoint : cszLastClientSharepoint),
                    (LPDWORD)NULL,
                    (LPDWORD)NULL,
                    (LPBYTE)&szLastPath[lstrlen(szLastPath)],
                    &dwBufLen);

                if (lStatus != ERROR_SUCCESS) {
                    // unable to read value so return an empty buffer
                    szLastPath[0] = 0;
                }
            }
            RegCloseKey (hkeyAppInfo);
        }
        RegCloseKey (hkeyUserInfo);
    }

    return (LPCTSTR)&szLastPath[0];
}

static
LONG
SearchForDistPath (
    IN  OUT LPTSTR  szPath,         // buffer to return path in (Req'd)
    IN  DWORD       dwPathLen,      // size of path buffer in chars
    IN  PLONG       plPathType,     // pointer to buffer recieving path type (opt)
    IN  DWORD       dwSearchType,   // type of tree to look for
    IN  DWORD       dwPhase         // phase(s) to search
)
/*++

Routine Description:

    function that looks for the desired directory tree in the following
        locations:
            a) the registry, for the stored server\share
            b) the shared directories on the system
            c) the local and redirected drives
            d) the CD-Rom

        The search is divided into phases to allow the user to cancel the
        search.

Arguments:

    IN  OUT LPTSTR  szPath,         // buffer to return path in (Req'd)
    IN  DWORD       dwPathLen,      // size of path buffer in chars
    IN  PLONG       plPathType,     // pointer to buffer recieving path type (opt)
    IN  DWORD       dwSearchType,   // type of tree to look for
    IN  DWORD       dwPhase         // phase(s) to search

Return Value:

    ERROR_SUCCESS

--*/
{
    LONG    lStatus = ERROR_SUCCESS;
    LONG    lPathType = NCDU_NO_CLIENT_PATH_FOUND;
    LPTSTR  szLocalPath = NULL;
    NET_API_STATUS  naStatus = NERR_Success;
    DWORD   dwTotalEntries;
    DWORD   dwEntriesRead;
    DWORD   dwEntriesProcessed;
    DWORD   dwResumeHandle;
    DWORD   dwIndex;
    DWORD   dwBufLen;
    BOOL    bFound;
    UINT    nDriveType;
    TCHAR   szRootDir[32];
    PSHARE_INFO_2    psi2Data;
    UINT    nErrorMode;
    BOOL    bValidPath;

    if (szPath == NULL) {
        // the pointer to the path is required
        return ERROR_INVALID_PARAMETER;
    }

    // allocate temp buffers

    szLocalPath = GlobalAlloc (GPTR, MAX_PATH_BYTES);

    if (szLocalPath == NULL) {
        return ERROR_OUTOFMEMORY;
    }

    // disable windows error message popup
    nErrorMode = SetErrorMode  (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);

    bFound = FALSE;

    if ((dwPhase & SEARCH_REGISTRY) == SEARCH_REGISTRY) {
        // check registry for saved server/sharepoint

        // if server/share found in registry, make into a UNC path
        //  and validate that it's really a client tree. return path if valid

        lstrcpy (szLocalPath, GetLastPathFromRegistry(dwSearchType));
        if (szLocalPath[lstrlen(szLocalPath)] != cBackslash) lstrcat (szLocalPath, cszBackslash);
        if (dwSearchType == FDT_TOOLS_TREE){
            bValidPath = (BOOL)(ValidSrvToolsPath (szLocalPath) == 0);
        } else {
            bValidPath = (BOOL)(ValidSharePath (szLocalPath) == 0);
         }
        if (bValidPath) {
            // it's there so save it in user's buffer and leave
            lstrcpy (szPath, szLocalPath);
            lPathType = NCDU_PATH_FROM_REGISTRY;
            lStatus = ERROR_SUCCESS;
            goto GDP_ExitPoint;
        }
    }

    if ((dwPhase & SEARCH_SHARED_DIRS) == SEARCH_SHARED_DIRS)  {
        // if here, then no valid server/share was found in registry, so
        // look at shared dir's on this machine and see if any of them are
        // valid client trees. If one is found, return the path in UNC form

        // search all current shares on this system

        dwEntriesProcessed = 0;
        dwEntriesRead = 0;
        dwTotalEntries = 0;
        dwResumeHandle = 0;
        while ((naStatus = NetShareEnum(
            NULL,
            2,
            (LPBYTE *)&psi2Data,
            0x00010000,
            &dwEntriesRead,
            &dwTotalEntries,
            &dwResumeHandle)) == NERR_Success) {
            if (dwEntriesRead == 0) break;  // then it'd done
            for (dwIndex = 0; dwIndex < dwEntriesRead; dwIndex++){
                // don't check shares that translate to floppy drives A: & B:
                if ((_tcsnicmp(psi2Data[dwIndex].shi2_path, cszADriveRoot, 3) != 0) &&
                    (_tcsnicmp(psi2Data[dwIndex].shi2_path, cszBDriveRoot, 3) != 0)) {
                    if (dwSearchType == FDT_TOOLS_TREE){
                        bValidPath = (BOOL)(ValidSrvToolsPath (psi2Data[dwIndex].shi2_path) == 0);
                    } else {
                        bValidPath = (BOOL)(ValidSharePath (psi2Data[dwIndex].shi2_path) == 0);
                    }
                    if (bValidPath) {
                        // make a UNC name out of share name
                        lstrcpy (szLocalPath, cszDoubleBackslash);
                        dwBufLen = MAX_COMPUTERNAME_LENGTH+1;
                        GetComputerName (&szLocalPath[2],  &dwBufLen);
                        lstrcat (szLocalPath, cszBackslash);
                        lstrcat (szLocalPath, psi2Data[dwIndex].shi2_netname);
                        lstrcat (szLocalPath, cszBackslash);

                        if (lstrlen(szLocalPath) < (LONG)dwPathLen) {
                            // save path string in user's buffer and leave
                            lstrcpy (szPath, szLocalPath);
                            lPathType = NCDU_LOCAL_SHARE_PATH;
                            lStatus = ERROR_SUCCESS;
                            bFound = TRUE;
                        }
                        break;
                    }
                }
            }
            // free buffer created by Net API
            if (psi2Data != NULL) NetApiBufferFree (psi2Data);
            // update entry counters to know when to stop looping
            dwEntriesProcessed += dwEntriesRead;
            if ((dwEntriesProcessed >= dwTotalEntries) || bFound) {
                break; // out of while loop
            }
        }
        if (bFound) goto GDP_ExitPoint;
    }

    if ((dwPhase & SEARCH_HARD_DRIVES) == SEARCH_HARD_DRIVES) {
        // if here, then no shared path was found, so search hard drives for
        // a client tree in the root directory and return the DOS path if one
        // is found

        szRootDir[0] = 0;
        szRootDir[1] = cColon;
        szRootDir[2] = cBackslash;
        szRootDir[3] = 0;
        for (szRootDir[0] = cC; szRootDir[0] <= cZ; szRootDir[0]++) {
            // if it's local or remote drive look for a clients dir.
            // don't check CD_ROM, RAM Disks or Removable drive
            nDriveType = GetDriveType(szRootDir);
            if ((nDriveType == DRIVE_FIXED) || (nDriveType == DRIVE_REMOTE)) {
                // see if this is drive has the appropriate sub-dir on it
                if (dwSearchType == FDT_TOOLS_TREE){
                    lstrcpy (&szRootDir[3], cszToolsDir);
                    bValidPath = (BOOL)(ValidSrvToolsPath (szRootDir) == 0);
                } else {
                    lstrcpy (&szRootDir[3], cszClientsDir);
                    bValidPath = (BOOL)(ValidSharePath (szRootDir) == 0);
                }
                if (bValidPath) {
                    // a valid path was found
                    if (nDriveType == DRIVE_REMOTE) {
                        // then this drive is shared on another machine
                        // so return the UNC version of the path
                        dwBufLen = MAX_PATH * sizeof(TCHAR);
                        if (LookupRemotePath (szRootDir, szLocalPath, &dwBufLen)) {
                            // save path string in user's buffer and leave
                            lstrcpy (szPath, szLocalPath);
                            lPathType = NCDU_LOCAL_SHARE_PATH;
                            lStatus = ERROR_SUCCESS;
                        } else {
                            // unable to look up redirected drive so return dos
                            // version of path (this shouldn't happen);
                            lstrcpy (szPath, szRootDir);
                            lPathType = NCDU_HARD_DRIVE_PATH;
                            lStatus = ERROR_SUCCESS;
                        }
                    } else {
                        // this is a Local drive so return the DOS
                        // version of path
                        lstrcpy (szPath, szRootDir);
                        lPathType = NCDU_HARD_DRIVE_PATH;
                        lStatus = ERROR_SUCCESS;
                    }
                    bFound = TRUE;
                    break;
                }
            } // else ignore if not a local or remote hard drive
            szRootDir[3] = 0;   // reset string back to a drive only
        } // end of for loop
        if (bFound) goto GDP_ExitPoint;
    }

    if ((dwPhase & SEARCH_CD_ROM) == SEARCH_CD_ROM) {
        // if here, then no client tree was found on a hard drive, so see if
        // they have a CD-ROM with the client tree on it. If they do, then
        // return the DOS path of the dir.

        // find CD-ROM drive
        szRootDir[0] = 0;
        szRootDir[1] = cColon;
        szRootDir[2] = cBackslash;
        szRootDir[3] = 0;

        for (szRootDir[0] = cC; szRootDir[0] <= cZ; szRootDir[0]++) {
            if (GetDriveType(szRootDir) == DRIVE_CDROM) break;
        }

        if (szRootDir[0] <= cZ) {
            // then a CD-ROM must have been found, so append the "clients" dir
            // and see if this is a valid client tree
            if (dwSearchType == FDT_TOOLS_TREE){
                lstrcat (szRootDir, cszToolsDir);
                bValidPath = (BOOL)(ValidSrvToolsPath (szRootDir) == 0);
            } else {
                lstrcat (szRootDir, cszClientsDir);
                bValidPath = (BOOL)(ValidSharePath (szRootDir) == 0);
            }
            if (bValidPath) {
                // found one on the CD so return the DOS
                // version of path
                lstrcpy (szPath, szRootDir);
                lPathType = NCDU_CDROM_PATH;
                lStatus = ERROR_SUCCESS;
                bFound = TRUE;
            }
        }
        goto GDP_ExitPoint;
    }

    // if here, then NO client tree was found. so return an empty string
    // bufffer and error code.

    lStatus = ERROR_SUCCESS;
    lPathType = NCDU_NO_CLIENT_PATH_FOUND;
    *szPath = 0;   // make string buffer empty

GDP_ExitPoint:

    if (plPathType != NULL) {
        *plPathType = lPathType;
    }

    FREE_IF_ALLOC (szLocalPath);

    SetErrorMode (nErrorMode);  // restore old error mode

    return lStatus;
}

static
BOOL
FindClientsDlg_WM_INITDIALOG (
    IN  HWND    hwndDlg,
    IN  WPARAM  wParam,
    IN  LPARAM  lParam
)
/*++

Routine Description:

    Dialog Box initialization routine:
        calls routines that format the currently selected options
        for display in the static text fields of the dialog box

Arguments:

    IN  HWND    hwndDlg
        Handle to dialog box window

    IN  WPARAM  wParam
        Not Used

    IN  LPARAM  lParam
        pointer to client search data strucutre

Return Value:

    FALSE  because focus is set in this routine to the CANCEL button

--*/
{
    PFDT_DATA   pFdt = (PFDT_DATA)lParam;
    LPTSTR      szTitle;

    // locate windw
    PositionWindow  (hwndDlg);

    // set global flag
    bSearchForClients = TRUE;

    // clear dialog box text
    SetDlgItemText (hwndDlg, NCDU_CLIENT_SEARCH_PHASE, cszEmptyString);

    // display Tools Tree search string if appropriate
    szTitle = GlobalAlloc (GPTR, MAX_PATH_BYTES);
    if (szTitle != NULL) {
        if (pFdt->dwSearchType == FDT_TOOLS_TREE) {
            if (LoadString (
                (HINSTANCE)GetWindowLongPtr(hwndDlg, GWLP_HINSTANCE),
                NCDU_FINDING_TOOLS_PATH,
                szTitle,
                80) > 0) {
                SetDlgItemText (hwndDlg, NCDU_SEARCH_TYPE_TITLE, szTitle);
            }
        }
        FREE_IF_ALLOC (szTitle);
    }

    // start 1st phase of search
    PostMessage (hwndDlg, NCDU_SEARCH_FOR_CLIENTS, (WPARAM)SEARCH_REGISTRY, lParam);

    // set focus
    SetFocus (GetDlgItem(hwndDlg, IDCANCEL));

    // need an arrow cursor to cancel out of dialog box.

    hOrigCursor = SetCursor (LoadCursor(NULL, IDC_ARROW));

    return FALSE;
}

static
BOOL
FindClientsDlg_SEARCH_FOR_CLIENTS (
    IN  HWND    hwndDlg,    // dlg window handle
    IN  WPARAM  wParam,     // search phase
    IN  LPARAM  lParam      // search data structure
)
/*++

Routine Description:

    message processing routine to perform client tree search in phases

Arguments:

    IN  HWND    hwndDlg
        dlg window handle

    IN  WPARAM  wParam
        search phase

    IN  LPARAM  lParam
        search data structure

Return Value:

    TRUE

--*/
{
    UINT        nPhaseName;
    PFDT_DATA   pFdt;

    if (bSearchForClients) {
        // perform this phase of the search
        // set dlg box text
        switch (wParam) {
            case SEARCH_REGISTRY:
                nPhaseName = CSZ_SYSTEM_REGISTRY;
                break;

            case SEARCH_SHARED_DIRS:
                nPhaseName = CSZ_SHARED_DIRS;
                break;

            case SEARCH_HARD_DRIVES:
                nPhaseName = CSZ_HARD_DISK_DIRS;
                break;

            case SEARCH_CD_ROM:
                nPhaseName = CSZ_CD_ROM;
                break;

            default:
                nPhaseName = CSZ_LOCAL_MACHINE;
                break;
        }
        SetDlgItemText (hwndDlg, NCDU_CLIENT_SEARCH_PHASE,
            GetStringResource (nPhaseName));

        pFdt = (PFDT_DATA)lParam;

        // search for clients

        SearchForDistPath (
            pFdt->szPathBuffer,
            pFdt->dwPathBufferLen,
            pFdt->plPathType,
            pFdt->dwSearchType,
            (DWORD)wParam);

        if (*pFdt->plPathType != NCDU_NO_CLIENT_PATH_FOUND) {
            // client found, so end here
            EndDialog (hwndDlg, IDOK);
        } else {
            // try next phase
            if (wParam != SEARCH_LAST_PHASE) {
                wParam <<= 1;  // go to next phase
                PostMessage (hwndDlg, NCDU_SEARCH_FOR_CLIENTS,
                    wParam, lParam);
            } else {
                // this is the last phase so exit
                EndDialog (hwndDlg, (bSearchForClients ? IDOK : IDCANCEL));
            }
        }
    }
    return TRUE;
}

static
BOOL
FindClientsDlg_WM_COMMAND (
    IN  HWND    hwndDlg,
    IN  WPARAM  wParam,
    IN  LPARAM  lParam
)
/*++

Routine Description:

    WM_COMMAND message dispatching routine.
        Dispatches IDCANCEL and IDOK button messages, sends all others
        to the DefDlgProc.

Arguments:

    IN  HWND    hwndDlg
        Handle to dialog box window

    IN  WPARAM  wParam
        windows message wParam arg

    IN  LPARAM  lParam
        windows message lParam arg

Return Value:

    TRUE if message is not dispatched (i.e. not processed)
        othewise the value returned by the called routine.

--*/
{

    switch (LOWORD(wParam)) {
        case IDCANCEL:
            switch (HIWORD(wParam)) {
                case BN_CLICKED:
                    bSearchForClients = FALSE;
                    return TRUE;

                default:
                    return FALSE;
            }

        default:
            return FALSE;
    }
}
static
BOOL
FindClientsDlg_WM_DESTROY (
    IN  HWND    hwndDlg,
    IN  WPARAM  wParam,
    IN  LPARAM  lParam
)
/*++

Routine Description:

    restores original cursor when dialog box exits

Arguments:

    std. windows message args

Return Value:

    TRUE

--*/
{
    if (hOrigCursor != NULL) SetCursor (hOrigCursor);
    hOrigCursor = NULL;
    return TRUE;
}

static
INT_PTR CALLBACK
FindClientsDlgProc (
    IN  HWND    hwndDlg,
    IN  UINT    message,
    IN  WPARAM  wParam,
    IN  LPARAM  lParam
)
/*++

Routine Description:

    main dialog proc for this dialog box.
        Processes the following messages:

            WM_INITDIALOG:              dialog box initialization
            WM_COMMAND:                 command button/item selected
            WM_DESTROY:                 restore cursor on exit
            NCDU_SEARCH_FOR_CLIENTS:    execute search message

Arguments:

    IN  HWND    hwndDlg
        handle to dialog box window

    IN  UINT    message
        message id

    IN  WPARAM  wParam
        message wParam arg

    IN  LPARAM  lParam
        message lParam arg

Return Value:

    FALSE if message not processed by this module, otherwise the
        value returned by the message processing routine.

--*/
{
    switch (message) {
        // windows messages
        case WM_INITDIALOG: return (FindClientsDlg_WM_INITDIALOG (hwndDlg, wParam, lParam));
        case WM_COMMAND:    return (FindClientsDlg_WM_COMMAND (hwndDlg, wParam, lParam));
        case WM_DESTROY:    return (FindClientsDlg_WM_DESTROY (hwndDlg, wParam, lParam));
        // local messages
        case NCDU_SEARCH_FOR_CLIENTS:    return (FindClientsDlg_SEARCH_FOR_CLIENTS (hwndDlg, wParam, lParam));
        default:            return FALSE;
    }
}