/*++

    Copyright (c) 1994  Microsoft Corporation

Module Name:

    StrUtils.C

Abstract:

    String utility functions

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 <stdlib.h>     // string to number conversions
//
//  app include files
//
#include "otnboot.h"
#include "otnbtdlg.h"
//
//  Local constants
//
#define NUM_BUFS    8

BOOL
MatchFirst (
    IN LPCTSTR   szStringA,
    IN LPCTSTR   szStringB
)
/*++

Routine Description:

    performs a case in-sensitive comparison of the two strings to
        the extent of the shortest string. If, up to the length
        of the shortest string, the strings match then TRUE is
        returned otherwise FALSE is returned.


Arguments:

    IN LPCTSTR   szStringA,
        pointer to first string

    IN LPCTSTR   szStringB
        pointer to second string

Return Value:

    TRUE if match found
    FALSE if not

--*/
{
    LPTSTR  szAptr;     // pointer to char in szStringA to compare
    LPTSTR  szBptr;     // pointer to char in szStringB to compare

    if ((szStringA != NULL) && (szStringB != NULL)) {
        szAptr = (LPTSTR)szStringA;
        szBptr = (LPTSTR)szStringB;
        while ((*szBptr != 0) && (*szAptr != 0)) {
            if (_totlower(*szBptr) != _totlower(*szAptr)) break;
            szBptr++;
            szAptr++;
        }
        if (((*szAptr == 0) && ((*szBptr == 0) || (*szBptr == cBackslash))) ||
            ((*szBptr == 0) && ((*szAptr == 0) || (*szAptr == cBackslash)))) {
            // then a matched directoryto the end of the shortest string
            return TRUE;
        } else {
            return FALSE;
        }
    } else {
        return FALSE;
    }
}

DWORD
GetSizeFromInfString (
    IN  LPCTSTR  szString
)
/*++

Routine Description:

    Reads the estimated size of the directory tree as stored in the
        inf file. The format of the INF string is:

            key=entry
                where:
                    key = subdir name
                    entry = NumberOfFiles,TotalBytes

        value must be less than 2**32

Arguments:

    "entry" string read from INF file


Return Value:

    DWORD value of TotalBytes in entry

--*/
{
    LPTSTR  szSize;     // size string parsed from input string
    LPTSTR  szLastChar; // beginning of size value in string

    // size is second param in comma separated list
    // go to first comma
    szSize = (LPTSTR)szString;
    while ((*szSize != cComma) && (*szSize != 0)) szSize++;
    szSize++; // go to first char after comma
    return _tcstoul (szSize, &szLastChar, 10);
}

