where.c File Reference

#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <winnls.h>
#include <strsafe.h>
#include <conutils.h>
#include "strlist.h"
#include "resource.h"

Include dependency graph for where.c:

Go to the source code of this file.

Macros
#define	FLAG_HELP   (1 << 0)
#define	FLAG_R   (1 << 1)
#define	FLAG_Q   (1 << 2)
#define	FLAG_F   (1 << 3)
#define	FLAG_T   (1 << 4)
#define	IS_DOTS(pch)    (*(pch) == L'.' && ((pch)[1] == 0 || ((pch)[1] == L'.' && (pch)[2] == 0)))
#define	DEFAULT_PATHEXT   L".com;.exe;.bat;.cmd"

Typedefs
typedef enum WRET	WRET
typedef BOOL(CALLBACK *	WHERE_CALLBACK) (LPCWSTR pattern, LPCWSTR path, PWIN32_FIND_DATAW data)

Enumerations
enum	WRET { WRET_SUCCESS = 0 , WRET_NOT_FOUND = 1 , WRET_ERROR = 2 }

Functions
static VOID	WhereError (UINT nID)
static BOOL	WhereSearchGeneric (LPCWSTR pattern, LPWSTR path, size_t path_len, BOOL bDir, WHERE_CALLBACK callback)
static BOOL CALLBACK	WherePrintPath (LPCWSTR pattern, LPCWSTR path, PWIN32_FIND_DATAW data)
static BOOL	WhereSearchFiles (LPCWSTR pattern, LPCWSTR dir)
static BOOL	WhereSearchRecursive (LPCWSTR pattern, LPCWSTR dir)
static BOOL CALLBACK	WhereSearchRecursiveCallback (LPCWSTR pattern, LPCWSTR path, PWIN32_FIND_DATAW data)
static BOOL	WhereSearch (LPCWSTR pattern, strlist_t *dirlist)
static BOOL	WhereGetVariable (LPCWSTR name, LPWSTR *value)
static BOOL	WhereDoOption (DWORD flag, LPCWSTR option)
static BOOL	WhereParseCommandLine (INT argc, WCHAR **argv)
static BOOL	WhereGetPathExt (strlist_t *ext_list)
static BOOL	WhereFindByDirs (LPCWSTR pattern, LPWSTR dirs)
static BOOL	WhereFindByVar (LPCWSTR pattern, LPCWSTR name)
static BOOL	WhereIsRecursiveDirOK (LPCWSTR name)
static BOOL	WhereDoPattern (LPWSTR pattern)
INT	wmain (INT argc, WCHAR **argv)

Variables
static DWORD	s_dwFlags = 0
static LPWSTR	s_pszRecursiveDir = NULL
static strlist_t	s_patterns = strlist_default
static strlist_t	s_results = strlist_default
static strlist_t	s_pathext = strlist_default

Macro Definition Documentation

DEFAULT_PATHEXT

#define DEFAULT_PATHEXT   L".com;.exe;.bat;.cmd"

Definition at line 33 of file where.c.

FLAG_F

#define FLAG_F   (1 << 3)

Definition at line 20 of file where.c.

FLAG_HELP

#define FLAG_HELP   (1 << 0)

Definition at line 17 of file where.c.

FLAG_Q

#define FLAG_Q   (1 << 2)

Definition at line 19 of file where.c.

FLAG_R

#define FLAG_R   (1 << 1)

Definition at line 18 of file where.c.

FLAG_T

#define FLAG_T   (1 << 4)

Definition at line 21 of file where.c.

IS_DOTS

#define IS_DOTS

(

pch

)

(*(pch) == L'.' && ((pch)[1] == 0 || ((pch)[1] == L'.' && (pch)[2] == 0)))

Definition at line 30 of file where.c.

Typedef Documentation

WHERE_CALLBACK

typedef BOOL(CALLBACK * WHERE_CALLBACK) (LPCWSTR pattern, LPCWSTR path, PWIN32_FIND_DATAW data)

Definition at line 48 of file where.c.

WRET

typedef enum WRET WRET

Enumeration Type Documentation

WRET

enum WRET

Enumerator
WRET_SUCCESS
WRET_NOT_FOUND
WRET_ERROR

Definition at line 35 of file where.c.

{
    WRET_SUCCESS = 0,
    WRET_NOT_FOUND = 1,
    WRET_ERROR = 2
} WRET;

