w2k_img.c

Undocumented Windows 2000 Secrets简体中文版.+源码光盘

        case 6: pbDay = "Saturday";  break;
        }
    return pbDay;
    }

// -----------------------------------------------------------------

PWORD WINAPI imgTimeDayW (IMG_TIME it)
    {
    PWORD pwDay = NULL;

    switch (it.bDayOfWeek % 7)
        {
        case 0: pwDay = L"Sunday";    break;
        case 1: pwDay = L"Monday";    break;
        case 2: pwDay = L"Tuesday";   break;
        case 3: pwDay = L"Wednesday"; break;
        case 4: pwDay = L"Thursday";  break;
        case 5: pwDay = L"Friday";    break;
        case 6: pwDay = L"Saturday";  break;
        }
    return pwDay;
    }

// =================================================================
// FILE PATH MANAGEMENT
// =================================================================

DWORD WINAPI imgPathRootA (PBYTE pbPath)
    {
    DWORD dRoot = 0;

    if ((pbPath != NULL) && pbPath [0])
        {
        if (pbPath [0] == '\\')
            {
            if (pbPath [1] == '\\')
                {
                for (dRoot = 2;
                     pbPath [dRoot] && (pbPath [dRoot] != '\\');
                     dRoot++);
                }
            }
        else
            {
            if (pbPath [1] == ':') dRoot = 2;
            }
        }
    return dRoot;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathRootW (PWORD pwPath)
    {
    DWORD dRoot = 0;

    if ((pwPath != NULL) && pwPath [0])
        {
        if (pwPath [0] == '\\')
            {
            if (pwPath [1] == '\\')
                {
                for (dRoot = 2;
                     pwPath [dRoot] && (pwPath [dRoot] != '\\');
                     dRoot++);
                }
            }
        else
            {
            if (pwPath [1] == ':') dRoot = 2;
            }
        }
    return dRoot;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathNameA (PBYTE  pbPath,
                           PDWORD pdExtension)
    {
    DWORD dRoot, dEnd;
    DWORD dExtension = 0;
    DWORD dName      = 0;

    if (pbPath != NULL)
        {
        dRoot = imgPathRootA (pbPath);
        dEnd  = dRoot + lstrlenA (pbPath + dRoot);

        for (dName = dEnd;
             (dName > dRoot) && (pbPath [dName-1] != '\\')
                             && (pbPath [dName-1] != ':' );
             dName--);

        for (dExtension = dEnd;
             (dExtension > dName) && (pbPath [dExtension-1] != '.');
             dExtension--);

        dExtension = (dExtension == dName ? dEnd : dExtension - 1);
        }
    if (pdExtension != NULL) *pdExtension = dExtension;
    return dName;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathNameW (PWORD  pwPath,
                           PDWORD pdExtension)
    {
    DWORD dRoot, dEnd;
    DWORD dExtension = 0;
    DWORD dName      = 0;

    if (pwPath != NULL)
        {
        dRoot = imgPathRootW (pwPath);
        dEnd  = dRoot + lstrlenW (pwPath + dRoot);

        for (dName = dEnd;
             (dName > dRoot) && (pwPath [dName-1] != '\\')
                             && (pwPath [dName-1] != ':' );
             dName--);

        for (dExtension = dEnd;
             (dExtension > dName) && (pwPath [dExtension-1] != '.');
             dExtension--);

        dExtension = (dExtension == dName ? dEnd : dExtension - 1);
        }
    if (pdExtension != NULL) *pdExtension = dExtension;
    return dName;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathCanonicalA (PBYTE pbPath,   // NULL: current dir
                                PBYTE pbBuffer, // can be == pbPath
                                DWORD dBuffer)
    {
    BYTE  abBuffer [MAX_PATH];
    PBYTE pb;
    DWORD n = 0;

    if ((pbBuffer != NULL) && dBuffer)
        {
        n = (pbPath == NULL
             ? GetCurrentDirectoryA (MAX_PATH, abBuffer)
             : (pbPath [0]
                ? GetFullPathNameA (pbPath, MAX_PATH, abBuffer, &pb)
                : 0));

        if (n && (n < MAX_PATH))
            {
            if (abBuffer [n-1] != '\\')
                {
                if (n+1 < MAX_PATH)
                    {
                    abBuffer [n++] = '\\';
                    }
                else
                    {
                    n = 0;
                    }
                }
            }
        else
            {
            n = 0;
            }
        if (n >= dBuffer) n = 0;
        abBuffer [n] = 0;
        lstrcpyA (pbBuffer, abBuffer);
        }
    return n;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathCanonicalW (PWORD pwPath,   // NULL: current dir
                                PWORD pwBuffer, // can be == pwPath
                                DWORD dBuffer)
    {
    WORD  awBuffer [MAX_PATH];
    PWORD pw;
    DWORD n = 0;

    if ((pwBuffer != NULL) && dBuffer)
        {
        n = (pwPath == NULL
             ? GetCurrentDirectoryW (MAX_PATH, awBuffer)
             : (pwPath [0]
                ? GetFullPathNameW (pwPath, MAX_PATH, awBuffer, &pw)
                : 0));

        if (n && (n < MAX_PATH))
            {
            if (awBuffer [n-1] != '\\')
                {
                if (n+1 < MAX_PATH)
                    {
                    awBuffer [n++] = '\\';
                    }
                else
                    {
                    n = 0;
                    }
                }
            }
        else
            {
            n = 0;
            }
        if (n >= dBuffer) n = 0;
        awBuffer [n] = 0;
        lstrcpyW (pwBuffer, awBuffer);
        }
    return n;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathCurrentA (PBYTE pbBuffer,
                              DWORD dBuffer)
    {
    return imgPathCanonicalA (NULL, pbBuffer, dBuffer);
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathCurrentW (PWORD pwBuffer,
                              DWORD dBuffer)
    {
    return imgPathCanonicalW (NULL, pwBuffer, dBuffer);
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathWindowsA (PBYTE pbBuffer,
                              DWORD dBuffer)
    {
    BYTE  abBuffer [MAX_PATH];
    DWORD n;

    n = GetWindowsDirectoryA (abBuffer, MAX_PATH);
    if (n >= MAX_PATH) n = 0;
    abBuffer [n] = 0;
    return imgPathCanonicalA (abBuffer, pbBuffer, dBuffer);
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathWindowsW (PWORD pwBuffer,
                              DWORD dBuffer)
    {
    WORD  awBuffer [MAX_PATH];
    DWORD n;

    n = GetWindowsDirectoryW (awBuffer, MAX_PATH);
    if (n >= MAX_PATH) n = 0;
    awBuffer [n] = 0;
    return imgPathCanonicalW (awBuffer, pwBuffer, dBuffer);
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathVariableA (PBYTE pbVariable,
                               PBYTE pbBuffer,
                               DWORD dBuffer,
                               DWORD dIndex)
    {
    BYTE  abBuffer [MAX_PATH_EX];
    DWORD i, j, k;
    DWORD n = 0;

    n = GetEnvironmentVariableA (pbVariable, abBuffer, MAX_PATH_EX);
    if (n >= MAX_PATH_EX) n = 0;

    for (i = j = 0; (i < dIndex) && (j < n); i++)
        {
        while ((j < n) && (abBuffer [j++] != ';'));
        }
    while ((j < n) && (abBuffer [j] == ' ')) j++;
    for (k = j; (k < n) && (abBuffer [k] != ';'); k++);
    while ((k > j) && (abBuffer [k-1] == ' ')) k--;

    if (j < n)
        {
        i = 0;

        if (k - j < MAX_PATH)
            {
            if (j)
                {
                while (j < k) abBuffer [i++] = abBuffer [j++];
                }
            else
                {
                i = k - j;
                }
            }
        abBuffer [i] = 0;

        n = imgPathCanonicalA (abBuffer, pbBuffer, dBuffer);
        }
    else
        {
        if ((pbBuffer != NULL) && dBuffer) pbBuffer [0] = 0;
        n = -1;
        }
    return n;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathVariableW (PWORD pwVariable,
                               PWORD pwBuffer,
                               DWORD dBuffer,
                               DWORD dIndex)
    {
    WORD  awBuffer [MAX_PATH_EX];
    DWORD i, j, k;
    DWORD n = 0;

    n = GetEnvironmentVariableW (pwVariable, awBuffer, MAX_PATH_EX);
    if (n >= MAX_PATH_EX) n = 0;

    for (i = j = 0; (i < dIndex) && (j < n); i++)
        {
        while ((j < n) && (awBuffer [j++] != ';'));
        }
    while ((j < n) && (awBuffer [j] == ' ')) j++;
    for (k = j; (k < n) && (awBuffer [k] != ';'); k++);
    while ((k > j) && (awBuffer [k-1] == ' ')) k--;

    if (j < n)
        {
        i = 0;

        if (k - j < MAX_PATH)
            {
            if (j)
                {
                while (j < k) awBuffer [i++] = awBuffer [j++];
                }
            else
                {
                i = k - j;
                }
            }
        awBuffer [i] = 0;

        n = imgPathCanonicalW (awBuffer, pwBuffer, dBuffer);
        }
    else
        {
        if ((pwBuffer != NULL) && dBuffer) pwBuffer [0] = 0;
        n = -1;
        }
    return n;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathEnumerateA (IMG_CALLBACKA CallbackA,
                                PBYTE         pbModule,
                                PVOID         pContext)
    {
    BYTE  abPath [MAX_PATH];
    DWORD i, j;
    DWORD n = 0;

    if (CallbackA != NULL)
        {
        if ((pbModule != NULL) &&
            ((i = imgPathNameA (pbModule, NULL)) < MAX_PATH))
            {
            lstrcpynA (abPath, pbModule, i+1);

            if (j = imgPathCanonicalA (abPath, abPath, MAX_PATH))
                {
                if (n = CallbackA (pbModule, abPath, j, pContext))
                    return n;
                }
            }
        if (j = imgPathCurrentA (abPath, MAX_PATH))
            {
            if (n = CallbackA (pbModule, abPath, j, pContext))
                return n;
            }
        i = 0;
        while ((j = imgPathVariableA (gabSymbolPath1,
                                      abPath, MAX_PATH, i++))
               != -1)
            {
            if (j)
                {
                if (n = CallbackA (pbModule, abPath, j, pContext))
                    return n;
                }
            }
        i = 0;
        while ((j = imgPathVariableA (gabSymbolPath2,
                                      abPath, MAX_PATH, i++))
               != -1)
            {
            if (j)
                {
                if (n = CallbackA (pbModule, abPath, j, pContext))
                    return n;
                }
            }
        if (j = imgPathWindowsA (abPath, MAX_PATH))
            {
            if (n = CallbackA (pbModule, abPath, j, pContext))
                return n;
            }
        n = CallbackA (pbModule, NULL, 0, pContext);
        }
    return n;
    }

// -----------------------------------------------------------------

DWORD WINAPI imgPathEnumerateW (IMG_CALLBACKW CallbackW,
                                PWORD         pwModule,
                                PVOID         pContext)
    {
    WORD  awPath [MAX_PATH];
    DWORD i, j;
    DWORD n = 0;

    if (CallbackW != NULL)
        {
        if ((pwModule != NULL) &&
            ((i = imgPathNameW (pwModule, NULL)) < MAX_PATH))
            {
            lstrcpynW (awPath, pwModule, i+1);

            if (j = imgPathCanonicalW (awPath, awPath, MAX_PATH))
                {
                if (n = CallbackW (pwModule, awPath, j, pContext))
                    return n;
                }