BOOL
SavePathToRegistry (
    LPCTSTR szPath,
    LPCTSTR szServerKey,
    LPCTSTR szShareKey
)
/*++

Routine Description:

    splits the path (which must be a UNC path) into server & sharepoint
        for loading into the system registry. The key used is the
        \HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\Network
        and the NCAdmin key is created (if it doesn't exist) under which the
        Server is stored in the szServerKey value and the share point is
        stored under the szShareKey value

Arguments:

    LPCTSTR szPath
        UNC path to store

    LPCTSTR szServerKey
        name of registry value to store server under

    LPCTSTR szShareKey
        name of registry value to store share under

Return Value:

    TRUE    values stored OK
    FALSE   values not stored

--*/
{
    TCHAR   szMachine[MAX_COMPUTERNAME_LENGTH+1];   // computer name buffer
    LPTSTR  szShare;                                // share name buffer
    HKEY    hkeyUserInfo;                           // registry key
    HKEY    hkeyAppInfo;                            // registry key

    LONG    lStatus;                                // local function status
    BOOL    bReturn;                                // return value of this fn
    DWORD   dwAppKeyDisp;                           // create/existing value

    szShare = GlobalAlloc (GPTR, MAX_PATH_BYTES);
    if (szShare == NULL) {
        // unable to alloc memory.
        return FALSE;
    }

    if (IsUncPath (szPath)) {
        // 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 error
            bReturn = FALSE;
        } else {
            // open registry key containing this app's info
            lStatus = RegCreateKeyEx (
                hkeyUserInfo,
                szAppName,
                0L,
                (LPTSTR)cszEmptyString,
                REG_OPTION_NON_VOLATILE,
                KEY_WRITE,
                NULL,
                &hkeyAppInfo,
                &dwAppKeyDisp);

            if (lStatus != ERROR_SUCCESS) {
                // unable to open key so return false
                bReturn = FALSE;
            } else {
                if (!GetServerFromUnc (szPath, szMachine)) {
                    // unable to read share so clear value
                    szMachine[0] = 0;
                }
                // get server name from registry
                lStatus = RegSetValueEx (
                    hkeyAppInfo,
                    (LPTSTR)szServerKey,
                    0L,
                    REG_SZ,
                    (LPBYTE)&szMachine[0],
                    (DWORD)(lstrlen(szMachine)*sizeof(TCHAR)));

                if (lStatus == ERROR_SUCCESS) {
                    if (!GetShareFromUnc (szPath, szShare)) {
                        szShare[0] = 0;
                    }

                    lStatus = RegSetValueEx (
                        hkeyAppInfo,
                        (LPTSTR)szShareKey,
                        0L,
                        REG_SZ,
                        (LPBYTE)&szShare[0],
                        (DWORD)(lstrlen(szShare)*sizeof(TCHAR)));

                    if (lStatus == ERROR_SUCCESS) {
                        bReturn = TRUE;
                    } else {
                        bReturn = FALSE;
                    }
                } else {
                    bReturn = FALSE;
                }

                RegCloseKey (hkeyAppInfo);
            }
            RegCloseKey (hkeyUserInfo);
        }

        bReturn = TRUE;
    } else {
        // not a UNC path so return error
        bReturn = FALSE;
    }

    FREE_IF_ALLOC (szShare);
    return bReturn;

}

DWORD
QuietGetPrivateProfileString (
    IN  LPCTSTR lpszSection,    /* address of section name  */
    IN  LPCTSTR lpszKey,        /* address of key name  */
    IN  LPCTSTR lpszDefault,    /* address of default string    */
    OUT LPTSTR lpszReturnBuffer, /* address of destination buffer    */
    IN  DWORD cchReturnBuffer,  /* size of destination buffer   */
    IN  LPCTSTR lpszFile        /* address of initialization filename   */
)
/*++

Routine Description:

    Reads data from profile file without triggering OS error message if
        unable to access file.

Arguments:

    IN  LPCTSTR lpszSection
        address of section name
    IN  LPCTSTR lpszKey
        address of key name
    IN  LPCTSTR lpszDefault
        address of default string
    OUT LPTSTR lpszReturnBuffer
        address of destination buffer
    IN  DWORD cchReturnBuffer
        size of destination buffer (in characters)
    IN  LPCTSTR lpszFile
        address of initialization filename

    See HELP on GetPrivateProfileString for details on using these arguments.

Return Value:

    number of characters copied into lpszReturnBuffer.

--*/
{
    DWORD   dwReturn;
    UINT    nErrorMode;

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

    // call function
    dwReturn = GetPrivateProfileString (
        lpszSection, lpszKey, lpszDefault, lpszReturnBuffer,
        cchReturnBuffer, lpszFile);

    SetErrorMode (nErrorMode);  // restore old error mode

    return dwReturn;
}

