BaseTools: Library hashing fix and optimization for --hash feature

[mirror_edk2.git] / FatPkg / EnhancedFatDxe / FileName.c

/** @file\r
  Functions for manipulating file names.\r
\r
Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "Fat.h"\r
\r
/**\r
\r
  This function checks whether the input FileName is a valid 8.3 short name.\r
  If the input FileName is a valid 8.3, the output is the 8.3 short name;\r
  otherwise, the output is the base tag of 8.3 short name.\r
\r
  @param  FileName              - The input unicode filename.\r
  @param  File8Dot3Name         - The output ascii 8.3 short name or base tag of 8.3 short name.\r
\r
  @retval TRUE                  - The input unicode filename is a valid 8.3 short name.\r
  @retval FALSE                 - The input unicode filename is not a valid 8.3 short name.\r
\r
**/\r
BOOLEAN\r
FatCheckIs8Dot3Name (\r
  IN  CHAR16    *FileName,\r
  OUT CHAR8     *File8Dot3Name\r
  )\r
{\r
  BOOLEAN PossibleShortName;\r
  CHAR16  *TempName;\r
  CHAR16  *ExtendName;\r
  CHAR16  *SeparateDot;\r
  UINTN   MainNameLen;\r
  UINTN   ExtendNameLen;\r
\r
  PossibleShortName = TRUE;\r
  SeparateDot       = NULL;\r
  SetMem (File8Dot3Name, FAT_NAME_LEN, ' ');\r
  for (TempName = FileName; *TempName != '\0'; TempName++) {\r
    if (*TempName == L'.') {\r
      SeparateDot = TempName;\r
    }\r
  }\r
\r
  if (SeparateDot == NULL) {\r
    //\r
    // Extended filename is not detected\r
    //\r
    MainNameLen   = TempName - FileName;\r
    ExtendName    = TempName;\r
    ExtendNameLen = 0;\r
  } else {\r
    //\r
    // Extended filename is detected\r
    //\r
    MainNameLen   = SeparateDot - FileName;\r
    ExtendName    = SeparateDot + 1;\r
    ExtendNameLen = TempName - ExtendName;\r
  }\r
  //\r
  // We scan the filename for the second time\r
  // to check if there exists any extra blanks and dots\r
  //\r
  while (--TempName >= FileName) {\r
    if ((*TempName == L'.' || *TempName == L' ') && (TempName != SeparateDot)) {\r
      //\r
      // There exist extra blanks and dots\r
      //\r
      PossibleShortName = FALSE;\r
    }\r
  }\r
\r
  if (MainNameLen == 0) {\r
    PossibleShortName = FALSE;\r
  }\r
\r
  if (MainNameLen > FAT_MAIN_NAME_LEN) {\r
    PossibleShortName = FALSE;\r
    MainNameLen       = FAT_MAIN_NAME_LEN;\r
  }\r
\r
  if (ExtendNameLen > FAT_EXTEND_NAME_LEN) {\r
    PossibleShortName = FALSE;\r
    ExtendNameLen     = FAT_EXTEND_NAME_LEN;\r
  }\r
\r
  if (FatStrToFat (FileName, MainNameLen, File8Dot3Name)) {\r
    PossibleShortName = FALSE;\r
  }\r
\r
  if (FatStrToFat (ExtendName, ExtendNameLen, File8Dot3Name + FAT_MAIN_NAME_LEN)) {\r
    PossibleShortName = FALSE;\r
  }\r
\r
  return PossibleShortName;\r
}\r
\r
/**\r
\r
  Trim the trailing blanks of fat name.\r
\r
  @param  Name                  - The Char8 string needs to be trimed.\r
  @param  Len                   - The length of the fat name.\r
\r
  The real length of the fat name after the trailing blanks are trimmed.\r
\r
**/\r
STATIC\r
UINTN\r
FatTrimAsciiTrailingBlanks (\r
  IN CHAR8        *Name,\r
  IN UINTN        Len\r
  )\r
{\r
  while (Len > 0 && Name[Len - 1] == ' ') {\r
    Len--;\r
  }\r
\r
  return Len;\r
}\r
\r
/**\r
\r
  Convert the ascii fat name to the unicode string and strip trailing spaces,\r
  and if necessary, convert the unicode string to lower case.\r
\r
  @param  FatName               - The Char8 string needs to be converted.\r
  @param  Len                   - The length of the fat name.\r
  @param  LowerCase             - Indicate whether to convert the string to lower case.\r
  @param  Str                   - The result of the convertion.\r
\r
**/\r
VOID\r
FatNameToStr (\r
  IN  CHAR8            *FatName,\r
  IN  UINTN            Len,\r
  IN  UINTN            LowerCase,\r
  OUT CHAR16           *Str\r
  )\r
{\r
  //\r
  // First, trim the trailing blanks\r
  //\r
  Len = FatTrimAsciiTrailingBlanks (FatName, Len);\r
  //\r
  // Convert fat string to unicode string\r
  //\r
  FatFatToStr (Len, FatName, Str);\r
\r
  //\r
  // If the name is to be lower cased, do it now\r
  //\r
  if (LowerCase != 0) {\r
    FatStrLwr (Str);\r
  }\r
}\r
\r
/**\r
\r
  This function generates 8Dot3 name from user specified name for a newly created file.\r
\r
  @param  Parent                - The parent directory.\r
  @param  DirEnt                - The directory entry whose 8Dot3Name needs to be generated.\r
\r
**/\r
VOID\r
FatCreate8Dot3Name (\r
  IN FAT_OFILE    *Parent,\r
  IN FAT_DIRENT   *DirEnt\r
  )\r
{\r
  CHAR8 *ShortName;\r
  CHAR8 *ShortNameChar;\r
  UINTN BaseTagLen;\r
  UINTN Index;\r
  UINTN Retry;\r
  UINT8 Segment;\r
  union {\r
    UINT32  Crc;\r
    struct HEX_DATA {\r
      UINT8 Segment : HASH_VALUE_TAG_LEN;\r
    } Hex[HASH_VALUE_TAG_LEN];\r
  } HashValue;\r
  //\r
  // Make sure the whole directory has been loaded\r
  //\r
  ASSERT (Parent->ODir->EndOfDir);\r
  ShortName = DirEnt->Entry.FileName;\r
\r
  //\r
  // Trim trailing blanks of 8.3 name\r
  //\r
  BaseTagLen = FatTrimAsciiTrailingBlanks (ShortName, FAT_MAIN_NAME_LEN);\r
  if (BaseTagLen > SPEC_BASE_TAG_LEN) {\r
    BaseTagLen = SPEC_BASE_TAG_LEN;\r
  }\r
  //\r
  // We first use the algorithm described by spec.\r
  //\r
  ShortNameChar     = ShortName + BaseTagLen;\r
  *ShortNameChar++  = '~';\r
  *ShortNameChar    = '1';\r
  Retry = 0;\r
  while (*FatShortNameHashSearch (Parent->ODir, ShortName) != NULL) {\r
    *ShortNameChar = (CHAR8)(*ShortNameChar + 1);\r
    if (++Retry == MAX_SPEC_RETRY) {\r
      //\r
      // We use new algorithm to generate 8.3 name\r
      //\r
      ASSERT (DirEnt->FileString != NULL);\r
      gBS->CalculateCrc32 (DirEnt->FileString, StrSize (DirEnt->FileString), &HashValue.Crc);\r
\r
      if (BaseTagLen > HASH_BASE_TAG_LEN) {\r
        BaseTagLen = HASH_BASE_TAG_LEN;\r
      }\r
\r
      ShortNameChar = ShortName + BaseTagLen;\r
      for (Index = 0; Index < HASH_VALUE_TAG_LEN; Index++) {\r
        Segment = HashValue.Hex[Index].Segment;\r
        if (Segment > 9) {\r
          *ShortNameChar++ = (CHAR8)(Segment - 10 + 'A');\r
        } else {\r
          *ShortNameChar++ = (CHAR8)(Segment + '0');\r
        }\r
      }\r
\r
      *ShortNameChar++  = '~';\r
      *ShortNameChar    = '1';\r
    }\r
  }\r
}\r
\r
/**\r
\r
  Check the string is lower case or upper case\r
  and it is used by fatname to dir entry count\r
\r
  @param Str                   - The string which needs to be checked.\r
  @param InCaseFlag            - The input case flag which is returned when the string is lower case.\r
\r
  @retval OutCaseFlag           - The output case flag.\r
\r
**/\r
STATIC\r
UINT8\r
FatCheckNameCase (\r
  IN CHAR16           *Str,\r
  IN UINT8            InCaseFlag\r
  )\r
{\r
  CHAR16  Buffer[FAT_MAIN_NAME_LEN + 1 + FAT_EXTEND_NAME_LEN + 1];\r
  UINT8   OutCaseFlag;\r
\r
  //\r
  // Assume the case of input string is mixed\r
  //\r
  OutCaseFlag = FAT_CASE_MIXED;\r
  //\r
  // Lower case a copy of the string, if it matches the\r
  // original then the string is lower case\r
  //\r
  StrCpyS (Buffer, ARRAY_SIZE (Buffer), Str);\r
  FatStrLwr (Buffer);\r
  if (StrCmp (Str, Buffer) == 0) {\r
    OutCaseFlag = InCaseFlag;\r
  }\r
  //\r
  // Upper case a copy of the string, if it matches the\r
  // original then the string is upper case\r
  //\r
  StrCpyS (Buffer, ARRAY_SIZE (Buffer), Str);\r
  FatStrUpr (Buffer);\r
  if (StrCmp (Str, Buffer) == 0) {\r
    OutCaseFlag = 0;\r
  }\r
\r
  return OutCaseFlag;\r
}\r
\r
/**\r
\r
  Set the caseflag value for the directory entry.\r
\r
  @param DirEnt                - The logical directory entry whose caseflag value is to be set.\r
\r
**/\r
VOID\r
FatSetCaseFlag (\r
  IN FAT_DIRENT   *DirEnt\r
  )\r
{\r
  CHAR16  LfnBuffer[FAT_MAIN_NAME_LEN + 1 + FAT_EXTEND_NAME_LEN + 1];\r
  CHAR16  *TempCharPtr;\r
  CHAR16  *ExtendName;\r
  CHAR16  *FileNameCharPtr;\r
  UINT8   CaseFlag;\r
\r
  ExtendName      = NULL;\r
  TempCharPtr     = LfnBuffer;\r
  FileNameCharPtr = DirEnt->FileString;\r
  ASSERT (StrSize (DirEnt->FileString) <= sizeof (LfnBuffer));\r
  while ((*TempCharPtr = *FileNameCharPtr) != 0) {\r
    if (*TempCharPtr == L'.') {\r
      ExtendName = TempCharPtr;\r
    }\r
\r
    TempCharPtr++;\r
    FileNameCharPtr++;\r
  }\r
\r
  CaseFlag = 0;\r
  if (ExtendName != NULL) {\r
    *ExtendName = 0;\r
    ExtendName++;\r
    CaseFlag = (UINT8)(CaseFlag | FatCheckNameCase (ExtendName, FAT_CASE_EXT_LOWER));\r
  }\r
\r
  CaseFlag = (UINT8)(CaseFlag | FatCheckNameCase (LfnBuffer, FAT_CASE_NAME_LOWER));\r
  if ((CaseFlag & FAT_CASE_MIXED) == 0) {\r
    //\r
    // We just need one directory entry to store this file name entry\r
    //\r
    DirEnt->Entry.CaseFlag = CaseFlag;\r
  } else {\r
    //\r
    // We need one extra directory entry to store the mixed case entry\r
    //\r
    DirEnt->Entry.CaseFlag = 0;\r
    DirEnt->EntryCount++;\r
  }\r
}\r
\r
/**\r
\r
  Convert the 8.3 ASCII fat name to cased Unicode string according to case flag.\r
\r
  @param  DirEnt                - The corresponding directory entry.\r
  @param  FileString            - The output Unicode file name.\r
  @param  FileStringMax           The max length of FileString.\r
\r
**/\r
VOID\r
FatGetFileNameViaCaseFlag (\r
  IN     FAT_DIRENT   *DirEnt,\r
  IN OUT CHAR16       *FileString,\r
  IN     UINTN        FileStringMax\r
  )\r
{\r
  UINT8   CaseFlag;\r
  CHAR8   *File8Dot3Name;\r
  CHAR16  TempExt[1 + FAT_EXTEND_NAME_LEN + 1];\r
  //\r
  // Store file extension like ".txt"\r
  //\r
  CaseFlag      = DirEnt->Entry.CaseFlag;\r
  File8Dot3Name = DirEnt->Entry.FileName;\r
\r
  FatNameToStr (File8Dot3Name, FAT_MAIN_NAME_LEN, CaseFlag & FAT_CASE_NAME_LOWER, FileString);\r
  FatNameToStr (File8Dot3Name + FAT_MAIN_NAME_LEN, FAT_EXTEND_NAME_LEN, CaseFlag & FAT_CASE_EXT_LOWER, &TempExt[1]);\r
  if (TempExt[1] != 0) {\r
    TempExt[0] = L'.';\r
    StrCatS (FileString, FileStringMax, TempExt);\r
  }\r
}\r
\r
/**\r
\r
  Get the Check sum for a short name.\r
\r
  @param  ShortNameString       - The short name for a file.\r
\r
  @retval Sum                   - UINT8 checksum.\r
\r
**/\r
UINT8\r
FatCheckSum (\r
  IN CHAR8  *ShortNameString\r
  )\r
{\r
  UINTN ShortNameLen;\r
  UINT8 Sum;\r
  Sum = 0;\r
  for (ShortNameLen = FAT_NAME_LEN; ShortNameLen != 0; ShortNameLen--) {\r
    Sum = (UINT8)((((Sum & 1) != 0) ? 0x80 : 0) + (Sum >> 1) + *ShortNameString++);\r
  }\r
\r
  return Sum;\r
}\r
\r
/**\r
\r
  Takes Path as input, returns the next name component\r
  in Name, and returns the position after Name (e.g., the\r
  start of the next name component)\r
\r
  @param  Path                  - The path of one file.\r
  @param  Name                  - The next name component in Path.\r
\r
  The position after Name in the Path\r
\r
**/\r
CHAR16 *\r
FatGetNextNameComponent (\r
  IN  CHAR16      *Path,\r
  OUT CHAR16      *Name\r
  )\r
{\r
  while (*Path != 0 && *Path != PATH_NAME_SEPARATOR) {\r
    *Name++ = *Path++;\r
  }\r
  *Name = 0;\r
  //\r
  // Get off of trailing path name separator\r
  //\r
  while (*Path == PATH_NAME_SEPARATOR) {\r
    Path++;\r
  }\r
\r
  return Path;\r
}\r
\r
/**\r
\r
  Check whether the IFileName is valid long file name. If the IFileName is a valid\r
  long file name, then we trim the possible leading blanks and leading/trailing dots.\r
  the trimmed filename is stored in OutputFileName\r
\r
  @param  InputFileName         - The input file name.\r
  @param  OutputFileName        - The output file name.\r
\r
  @retval TRUE                  - The InputFileName is a valid long file name.\r
  @retval FALSE                 - The InputFileName is not a valid long file name.\r
\r
**/\r
BOOLEAN\r
FatFileNameIsValid (\r
  IN  CHAR16  *InputFileName,\r
  OUT CHAR16  *OutputFileName\r
  )\r
{\r
  CHAR16  *TempNamePointer;\r
  CHAR16  TempChar;\r
  //\r
  // Trim Leading blanks\r
  //\r
  while (*InputFileName == L' ') {\r
    InputFileName++;\r
  }\r
\r
  TempNamePointer = OutputFileName;\r
  while (*InputFileName != 0) {\r
    *TempNamePointer++ = *InputFileName++;\r
  }\r
  //\r
  // Trim Trailing blanks and dots\r
  //\r
  while (TempNamePointer > OutputFileName) {\r
    TempChar = *(TempNamePointer - 1);\r
    if (TempChar != L' ' && TempChar != L'.') {\r
      break;\r
    }\r
\r
    TempNamePointer--;\r
  }\r
\r
  *TempNamePointer = 0;\r
\r
  //\r
  // Per FAT Spec the file name should meet the following criteria:\r
  //   C1. Length (FileLongName) <= 255\r
  //   C2. Length (X:FileFullPath<NUL>) <= 260\r
  // Here we check C1.\r
  //\r
  if (TempNamePointer - OutputFileName > EFI_FILE_STRING_LENGTH) {\r
    return FALSE;\r
  }\r
  //\r
  // See if there is any illegal characters within the name\r
  //\r
  do {\r
    if (*OutputFileName < 0x20 ||\r
        *OutputFileName == '\"' ||\r
        *OutputFileName == '*' ||\r
        *OutputFileName == '/' ||\r
        *OutputFileName == ':' ||\r
        *OutputFileName == '<' ||\r
        *OutputFileName == '>' ||\r
        *OutputFileName == '?' ||\r
        *OutputFileName == '\\' ||\r
        *OutputFileName == '|'\r
        ) {\r
      return FALSE;\r
    }\r
\r
    OutputFileName++;\r
  } while (*OutputFileName != 0);\r
  return TRUE;\r
}\r