Function Documentation

WhereDoOption()

static BOOL WhereDoOption ( DWORD  flag, LPCWSTR  option  )

static

Definition at line 202 of file where.c.

{
    if (s_dwFlags & flag)
    {
        ConResPrintf(StdErr, IDS_TOO_MANY, option, 1);
        ConResPuts(StdErr, IDS_TYPE_HELP);
        return FALSE;
    }
    s_dwFlags |= flag;
    return TRUE;
}

Referenced by WhereParseCommandLine().

WhereDoPattern()

static BOOL WhereDoPattern ( LPWSTR  pattern )

static

Definition at line 383 of file where.c.

{
    BOOL ret;
    LPWSTR pch = wcsrchr(pattern, L':');
    if (pch)
    {
        *pch++ = 0;
        if (pattern[0] == L'$') // $env:pattern
        {
            if (s_dwFlags & FLAG_R) // recursive?
            {
                WhereError(IDS_ENVPAT_WITH_R);
                return FALSE;
            }
            ret = WhereFindByVar(pch, pattern + 1);
        }
        else // path:pattern
        {
            if (s_dwFlags & FLAG_R) // recursive?
            {
                WhereError(IDS_PATHPAT_WITH_R);
                return FALSE;
            }
            if (wcschr(pch, L'\\') != NULL) // found '\\'?
            {
                WhereError(IDS_BAD_PATHPAT);
                return FALSE;
            }
            ret = WhereFindByDirs(pch, pattern);
        }
    }
    else if (s_pszRecursiveDir) // recursive
    {
        WCHAR szPath[MAX_PATH];
 
        if (!WhereIsRecursiveDirOK(s_pszRecursiveDir))
            return FALSE;
 
        GetFullPathNameW(s_pszRecursiveDir, _countof(szPath), szPath, NULL);
 
        ret = WhereSearchRecursive(pattern, szPath);
    }
    else // otherwise
    {
        ret = WhereFindByVar(pattern, L"PATH");
    }
 
    if (!ret)
        WhereError(IDS_OUTOFMEMORY);
    return ret;
}

Referenced by wmain().

WhereError()

static VOID WhereError ( UINT  nID )

static

Definition at line 42 of file where.c.

{
    if (!(s_dwFlags & FLAG_Q)) // not quiet mode?
        ConResPuts(StdErr, nID);
}

Referenced by WhereDoPattern(), WhereIsRecursiveDirOK(), and wmain().

WhereFindByDirs()

static BOOL WhereFindByDirs ( LPCWSTR  pattern, LPWSTR  dirs  )

static

Definition at line 309 of file where.c.

{
    BOOL ret;
    size_t cch;
    WCHAR szPath[MAX_PATH];
    LPWSTR dir, pch;
    strlist_t dirlist = strlist_default;
 
    GetCurrentDirectoryW(_countof(szPath), szPath);
    if (!strlist_add(&dirlist, szPath))
        return FALSE; // out of memory
 
    for (dir = wcstok(dirs, L";"); dir; dir = wcstok(NULL, L";"))
    {
        if (*dir == L'"') // began from '"'
        {
            pch = wcschr(++dir, L'"'); // find '"'
            if (*pch)
                *pch = 0; // cut off
        }
 
        if (*dir != '\\' && dir[1] != L':')
            continue; // relative path
 
        cch = wcslen(dir);
        if (cch > 0 && dir[cch - 1] == L'\\')
            dir[cch - 1] = 0; // remove trailing backslash
 
        if (!strlist_add(&dirlist, dir))
        {
            strlist_destroy(&dirlist);
            return FALSE; // out of memory
        }
    }
 
    ret = WhereSearch(pattern, &dirlist);
    strlist_destroy(&dirlist);
    return ret;
}

Referenced by WhereDoPattern(), and WhereFindByVar().

WhereFindByVar()

static BOOL WhereFindByVar ( LPCWSTR  pattern, LPCWSTR  name  )

static

Definition at line 349 of file where.c.

{
    LPWSTR value;
    BOOL ret = WhereGetVariable(name, &value);
    if (ret && value)
        ret = WhereFindByDirs(pattern, value);
    free(value);
    return ret;
}

Referenced by WhereDoPattern().

WhereGetPathExt()