LPCTSTR
GetKeyFromEntry (
    IN  LPCTSTR  szEntry
)
/*++

Routine Description:

    copys the "key" from an INF string of the format:
        Key=Value. All text up to, but not including the "="
        is returned.

Arguments:

    IN  LPCTSTR szEntry
        line from INF file to process. must be in the format referenced
        above.

Return Value:

    pointer to a read only string that contains the resulting key string.

    NOTE: this is stored in a static variable and should be copied to a
    local variable for further processing OR before calling this routine
    again.

--*/
{
    static  TCHAR   szReturnBuffer[MAX_PATH];
    LPTSTR  szSource, szDest;

    szSource = (LPTSTR)szEntry;
    szDest = &szReturnBuffer[0];

    *szDest = 0;

    if (*szSource != 0) {
        // copy all chars from start to the equal sign
        //  (or the end of the string)
        while ((*szSource != cEqual) && (*szSource != 0)) {
            *szDest++ = *szSource++;
        }
        *szDest = 0; //terminate destination string (key)
    }
    return szReturnBuffer;
}

LPCTSTR
GetItemFromEntry (
    IN  LPCTSTR  szEntry,
    IN  DWORD   dwItem

)
/*++

Routine Description:

    returns nth item from comma separated list returned from
        inf file. leaves (double)quoted strings intact.

Arguments:

    IN  LPCTSTR szEntry
        entry string returned from INF file

    IN  DWORD   dwItem
        1-based index indicating which item to return. (i.e. 1= first item
        in list, 2= second, etc.)


Return Value:

    pointer to buffer containing desired entry in string. Note, this
        routine may only be called 4 times before the string
        buffer is re-used. (i.e. don't use this function more than
        4 times in another function call!!)

--*/
{
    static  TCHAR   szReturnBuffer[4][MAX_PATH];
    LPTSTR  szSource, szDest;
    DWORD   dwThisItem;
    static  DWORD   dwBuff;

    dwBuff = ++dwBuff % 4; // wrap buffer index

    szSource = (LPTSTR)szEntry;
    szDest = &szReturnBuffer[dwBuff][0];

    *szDest = 0;

    // go past ini key
    while ((*szSource != cEqual) && (*szSource != 0)) szSource++;
    if (*szSource == 0){
        // no equals found so start at beginning
        // presumably this is just the "value"
        szSource = (LPTSTR)szEntry;
    } else {
        szSource++;
    }
    dwThisItem = 1;
    while (dwThisItem < dwItem) {
        if (*szSource != 0) {
            while ((*szSource != cComma) && (*szSource != 0)) {
                if (*szSource == cDoubleQuote) {
                    // if this is a quote, then go to the close quote
                    szSource++;
                    while ((*szSource != cDoubleQuote) && (*szSource != 0)) szSource++;
                }
                if (*szSource != 0) szSource++;
            }
        }
        dwThisItem++;
        if (*szSource != 0) szSource++;
    }
    // copy this entry to the return buffer
    if (*szSource != 0) {
        while ((*szSource != cComma) && (*szSource != 0)) {
            if (*szSource == cDoubleQuote) {
                // if this is a quote, then go to the close quote
                // don't copy quotes!
                szSource++;
                while ((*szSource != cDoubleQuote) && (*szSource != 0)) {
                    *szDest++ = *szSource++;
                }
                if (*szSource != 0) szSource++;
            } else {
                *szDest++ = *szSource++;
            }
        }
        *szDest = 0;
    }

    return &szReturnBuffer[dwBuff][0];
}

LPCTSTR
GetFileNameFromEntry (
    IN  LPCTSTR szEntry
)
/*++

Routine Description:

    returns pointer into szEntry where file name is found.
        first character after the ":"

Arguments:

    string containing filename in format of:
        nn:filename.ext

Return Value:

    returns pointer into szEntry where file name is found.
        first character after the ":"
    returns an empty string if no ":" char was found.

--*/
{
    LPTSTR szReturn;
    szReturn = (LPTSTR)szEntry;
    // go to COLON character
    while ((*szReturn != cColon) && (*szReturn != 0)) szReturn++;
    // scoot to next char
    if (*szReturn != 0) szReturn++;
    return szReturn;
}

