pattern.c

 
#include <winpr/config.h>
 
#include <winpr/crt.h>
#include <winpr/handle.h>
 
#include <winpr/file.h>
 
#ifdef WINPR_HAVE_UNISTD_H
#include <unistd.h>
#endif
 
#ifdef WINPR_HAVE_FCNTL_H
#include <fcntl.h>
#endif
 
#include "../log.h"
#define TAG WINPR_TAG("file")
 
LPSTR FilePatternFindNextWildcardA(LPCSTR lpPattern, DWORD* pFlags)
{
  LPSTR lpWildcard = NULL;
  *pFlags = 0;
  lpWildcard = strpbrk(lpPattern, "*?~");
 
  if (lpWildcard)
  {
    if (*lpWildcard == '*')
    {
      *pFlags = WILDCARD_STAR;
      return lpWildcard;
    }
    else if (*lpWildcard == '?')
    {
      *pFlags = WILDCARD_QM;
      return lpWildcard;
    }
    else if (*lpWildcard == '~')
    {
      if (lpWildcard[1] == '*')
      {
        *pFlags = WILDCARD_DOS_STAR;
        return lpWildcard;
      }
      else if (lpWildcard[1] == '?')
      {
        *pFlags = WILDCARD_DOS_QM;
        return lpWildcard;
      }
      else if (lpWildcard[1] == '.')
      {
        *pFlags = WILDCARD_DOS_DOT;
        return lpWildcard;
      }
    }
  }
 
  return NULL;
}
 
static BOOL FilePatternMatchSubExpressionA(LPCSTR lpFileName, size_t cchFileName, LPCSTR lpX,
                                           size_t cchX, LPCSTR lpY, size_t cchY, LPCSTR lpWildcard,
                                           LPCSTR* ppMatchEnd)
{
  LPCSTR lpMatch = NULL;
 
  if (!lpFileName)
    return FALSE;
 
  if (*lpWildcard == '*')
  {
    /*
     *                            S
     *                         <-----<
     *                      X  |     |  e       Y
     * X * Y ==        (0)----->-(1)->-----(2)-----(3)
     */
 
    /*
     * State 0: match 'X'
     */
    if (_strnicmp(lpFileName, lpX, cchX) != 0)
      return FALSE;
 
    /*
     * State 1: match 'S' or 'e'
     *
     * We use 'e' to transition to state 2
     */
 
    if (cchY != 0)
    {
      /* TODO: case insensitive character search */
      lpMatch = strchr(&lpFileName[cchX], *lpY);
 
      if (!lpMatch)
        return FALSE;
 
      if (_strnicmp(lpMatch, lpY, cchY) != 0)
        return FALSE;
    }
    else
    {
      lpMatch = &lpFileName[cchFileName];
    }
 
    *ppMatchEnd = &lpMatch[cchY];
    return TRUE;
  }
  else if (*lpWildcard == '?')
  {
    /*
     * State 0: match 'X'
     */
    if (cchFileName < cchX)
      return FALSE;
 
    if (_strnicmp(lpFileName, lpX, cchX) != 0)
      return FALSE;
 
    /*
     * State 1: match 'S'
     */
 
    if (cchY != 0)
    {
      /* TODO: case insensitive character search */
      lpMatch = strchr(&lpFileName[cchX + 1], *lpY);
 
      if (!lpMatch)
        return FALSE;
 
      if (_strnicmp(lpMatch, lpY, cchY) != 0)
        return FALSE;
    }
    else
    {
      if ((cchX + 1) > cchFileName)
        return FALSE;
 
      lpMatch = &lpFileName[cchX + 1];
    }
 
    *ppMatchEnd = &lpMatch[cchY];
    return TRUE;
  }
  else if (*lpWildcard == '~')
  {
    WLog_ERR(TAG, "warning: unimplemented '~' pattern match");
    return TRUE;
  }
 
  return FALSE;
}
 