static BOOL WhereGetPathExt ( strlist_t *  ext_list )

static

Definition at line 275 of file where.c.

{
    BOOL ret = TRUE;
    LPWSTR pszPathExt, ext;
    DWORD cchPathExt = GetEnvironmentVariableW(L"PATHEXT", NULL, 0);
 
    pszPathExt = (cchPathExt ? malloc(cchPathExt * sizeof(WCHAR)) : str_clone(DEFAULT_PATHEXT));
    if (!pszPathExt)
        return FALSE; // out of memory
 
    if (cchPathExt)
        GetEnvironmentVariableW(L"PATHEXT", pszPathExt, cchPathExt);
 
    if (!strlist_add(ext_list, L"")) // add empty extension for normal search
    {
        strlist_destroy(ext_list);
        free(pszPathExt);
        return FALSE;
    }
 
    for (ext = wcstok(pszPathExt, L";"); ext; ext = wcstok(NULL, L";")) // for all extensions
    {
        if (!strlist_add(ext_list, ext)) // add extension to ext_list
        {
            strlist_destroy(ext_list);
            ret = FALSE;
            break;
        }
    }
 
    free(pszPathExt);
    return ret;
}

Referenced by wmain().

WhereGetVariable()

static BOOL WhereGetVariable ( LPCWSTR  name, LPWSTR *  value  )

static

Definition at line 181 of file where.c.

{
    DWORD cch = GetEnvironmentVariableW(name, NULL, 0);
    if (cch == 0) // variable not found
    {
        *value = NULL;
        if (!(s_dwFlags & FLAG_Q)) // not quiet mode?
            ConResPrintf(StdErr, IDS_BAD_ENVVAR, name);
        return TRUE; // it is error, but continue the task
    }
 
    *value = malloc(cch * sizeof(WCHAR));
    if (!*value || !GetEnvironmentVariableW(name, *value, cch))
    {
        free(*value);
        *value = NULL;
        return FALSE; // error
    }
    return TRUE;
}

Referenced by WhereFindByVar().

WhereIsRecursiveDirOK()

static BOOL WhereIsRecursiveDirOK ( LPCWSTR  name )

static

Definition at line 359 of file where.c.

{
    if (wcschr(name, L';') != NULL)
    {
        WhereError(IDS_BAD_NAME);
        return FALSE;
    }
    else
    {
        DWORD attrs = GetFileAttributesW(name);
        if (attrs == INVALID_FILE_ATTRIBUTES) // file not found
        {
            WhereError(IDS_CANT_FOUND);
            return FALSE;
        }
        if (!(attrs & FILE_ATTRIBUTE_DIRECTORY))
        {
            WhereError(IDS_BAD_DIR);
            return FALSE;
        }
        return TRUE;
    }
}

Referenced by WhereDoPattern().

WhereParseCommandLine()

static BOOL WhereParseCommandLine ( INT  argc, WCHAR **  argv  )

static

Definition at line 214 of file where.c.

{
    INT iArg;
    for (iArg = 1; iArg < argc; ++iArg)
    {
        LPWSTR arg = argv[iArg];
        if (arg[0] == L'/' || arg[0] == L'-')
        {
            if (arg[2] == 0)
            {
                switch (towupper(arg[1]))
                {
                    case L'?':
                        if (!WhereDoOption(FLAG_HELP, L"/?"))
                            return FALSE;
                        continue;
                    case L'F':
                        if (!WhereDoOption(FLAG_F, L"/F"))
                            return FALSE;
                        continue;
                    case L'Q':
                        if (!WhereDoOption(FLAG_Q, L"/Q"))
                            return FALSE;
                        continue;
                    case L'T':
                        if (!WhereDoOption(FLAG_T, L"/T"))
                            return FALSE;
                        continue;
                    case L'R':
                    {
                        if (!WhereDoOption(FLAG_R, L"/R"))
                            return FALSE;
                        if (iArg + 1 < argc)
                        {
                            ++iArg;
                            s_pszRecursiveDir = argv[iArg];
                            continue;
                        }
                        ConResPrintf(StdErr, IDS_WANT_VALUE, L"/R");
                        ConResPuts(StdErr, IDS_TYPE_HELP);
                        return FALSE;
                    }
                }
            }
            ConResPrintf(StdErr, IDS_BAD_ARG, argv[iArg]);
            ConResPuts(StdErr, IDS_TYPE_HELP);
            return FALSE;
        }
        else // pattern?
        {
            if (!strlist_add(&s_patterns, argv[iArg])) // append pattern
            {
                ConResPuts(StdErr, IDS_OUTOFMEMORY);
                return FALSE;
            }
        }
    }
 
    return TRUE; // success
}