BOOL
TrimSpaces (
    IN  OUT LPTSTR  szString
)
/*++

Routine Description:

    Trims leading and trailing spaces from szString argument, modifying
        the buffer passed in

Arguments:

    IN  OUT LPTSTR  szString
        buffer to process

Return Value:

    TRUE if string was modified
    FALSE if not

--*/
{
    LPTSTR  szSource;
    LPTSTR  szDest;
    LPTSTR  szLast;
    BOOL    bChars;

    szLast = szSource = szDest = szString;
    bChars = FALSE;

    while (*szSource != 0) {
        // skip leading non-space chars
        if (*szSource > cSpace) {
            szLast = szDest;
            bChars = TRUE;
        }
        if (bChars) {
            // remember last non-space character
            // copy source to destination & increment both
            *szDest++ = *szSource++;
        } else {
            szSource++;
        }
    }

    if (bChars) {
        *++szLast = 0; // terminate after last non-space char
    } else {
        // string was all spaces so return an empty (0-len) string
        *szString = 0;
    }

    return (szLast != szSource);
}

BOOL
IsUncPath (
    IN  LPCTSTR  szPath
)
/*++

Routine Description:

    examines path as a string looking for "tell-tale" double
        backslash indicating the machine name syntax of a UNC path

Arguments:

    IN  LPCTSTR szPath
        path to examine

Return Value:

    TRUE if \\ found at start of string
    FALSE if not

--*/
{
    LPTSTR  szPtChar;

    szPtChar = (LPTSTR)szPath;
    if (*szPtChar == cBackslash) {
        if (*++szPtChar == cBackslash) {
            return TRUE;
        }
    }
    return FALSE;
}

LPCTSTR
GetEntryInMultiSz (
    IN  LPCTSTR   mszList,
    IN  DWORD   dwEntry

)
/*++

Routine Description:

    Searches for the specified element in the mszList and returns the pointer
        to that element in the list.

Arguments:

    IN  LPCTSTR   mszList       Multi-SZ list to search
    IN  DWORD   dwEntry         1-based index of entry to return

ReturnValue:

        !=cszEmptyString    pointer to matching element in list
        cszEmptyString      (pointer to 0-length string) entry is not in list
--*/
{
    LPCTSTR   szThisString;
    DWORD   dwIndex=0;

    if (mszList == NULL) return (LPCTSTR)cszEmptyString;   // no list to process
    if (dwEntry == 0) return (LPCTSTR)cszEmptyString;      // no string to find

    for (szThisString = mszList;
        *szThisString;
        szThisString += (lstrlen(szThisString)+ 1)) {
        dwIndex++;
        if (dwIndex == dwEntry) {
            return szThisString;
        }
    }

    return (LPCTSTR)cszEmptyString;
}

DWORD
AddStringToMultiSz (
    LPTSTR OUT   mszDest,
    LPCTSTR IN    szSource
)
/*++

Routine Description:

    appends the source string to the end of the destination MULTI_SZ
        string. Assumes that the destination is large enough!

Arguments:

    LPTSTR OUT   mszDest     multi-sz string to be appended
    LPTSTR IN    szSource    ASCIZ string to be added to the end of the dest
                            string

ReturnValue:

    1

--*/
{
    LPTSTR   szDestElem;

    // check function arguments

    if ((mszDest == NULL) || (szSource == NULL)) return 0; // invalid buffers
    if (*szSource == '\0') return 0; // no string to add

    // go to end of dest string
    //

    for (szDestElem = mszDest;
            *szDestElem;
            szDestElem += (lstrlen(szDestElem)+1));

    // if here, then add string
    // szDestElem is at end of list

    lstrcpy (szDestElem, szSource);
    szDestElem += (lstrlen(szDestElem) + 1);
    *szDestElem = '\0'; // add second NULL

    return 1;
}