BOOL FilePatternMatchA(LPCSTR lpFileName, LPCSTR lpPattern)
{
  BOOL match = 0;
  LPCSTR lpTail = NULL;
  size_t cchTail = 0;
  size_t cchPattern = 0;
  size_t cchFileName = 0;
  DWORD dwFlags = 0;
  DWORD dwNextFlags = 0;
  LPSTR lpWildcard = NULL;
  LPSTR lpNextWildcard = NULL;
 
  if (!lpPattern)
    return FALSE;
 
  if (!lpFileName)
    return FALSE;
 
  cchPattern = strlen(lpPattern);
  cchFileName = strlen(lpFileName);
 
  if ((lpPattern[0] == '*') && (cchPattern == 1))
    return TRUE;
 
  if (lpPattern[0] == '*')
  {
    lpTail = &lpPattern[1];
    cchTail = strlen(lpTail);
 
    if (!FilePatternFindNextWildcardA(lpTail, &dwFlags))
    {
      /* tail contains no wildcards */
      if (cchFileName < cchTail)
        return FALSE;
 
      if (_stricmp(&lpFileName[cchFileName - cchTail], lpTail) == 0)
        return TRUE;
 
      return FALSE;
    }
  }
 
  lpWildcard = FilePatternFindNextWildcardA(lpPattern, &dwFlags);
 
  if (lpWildcard)
  {
    LPCSTR lpX = NULL;
    LPCSTR lpY = NULL;
    size_t cchX = 0;
    size_t cchY = 0;
    LPCSTR lpMatchEnd = NULL;
    LPCSTR lpSubPattern = NULL;
    size_t cchSubPattern = 0;
    LPCSTR lpSubFileName = NULL;
    size_t cchSubFileName = 0;
    size_t cchWildcard = 0;
    size_t cchNextWildcard = 0;
    cchSubPattern = cchPattern;
    lpSubPattern = lpPattern;
    cchSubFileName = cchFileName;
    lpSubFileName = lpFileName;
    cchWildcard = ((dwFlags & WILDCARD_DOS) ? 2 : 1);
    lpNextWildcard = FilePatternFindNextWildcardA(&lpWildcard[cchWildcard], &dwNextFlags);
 
    if (!lpNextWildcard)
    {
      lpX = lpSubPattern;
      cchX = (lpWildcard - lpSubPattern);
      lpY = &lpSubPattern[cchX + cchWildcard];
      cchY = (cchSubPattern - (lpY - lpSubPattern));
      match = FilePatternMatchSubExpressionA(lpSubFileName, cchSubFileName, lpX, cchX, lpY,
                                             cchY, lpWildcard, &lpMatchEnd);
      return match;
    }
    else
    {
      while (lpNextWildcard)
      {
        cchSubFileName = cchFileName - (lpSubFileName - lpFileName);
        cchNextWildcard = ((dwNextFlags & WILDCARD_DOS) ? 2 : 1);
        lpX = lpSubPattern;
        cchX = (lpWildcard - lpSubPattern);
        lpY = &lpSubPattern[cchX + cchWildcard];
        cchY = (lpNextWildcard - lpWildcard) - cchWildcard;
        match = FilePatternMatchSubExpressionA(lpSubFileName, cchSubFileName, lpX, cchX,
                                               lpY, cchY, lpWildcard, &lpMatchEnd);
 
        if (!match)
          return FALSE;
 
        lpSubFileName = lpMatchEnd;
        cchWildcard = cchNextWildcard;
        lpWildcard = lpNextWildcard;
        dwFlags = dwNextFlags;
        lpNextWildcard =
            FilePatternFindNextWildcardA(&lpWildcard[cchWildcard], &dwNextFlags);
      }
 
      return TRUE;
    }
  }
  else
  {
    /* no wildcard characters */
    if (_stricmp(lpFileName, lpPattern) == 0)
      return TRUE;
  }
 
  return FALSE;
}