Referenced by wmain().

WherePrintPath()

static BOOL CALLBACK WherePrintPath ( LPCWSTR  pattern, LPCWSTR  path, PWIN32_FIND_DATAW  data  )

static

Definition at line 84 of file where.c.

{
    WCHAR szPath[MAX_PATH + 2], szDate[32], szTime[32];
    LARGE_INTEGER FileSize;
    FILETIME ftLocal;
    SYSTEMTIME st;
 
    if (strlist_find_i(&s_results, path) >= 0)
        return TRUE; // already exists
    if (!strlist_add(&s_results, path))
        return FALSE; // out of memory
    if (s_dwFlags & FLAG_Q) // quiet mode?
        return TRUE;
 
    if (s_dwFlags & FLAG_T) // print detailed info
    {
        // convert date/time
        FileTimeToLocalFileTime(&data->ftLastWriteTime, &ftLocal);
        FileTimeToSystemTime(&ftLocal, &st);
        // get date/time strings
        GetDateFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, szDate, _countof(szDate));
        GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, szTime, _countof(szTime));
        // set size
        FileSize.LowPart = data->nFileSizeLow;
        FileSize.HighPart = data->nFileSizeHigh;
        // print
        if (s_dwFlags & FLAG_F) // double quote
            StringCchPrintfW(szPath, _countof(szPath), L"\"%s\"", path);
        else
            StringCchCopyW(szPath, _countof(szPath), path);
        ConResPrintf(StdOut, IDS_FILE_INFO, FileSize.QuadPart, szDate, szTime, szPath);
    }
    else // print path only
    {
        if (s_dwFlags & FLAG_F) // double quote
            ConPrintf(StdOut, L"\"%ls\"\n", path);
        else
            ConPrintf(StdOut, L"%ls\n", path);
    }
    return TRUE; // success
}

Referenced by WhereSearchFiles().

WhereSearch()

static BOOL WhereSearch ( LPCWSTR  pattern, strlist_t *  dirlist  )

static

Definition at line 170 of file where.c.

{
    UINT iDir;
    for (iDir = 0; iDir < dirlist->count; ++iDir)
    {
        if (!WhereSearchFiles(pattern, strlist_get_at(dirlist, iDir)))
            return FALSE;
    }
    return TRUE;
}

Referenced by WhereFindByDirs().

WhereSearchFiles()

static BOOL WhereSearchFiles ( LPCWSTR  pattern, LPCWSTR  dir  )

static

Definition at line 126 of file where.c.

{
    INT iExt;
    size_t cch;
    WCHAR szPath[MAX_PATH];
    StringCchCopyW(szPath, _countof(szPath), dir);
    StringCchCatW(szPath, _countof(szPath), L"\\");
    StringCchCatW(szPath, _countof(szPath), pattern);
    cch = wcslen(szPath);
 
    for (iExt = 0; iExt < s_pathext.count; ++iExt)
    {
        szPath[cch] = 0; // cut off extension
        // append extension
        StringCchCatW(szPath, _countof(szPath), strlist_get_at(&s_pathext, iExt));
 
        if (!WhereSearchGeneric(pattern, szPath, _countof(szPath), FALSE, WherePrintPath))
            return FALSE;
    }
    return TRUE;
}

Referenced by WhereSearch(), and WhereSearchRecursive().

WhereSearchGeneric()

static BOOL WhereSearchGeneric ( LPCWSTR  pattern, LPWSTR  path, size_t  path_len, BOOL  bDir, WHERE_CALLBACK  callback  )

static

Definition at line 51 of file where.c.