DWORD
StringInMultiSz (
    IN  LPCTSTR   szString,
    IN  LPCTSTR   mszList
)
/*++

Routine Description:

    Searches each element in the mszList and does a case-insensitive
        comparison with the szString argument.

Arguments:

    IN  LPCTSTR   szString    string to find in list
    IN  LPCTSTR   mszList     list to search

ReturnValue:

        >0      szString was found in the list, # returned is the
                    index of the matching entry (1= first)
        0       szString was NOT found
--*/
{
    LPTSTR   szThisString;
    DWORD   dwIndex=0;

    // check input arguments

    if ((szString == NULL) || (mszList == NULL)) return 0;  // invalid buffer
    if (*szString == 0) return 0; // no string to find

    for (szThisString = (LPTSTR)mszList;
        *szThisString;
        szThisString += (lstrlen(szThisString)+ 1)) {
        dwIndex++;
        if (lstrcmpi(szThisString, szString) == 0) {
            return dwIndex;
        }
    }

    return 0;
}

LPCTSTR
GetStringResource (
    IN  UINT    nId
)
/*++

Routine Description:

    look up string resource and return string

Arguments:

    IN  UINT    nId
        Resource ID of string to look up

Return Value:

    pointer to string referenced by ID in arg list

--*/
{
    static  TCHAR   szBufArray[NUM_BUFS][SMALL_BUFFER_SIZE];
    static  DWORD   dwIndex;
    LPTSTR  szBuffer;
    DWORD   dwLength;

    dwIndex++;
    dwIndex %= NUM_BUFS;
    szBuffer = &szBufArray[dwIndex][0];

    dwLength = LoadString (
        GetModuleHandle (NULL),
        nId,
        szBuffer,
        SMALL_BUFFER_SIZE);

    return (LPCTSTR)szBuffer;
}

DWORD
GetMultiSzLen (
    IN  LPCTSTR     mszInString
)
/*++

Routine Description:

    Counts the number of characters in the multi-sz string (including
        NULL's between strings and terminating NULL char)

Arguments:

    IN  LPCTSTR mszInString
        multi-sz string to count

Return Value:

    number of characters in string

--*/
{
    LPCTSTR szEndChar = mszInString;
    BOOL    bEnd = FALSE;
    DWORD   dwCharsInString = 0;

    while (!bEnd) {
        if (*szEndChar == 0) {
            // this is the end of a line so adjust the count to
            // account for the crlf being 2 chars
            szEndChar++;
            dwCharsInString += 2;

            if (*szEndChar == 0) {
                // this is the end of the MSZ
                dwCharsInString++; // for the CTRL-Z
                bEnd = TRUE;
            }
        } else {
            szEndChar++;
            dwCharsInString++;
        }
    }

    return dwCharsInString;
}

DWORD
TranslateEscapeChars (
    IN  LPTSTR szNewString,
    IN  LPTSTR szString
)
/*++

    Translates the following escape sequences if found in the string.
    The translation is performed on szString and written to szNewString.

    The return value is the length of the resulting string in characters;

--*/
{
    LPTSTR szSource;
    LPTSTR szDest;

    szSource = szString;
    szDest = szNewString;

    while (*szSource != 0) {
        if (*szSource == '\\') {
            // this is an escape sequence so go to the next char
            // and see which one.
            szSource++;
            switch (*szSource) {
                case _T('b'):
                    *szDest = _T('\b');
                    break;

                case _T('f'):
                    *szDest = _T('\f');
                    break;

                case _T('n'):
                    *szDest = _T('\n');
                    break;

                case _T('r'):
                    *szDest = _T('\r');
                    break;

                case _T('t'):
                    *szDest = _T('\t');
                    break;

                case _T('v'):
                    *szDest = _T('\v');
                    break;

                case _T('?'):
                    *szDest = _T('\?');
                    break;

                case _T('\''):
                    *szDest = _T('\'');
                    break;

                case _T('\"'):
                    *szDest = _T('\"');
                    break;

                case _T('\\'):
                    *szDest = _T('\\');
                    break;

                default:
                    *szDest = *szSource;
                    break;
            }
            szDest++;
            szSource++;
        } else {
            // just a plain old character so copy it
            *szDest++ = *szSource++;
        }
    }
    return (DWORD)(szDest - szNewString);

}