{
    LPWSTR pch;
    size_t cch;
    BOOL ret;
    WIN32_FIND_DATAW data;
    HANDLE hFind = FindFirstFileExW(path, FindExInfoStandard, &data, FindExSearchNameMatch,
                                    NULL, 0);
    if (hFind == INVALID_HANDLE_VALUE)
        return TRUE; // not found
 
    pch = wcsrchr(path, L'\\') + 1;
    cch = path_len - (pch - path);
    do
    {
        if (bDir != !!(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            continue;
        if (bDir && IS_DOTS(data.cFileName))
            continue; // ignore "." and ".."
        if (data.dwFileAttributes & FILE_ATTRIBUTE_VIRTUAL)
            continue; // ignore virtual
 
        StringCchCopyW(pch, cch, data.cFileName); // build full path
 
        ret = callback(pattern, path, &data);
        if (!ret) // out of memory
            break;
    } while (FindNextFileW(hFind, &data));
    FindClose(hFind);
    return ret;
}

Referenced by WhereSearchFiles(), and WhereSearchRecursive().

WhereSearchRecursive()

static BOOL WhereSearchRecursive ( LPCWSTR  pattern, LPCWSTR  dir  )

static

Definition at line 157 of file where.c.

{
    WCHAR szPath[MAX_PATH];
    if (!WhereSearchFiles(pattern, dir))
        return FALSE; // out of memory
 
    // build path with wildcard
    StringCchCopyW(szPath, _countof(szPath), dir);
    StringCchCatW(szPath, _countof(szPath), L"\\*");
    return WhereSearchGeneric(pattern, szPath, _countof(szPath), TRUE,
                              WhereSearchRecursiveCallback);
}

Referenced by WhereDoPattern(), and WhereSearchRecursiveCallback().

WhereSearchRecursiveCallback()

static BOOL CALLBACK WhereSearchRecursiveCallback ( LPCWSTR  pattern, LPCWSTR  path, PWIN32_FIND_DATAW  data  )

static

Definition at line 151 of file where.c.

{
    return WhereSearchRecursive(pattern, path);
}

Referenced by WhereSearchRecursive().

wmain()

INT wmain	(	INT	argc,
		WCHAR **	argv
	)

Definition at line 435 of file where.c.

{
    typedef BOOL (WINAPI *FN_DISABLE_WOW)(PVOID *);
    HANDLE hKernel32 = GetModuleHandleA("kernel32");
    FN_DISABLE_WOW DisableWOW =
        (FN_DISABLE_WOW)GetProcAddress(hKernel32, "Wow64DisableWow64FsRedirection");
    DWORD iPattern;
    WRET ret = WRET_ERROR;
    PVOID dummy;
 
    ConInitStdStreams(); // Initialize the Console Standard Streams
 
    if (!WhereParseCommandLine(argc, argv))
        goto quit;
 
    if ((s_dwFlags & FLAG_HELP) || !s_patterns.count)
    {
        ConResPuts(StdOut, IDS_USAGE);
        goto quit;
    }
 
    if (DisableWOW)
        DisableWOW(&dummy);
 
    if (!WhereGetPathExt(&s_pathext))
    {
        WhereError(IDS_OUTOFMEMORY);
        goto quit;
    }
 
    ret = WRET_SUCCESS;
    for (iPattern = 0; iPattern < s_patterns.count; ++iPattern)
    {
        if (!WhereDoPattern(strlist_get_at(&s_patterns, iPattern)))
        {
            ret = WRET_ERROR;
            goto quit;
        }
    }
 
    if (!s_results.count)
    {
        WhereError(IDS_NOT_FOUND);
        ret = WRET_NOT_FOUND;
    }
 
quit:
    strlist_destroy(&s_results);
    strlist_destroy(&s_patterns);
    strlist_destroy(&s_pathext);
    return ret;
}

Variable Documentation

s_dwFlags

DWORD s_dwFlags = 0

static

Definition at line 23 of file where.c.

Referenced by WhereDoOption(), WhereDoPattern(), WhereError(), WhereGetVariable(), WherePrintPath(), and wmain().

s_pathext

strlist_t s_pathext = strlist_default

static

Definition at line 27 of file where.c.

Referenced by WhereSearchFiles(), and wmain().

s_patterns

strlist_t s_patterns = strlist_default

static

Definition at line 25 of file where.c.

Referenced by WhereParseCommandLine(), and wmain().

s_pszRecursiveDir

LPWSTR s_pszRecursiveDir = NULL

static

Definition at line 24 of file where.c.

Referenced by WhereDoPattern(), and WhereParseCommandLine().

s_results

strlist_t s_results = strlist_default

static

Definition at line 26 of file where.c.

Referenced by WherePrintPath(), and wmain().