react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Common/EnumDirItems.cpp

@@ -3,13 +3,6 @@
 #include "StdAfx.h"
 
 #include <wchar.h>
-// #include <stdio.h>
-
-#ifndef _WIN32
-#include <grp.h>
-#include <pwd.h>
-#include "../../../Common/UTFConvert.h"
-#endif
 
 #include "../../../Common/Wildcard.h"
 
@@ -18,7 +11,7 @@
 #include "../../../Windows/FileName.h"
 
 #if defined(_WIN32) && !defined(UNDER_CE)
-#define Z7_USE_SECURITY_CODE
+#define _USE_SECURITY_CODE
 #include "../../../Windows/SecurityUtils.h"
 #endif
 
@@ -29,60 +22,32 @@ using namespace NWindows;
 using namespace NFile;
 using namespace NName;
 
-
-static bool FindFile_KeepDots(NFile::NFind::CFileInfo &fi, const FString &path, bool followLink)
-{
-  const bool res = fi.Find(path, followLink);
-  if (!res)
-    return res;
-  if (path.IsEmpty())
-    return res;
-  // we keep name "." and "..", if it's without tail slash
-  const FChar *p = path.RightPtr(1);
-  if (*p != '.')
-    return res;
-  if (p != path.Ptr())
-  {
-    FChar c = p[-1];
-    if (!IS_PATH_SEPAR(c))
-    {
-      if (c != '.')
-        return res;
-      p--;
-      if (p != path.Ptr())
-      {
-        c = p[-1];
-        if (!IS_PATH_SEPAR(c))
-          return res;
-      }
-    }
-  }
-  fi.Name = p;
-  return res;
-}
-
-
 void CDirItems::AddDirFileInfo(int phyParent, int logParent, int secureIndex,
     const NFind::CFileInfo &fi)
 {
-  /*
-  CDirItem di(fi);
+  CDirItem di;
+  di.Size = fi.Size;
+  di.CTime = fi.CTime;
+  di.ATime = fi.ATime;
+  di.MTime = fi.MTime;
+  di.Attrib = fi.Attrib;
+  di.IsAltStream = fi.IsAltStream;
   di.PhyParent = phyParent;
   di.LogParent = logParent;
   di.SecureIndex = secureIndex;
+  di.Name = fs2us(fi.Name);
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  // di.ShortName = fs2us(fi.ShortName);
+  #endif
   Items.Add(di);
-  */
-  VECTOR_ADD_NEW_OBJECT (Items, CDirItem(fi, phyParent, logParent, secureIndex))
   
   if (fi.IsDir())
     Stat.NumDirs++;
- #ifdef _WIN32
   else if (fi.IsAltStream)
   {
     Stat.NumAltStreams++;
     Stat.AltStreamsSize += fi.Size;
   }
- #endif
   else
   {
     Stat.NumFiles++;
@@ -90,13 +55,8 @@ void CDirItems::AddDirFileInfo(int phyParent, int logParent, int secureIndex,
   }
 }
 
-// (DWORD)E_FAIL
-#define DI_DEFAULT_ERROR  ERROR_INVALID_FUNCTION
-
 HRESULT CDirItems::AddError(const FString &path, DWORD errorCode)
 {
-  if (errorCode == 0)
-    errorCode = DI_DEFAULT_ERROR;
   Stat.NumErrors++;
   if (Callback)
     return Callback->ScanError(path, errorCode);
@@ -123,17 +83,17 @@ UString CDirItems::GetPrefixesPath(const CIntVector &parents, int index, const U
   unsigned len = name.Len();
   
   int i;
-  for (i = index; i >= 0; i = parents[(unsigned)i])
-    len += Prefixes[(unsigned)i].Len();
+  for (i = index; i >= 0; i = parents[i])
+    len += Prefixes[i].Len();
   
   wchar_t *p = path.GetBuf_SetEnd(len) + len;
   
   p -= name.Len();
   wmemcpy(p, (const wchar_t *)name, name.Len());
   
-  for (i = index; i >= 0; i = parents[(unsigned)i])
+  for (i = index; i >= 0; i = parents[i])
   {
-    const UString &s = Prefixes[(unsigned)i];
+    const UString &s = Prefixes[i];
     p -= s.Len();
     wmemcpy(p, (const wchar_t *)s, s.Len());
   }
@@ -180,24 +140,17 @@ bool InitLocalPrivileges();
 CDirItems::CDirItems():
     SymLinks(false),
     ScanAltStreams(false)
-    , ExcludeDirItems(false)
-    , ExcludeFileItems(false)
-    , ShareForWrite(false)
-   #ifdef Z7_USE_SECURITY_CODE
+    #ifdef _USE_SECURITY_CODE
     , ReadSecure(false)
-   #endif
-   #ifndef _WIN32
-    , StoreOwnerName(false)
-   #endif
+    #endif
     , Callback(NULL)
 {
-  #ifdef Z7_USE_SECURITY_CODE
+  #ifdef _USE_SECURITY_CODE
   _saclEnabled = InitLocalPrivileges();
   #endif
 }
 
-
-#ifdef Z7_USE_SECURITY_CODE
+#ifdef _USE_SECURITY_CODE
 
 HRESULT CDirItems::AddSecurityItem(const FString &path, int &secureIndex)
 {
@@ -213,7 +166,7 @@ HRESULT CDirItems::AddSecurityItem(const FString &path, int &secureIndex)
   DWORD errorCode = 0;
   DWORD secureSize;
   
-  BOOL res = ::GetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(void *)(Byte *)TempSecureBuf, (DWORD)TempSecureBuf.Size(), &secureSize);
+  BOOL res = ::GetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(Byte *)TempSecureBuf, (DWORD)TempSecureBuf.Size(), &secureSize);
   
   if (res)
   {
@@ -232,11 +185,11 @@ HRESULT CDirItems::AddSecurityItem(const FString &path, int &secureIndex)
       else
       {
         TempSecureBuf.Alloc(secureSize);
-        res = ::GetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(void *)(Byte *)TempSecureBuf, (DWORD)TempSecureBuf.Size(), &secureSize);
+        res = ::GetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(Byte *)TempSecureBuf, (DWORD)TempSecureBuf.Size(), &secureSize);
         if (res)
         {
           if (secureSize != TempSecureBuf.Size())
-            errorCode = ERROR_INVALID_FUNCTION;
+            errorCode = ERROR_INVALID_FUNCTION;;
         }
         else
           errorCode = GetLastError();
@@ -246,222 +199,104 @@ HRESULT CDirItems::AddSecurityItem(const FString &path, int &secureIndex)
   
   if (res)
   {
-    secureIndex = (int)SecureBlocks.AddUniq(TempSecureBuf, secureSize);
+    secureIndex = SecureBlocks.AddUniq(TempSecureBuf, secureSize);
     return S_OK;
   }
   
+  if (errorCode == 0)
+    errorCode = ERROR_INVALID_FUNCTION;
   return AddError(path, errorCode);
 }
 
-#endif // Z7_USE_SECURITY_CODE
-
+#endif
 
-HRESULT CDirItems::EnumerateOneDir(const FString &phyPrefix, CObjectVector<NFind::CFileInfo> &files)
+HRESULT CDirItems::EnumerateDir(int phyParent, int logParent, const FString &phyPrefix)
 {
-  NFind::CEnumerator enumerator;
-  // printf("\n  enumerator.SetDirPrefix(phyPrefix) \n");
+  RINOK(ScanProgress(phyPrefix));
 
+  NFind::CEnumerator enumerator;
   enumerator.SetDirPrefix(phyPrefix);
-
-  #ifdef _WIN32
-
-  NFind::CFileInfo fi;
-
   for (unsigned ttt = 0; ; ttt++)
   {
+    NFind::CFileInfo fi;
     bool found;
     if (!enumerator.Next(fi, found))
-      return AddError(phyPrefix);
-    if (!found)
-      return S_OK;
-    files.Add(fi);
-    if (Callback && (ttt & kScanProgressStepMask) == kScanProgressStepMask)
     {
-      RINOK(ScanProgress(phyPrefix))
-    }
-  }
-
-  #else // _WIN32
-
-  // enumerator.SolveLinks = !SymLinks;
-  
-  CObjectVector<NFind::CDirEntry> entries;
-
-  for (;;)
-  {
-    bool found;
-    NFind::CDirEntry de;
-    if (!enumerator.Next(de, found))
       return AddError(phyPrefix);
-    if (!found)
-      break;
-    entries.Add(de);
-  }
-
-  FOR_VECTOR(i, entries)
-  {
-    const NFind::CDirEntry &de = entries[i];
-    NFind::CFileInfo fi;
-    if (!enumerator.Fill_FileInfo(de, fi, !SymLinks))
-    // if (!fi.Find_AfterEnumerator(path))
-    {
-      const FString path = phyPrefix + de.Name;
-      {
-        RINOK(AddError(path))
-        continue;
-      }
     }
+    if (!found)
+      return S_OK;
 
-    files.Add(fi);
-
-    if (Callback && (i & kScanProgressStepMask) == kScanProgressStepMask)
-    {
-      RINOK(ScanProgress(phyPrefix))
-    }
-  }
-
-  return S_OK;
-
-  #endif // _WIN32
-}
-
-
-
-
-HRESULT CDirItems::EnumerateDir(int phyParent, int logParent, const FString &phyPrefix)
-{
-  RINOK(ScanProgress(phyPrefix))
-
-  CObjectVector<NFind::CFileInfo> files;
-  RINOK(EnumerateOneDir(phyPrefix, files))
-
-  FOR_VECTOR (i, files)
-  {
-    #ifdef _WIN32
-    const NFind::CFileInfo &fi = files[i];
-    #else
-    const NFind::CFileInfo &fi = files[i];
-    /*
-    NFind::CFileInfo fi;
-    {
-      const NFind::CDirEntry &di = files[i];
-      const FString path = phyPrefix + di.Name;
-      if (!fi.Find_AfterEnumerator(path))
-      {
-        RINOK(AddError(path));
-        continue;
-      }
-      fi.Name = di.Name;
-    }
-    */
-    #endif
-
-    if (CanIncludeItem(fi.IsDir()))
-    {
     int secureIndex = -1;
-    #ifdef Z7_USE_SECURITY_CODE
+    #ifdef _USE_SECURITY_CODE
     if (ReadSecure)
     {
-      RINOK(AddSecurityItem(phyPrefix + fi.Name, secureIndex))
+      RINOK(AddSecurityItem(phyPrefix + fi.Name, secureIndex));
     }
     #endif
+    
     AddDirFileInfo(phyParent, logParent, secureIndex, fi);
-    }
     
-    if (Callback && (i & kScanProgressStepMask) == kScanProgressStepMask)
+    if (Callback && (ttt & kScanProgressStepMask) == kScanProgressStepMask)
     {
-      RINOK(ScanProgress(phyPrefix))
+      RINOK(ScanProgress(phyPrefix));
     }
 
     if (fi.IsDir())
     {
       const FString name2 = fi.Name + FCHAR_PATH_SEPARATOR;
       unsigned parent = AddPrefix(phyParent, logParent, fs2us(name2));
-      RINOK(EnumerateDir((int)parent, (int)parent, phyPrefix + name2))
+      RINOK(EnumerateDir(parent, parent, phyPrefix + name2));
     }
   }
-  return S_OK;
 }
 
-
-/*
-EnumerateItems2()
-  const FStringVector &filePaths - are path without tail slashes.
-  All dir prefixes of filePaths will be not stores in logical paths
-fix it: we can scan AltStream also.
-*/
-
-#ifdef _WIN32
-// #define FOLLOW_LINK_PARAM
-// #define FOLLOW_LINK_PARAM2
-#define FOLLOW_LINK_PARAM , (!SymLinks)
-#define FOLLOW_LINK_PARAM2 , (!dirItems.SymLinks)
-#else
-#define FOLLOW_LINK_PARAM , (!SymLinks)
-#define FOLLOW_LINK_PARAM2 , (!dirItems.SymLinks)
-#endif
-
 HRESULT CDirItems::EnumerateItems2(
     const FString &phyPrefix,
     const UString &logPrefix,
     const FStringVector &filePaths,
     FStringVector *requestedPaths)
 {
-  const int phyParent = phyPrefix.IsEmpty() ? -1 : (int)AddPrefix(-1, -1, fs2us(phyPrefix));
-  const int logParent = logPrefix.IsEmpty() ? -1 : (int)AddPrefix(-1, -1, logPrefix);
-
- #ifdef _WIN32
-  const bool phyPrefix_isAltStreamPrefix =
-      NFile::NName::IsAltStreamPrefixWithColon(fs2us(phyPrefix));
- #endif
+  int phyParent = phyPrefix.IsEmpty() ? -1 : AddPrefix(-1, -1, fs2us(phyPrefix));
+  int logParent = logPrefix.IsEmpty() ? -1 : AddPrefix(-1, -1, logPrefix);
 
   FOR_VECTOR (i, filePaths)
   {
     const FString &filePath = filePaths[i];
     NFind::CFileInfo fi;
     const FString phyPath = phyPrefix + filePath;
-    if (!FindFile_KeepDots(fi, phyPath  FOLLOW_LINK_PARAM))
+    if (!fi.Find(phyPath))
     {
-      RINOK(AddError(phyPath))
+      RINOK(AddError(phyPath));
       continue;
     }
     if (requestedPaths)
       requestedPaths->Add(phyPath);
 
-    const int delimiter = filePath.ReverseFind_PathSepar();
+    int delimiter = filePath.ReverseFind_PathSepar();
     FString phyPrefixCur;
     int phyParentCur = phyParent;
     if (delimiter >= 0)
     {
-      phyPrefixCur.SetFrom(filePath, (unsigned)(delimiter + 1));
-      phyParentCur = (int)AddPrefix(phyParent, logParent, fs2us(phyPrefixCur));
+      phyPrefixCur.SetFrom(filePath, delimiter + 1);
+      phyParentCur = AddPrefix(phyParent, logParent, fs2us(phyPrefixCur));
     }
 
-    if (CanIncludeItem(fi.IsDir()))
-    {
     int secureIndex = -1;
-    #ifdef Z7_USE_SECURITY_CODE
+    #ifdef _USE_SECURITY_CODE
     if (ReadSecure)
     {
-      RINOK(AddSecurityItem(phyPath, secureIndex))
+      RINOK(AddSecurityItem(phyPath, secureIndex));
     }
     #endif
-   #ifdef _WIN32
-    if (phyPrefix_isAltStreamPrefix && fi.IsAltStream)
-    {
-      const int pos = fi.Name.Find(FChar(':'));
-      if (pos >= 0)
-        fi.Name.DeleteFrontal((unsigned)pos + 1);
-    }
-   #endif
+
     AddDirFileInfo(phyParentCur, logParent, secureIndex, fi);
-    }
     
     if (fi.IsDir())
     {
       const FString name2 = fi.Name + FCHAR_PATH_SEPARATOR;
-      const unsigned parent = AddPrefix(phyParentCur, logParent, fs2us(name2));
-      RINOK(EnumerateDir((int)parent, (int)parent, phyPrefix + phyPrefixCur + name2))
+      unsigned parent = AddPrefix(phyParentCur, logParent, fs2us(name2));
+      RINOK(EnumerateDir(parent, parent, phyPrefix + phyPrefixCur + name2));
     }
   }
   
@@ -472,46 +307,34 @@ HRESULT CDirItems::EnumerateItems2(
 
 
 
+
+
 static HRESULT EnumerateDirItems(
     const NWildcard::CCensorNode &curNode,
-    const int phyParent, const int logParent,
-    const FString &phyPrefix,
-    const UStringVector &addParts, // additional parts from curNode
+    int phyParent, int logParent, const FString &phyPrefix,
+    const UStringVector &addArchivePrefix,
     CDirItems &dirItems,
     bool enterToSubFolders);
 
-
-/* EnumerateDirItems_Spec()
-   adds new Dir item prefix, and enumerates dir items,
-   then it can remove that Dir item prefix, if there are no items in that dir.
-*/
-
-
-/*
-  EnumerateDirItems_Spec()
-  it's similar to EnumerateDirItems, but phyPrefix doesn't include (curFolderName)
-*/
-
 static HRESULT EnumerateDirItems_Spec(
     const NWildcard::CCensorNode &curNode,
-    const int phyParent, const int logParent, const FString &curFolderName,
-    const FString &phyPrefix,      // without (curFolderName)
-    const UStringVector &addParts, // (curNode + addParts) includes (curFolderName)
+    int phyParent, int logParent, const FString &curFolderName,
+    const FString &phyPrefix,
+    const UStringVector &addArchivePrefix,
     CDirItems &dirItems,
     bool enterToSubFolders)
 {
   const FString name2 = curFolderName + FCHAR_PATH_SEPARATOR;
-  const unsigned parent = dirItems.AddPrefix(phyParent, logParent, fs2us(name2));
-  const unsigned numItems = dirItems.Items.Size();
+  unsigned parent = dirItems.AddPrefix(phyParent, logParent, fs2us(name2));
+  unsigned numItems = dirItems.Items.Size();
   HRESULT res = EnumerateDirItems(
-      curNode, (int)parent, (int)parent, phyPrefix + name2,
-      addParts, dirItems, enterToSubFolders);
+      curNode, parent, parent, phyPrefix + name2,
+      addArchivePrefix, dirItems, enterToSubFolders);
   if (numItems == dirItems.Items.Size())
     dirItems.DeleteLastPrefix();
   return res;
 }
 
-
 #ifndef UNDER_CE
 
 #ifdef _WIN32
@@ -519,222 +342,159 @@ static HRESULT EnumerateDirItems_Spec(
 static HRESULT EnumerateAltStreams(
     const NFind::CFileInfo &fi,
     const NWildcard::CCensorNode &curNode,
-    const int phyParent, const int logParent,
-    const FString &phyPath,         // with (fi.Name), without tail slash for folders
-    const UStringVector &addParts,  // with (fi.Name), prefix parts from curNode
-    bool addAllSubStreams,
+    int phyParent, int logParent, const FString &fullPath,
+    const UStringVector &addArchivePrefix,  // prefix from curNode
+    bool addAllItems,
     CDirItems &dirItems)
 {
-  // we don't use (ExcludeFileItems) rules for AltStreams
-  // if (dirItems.ExcludeFileItems) return S_OK;
-
-  NFind::CStreamEnumerator enumerator(phyPath);
+  NFind::CStreamEnumerator enumerator(fullPath);
   for (;;)
   {
     NFind::CStreamInfo si;
     bool found;
     if (!enumerator.Next(si, found))
     {
-      return dirItems.AddError(phyPath + FTEXT(":*")); // , (DWORD)E_FAIL
+      return dirItems.AddError(fullPath + FTEXT(":*")); // , (DWORD)E_FAIL
     }
     if (!found)
       return S_OK;
     if (si.IsMainStream())
       continue;
-    UStringVector parts = addParts;
-    const UString reducedName = si.GetReducedName();
-    parts.Back() += reducedName;
-    if (curNode.CheckPathToRoot(false, parts, true))
+    UStringVector addArchivePrefixNew = addArchivePrefix;
+    UString reducedName = si.GetReducedName();
+    addArchivePrefixNew.Back() += reducedName;
+    if (curNode.CheckPathToRoot(false, addArchivePrefixNew, true))
       continue;
-    if (!addAllSubStreams)
-      if (!curNode.CheckPathToRoot(true, parts, true))
+    if (!addAllItems)
+      if (!curNode.CheckPathToRoot(true, addArchivePrefixNew, true))
         continue;
 
     NFind::CFileInfo fi2 = fi;
     fi2.Name += us2fs(reducedName);
     fi2.Size = si.Size;
-    fi2.Attrib &= ~(DWORD)(FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
+    fi2.Attrib &= ~FILE_ATTRIBUTE_DIRECTORY;
     fi2.IsAltStream = true;
     dirItems.AddDirFileInfo(phyParent, logParent, -1, fi2);
   }
 }
 
-#endif // _WIN32
-
-
-/* We get Reparse data and parse it.
-   If there is Reparse error, we free dirItem.Reparse data.
-   Do we need to work with empty reparse data?
-*/
+#endif
 
 HRESULT CDirItems::SetLinkInfo(CDirItem &dirItem, const NFind::CFileInfo &fi,
     const FString &phyPrefix)
 {
-  if (!SymLinks)
+  if (!SymLinks || !fi.HasReparsePoint())
     return S_OK;
-
-  #ifdef _WIN32
-    if (!fi.HasReparsePoint() || fi.IsAltStream)
-  #else // _WIN32
-    if (!fi.IsPosixLink())
-  #endif // _WIN32
-      return S_OK;
-
   const FString path = phyPrefix + fi.Name;
   CByteBuffer &buf = dirItem.ReparseData;
+  DWORD res = 0;
   if (NIO::GetReparseData(path, buf))
   {
-    // if (dirItem.ReparseData.Size() != 0)
-    Stat.FilesSize -= fi.Size;
-    return S_OK;
+    CReparseAttr attr;
+    if (attr.Parse(buf, buf.Size(), res))
+      return S_OK;
+    // we ignore unknown reparse points
+    if (res != ERROR_INVALID_REPARSE_DATA)
+      res = 0;
+  }
+  else
+  {
+    res = ::GetLastError();
+    if (res == 0)
+      res = ERROR_INVALID_FUNCTION;
   }
 
-  DWORD res = ::GetLastError();
   buf.Free();
+  if (res == 0)
+    return S_OK;
   return AddError(path, res);
 }
 
-#endif // UNDER_CE
-
-
+#endif
 
 static HRESULT EnumerateForItem(
-    const NFind::CFileInfo &fi,
+    NFind::CFileInfo &fi,
     const NWildcard::CCensorNode &curNode,
-    const int phyParent, const int logParent, const FString &phyPrefix,
-    const UStringVector &addParts, // additional parts from curNode, without (fi.Name)
+    int phyParent, int logParent, const FString &phyPrefix,
+    const UStringVector &addArchivePrefix,  // prefix from curNode
     CDirItems &dirItems,
     bool enterToSubFolders)
 {
   const UString name = fs2us(fi.Name);
-  UStringVector newParts = addParts;
-  newParts.Add(name);
-  
-  // check the path in exclude rules
-  if (curNode.CheckPathToRoot(false, newParts, !fi.IsDir()))
-    return S_OK;
-
-  #if !defined(UNDER_CE)
+  bool enterToSubFolders2 = enterToSubFolders;
+  UStringVector addArchivePrefixNew = addArchivePrefix;
+  addArchivePrefixNew.Add(name);
+  {
+    UStringVector addArchivePrefixNewTemp(addArchivePrefixNew);
+    if (curNode.CheckPathToRoot(false, addArchivePrefixNewTemp, !fi.IsDir()))
+      return S_OK;
+  }
   int dirItemIndex = -1;
-  #if defined(_WIN32)
+  
   bool addAllSubStreams = false;
-  bool needAltStreams = true;
-  #endif // _WIN32
-  #endif // !defined(UNDER_CE)
 
-  // check the path in inlcude rules
-  if (curNode.CheckPathToRoot(true, newParts, !fi.IsDir()))
+  if (curNode.CheckPathToRoot(true, addArchivePrefixNew, !fi.IsDir()))
   {
-    #if !defined(UNDER_CE)
-    // dirItemIndex = (int)dirItems.Items.Size();
-    #if defined(_WIN32)
-    // we will not check include rules for substreams.
-    addAllSubStreams = true;
-    #endif // _WIN32
-    #endif // !defined(UNDER_CE)
-
-    if (dirItems.CanIncludeItem(fi.IsDir()))
-    {
-      int secureIndex = -1;
-    #ifdef Z7_USE_SECURITY_CODE
-      if (dirItems.ReadSecure)
-      {
-        RINOK(dirItems.AddSecurityItem(phyPrefix + fi.Name, secureIndex))
-      }
-    #endif
-    #if !defined(UNDER_CE)
-      dirItemIndex = (int)dirItems.Items.Size();
-    #endif // !defined(UNDER_CE)
-      dirItems.AddDirFileInfo(phyParent, logParent, secureIndex, fi);
-    }
-    else
+    int secureIndex = -1;
+    #ifdef _USE_SECURITY_CODE
+    if (dirItems.ReadSecure)
     {
-      #if defined(_WIN32) && !defined(UNDER_CE)
-        needAltStreams = false;
-      #endif
+      RINOK(dirItems.AddSecurityItem(phyPrefix + fi.Name, secureIndex));
     }
+    #endif
     
+    dirItemIndex = dirItems.Items.Size();
+    dirItems.AddDirFileInfo(phyParent, logParent, secureIndex, fi);
     if (fi.IsDir())
-      enterToSubFolders = true;
+      enterToSubFolders2 = true;
+
+    addAllSubStreams = true;
   }
 
-  #if !defined(UNDER_CE)
-  
-  // we don't scan AltStreams for link files
+  #ifndef UNDER_CE
+  if (dirItems.ScanAltStreams)
+  {
+    RINOK(EnumerateAltStreams(fi, curNode, phyParent, logParent,
+        phyPrefix + fi.Name,
+        addArchivePrefixNew,
+        addAllSubStreams,
+        dirItems));
+  }
 
   if (dirItemIndex >= 0)
   {
-    CDirItem &dirItem = dirItems.Items[(unsigned)dirItemIndex];
-    RINOK(dirItems.SetLinkInfo(dirItem, fi, phyPrefix))
+    CDirItem &dirItem = dirItems.Items[dirItemIndex];
+    RINOK(dirItems.SetLinkInfo(dirItem, fi, phyPrefix));
     if (dirItem.ReparseData.Size() != 0)
       return S_OK;
   }
-  
-  #if defined(_WIN32)
-  if (needAltStreams && dirItems.ScanAltStreams && !fi.IsAltStream)
-  {
-    RINOK(EnumerateAltStreams(fi, curNode, phyParent, logParent,
-        phyPrefix + fi.Name,    // with (fi.Name)
-        newParts,               // with (fi.Name)
-        addAllSubStreams,
-        dirItems))
-  }
-  #endif
-
-  #endif // !defined(UNDER_CE)
-
-
-  #ifndef _WIN32
-  if (!fi.IsPosixLink()) // posix link can follow to dir
   #endif
+  
   if (!fi.IsDir())
     return S_OK;
-
-  const NWildcard::CCensorNode *nextNode = NULL;
-
-  if (addParts.IsEmpty())
+  
+  const NWildcard::CCensorNode *nextNode = 0;
+  if (addArchivePrefix.IsEmpty())
   {
     int index = curNode.FindSubNode(name);
     if (index >= 0)
-    {
-      nextNode = &curNode.SubNodes[(unsigned)index];
-      newParts.Clear();
-    }
+      nextNode = &curNode.SubNodes[index];
   }
-
-  if (!nextNode)
+  if (!enterToSubFolders2 && nextNode == 0)
+    return S_OK;
+  
+  addArchivePrefixNew = addArchivePrefix;
+  if (nextNode == 0)
   {
-    if (!enterToSubFolders)
-      return S_OK;
-
-   #ifndef _WIN32
-    if (fi.IsPosixLink())
-    {
-      // here we can try to resolve posix link
-      // if the link to dir, then can we follow it
-      return S_OK; // we don't follow posix link
-    }
-   #else
-    if (dirItems.SymLinks && fi.HasReparsePoint())
-    {
-      /* 20.03: in SymLinks mode: we don't enter to directory that
-         has reparse point and has no CCensorNode
-         NOTE: (curNode and parent nodes) still can have wildcard rules
-         to include some items of target directory (of reparse point),
-         but we ignore these rules here.
-      */
-      return S_OK;
-    }
-   #endif
     nextNode = &curNode;
+    addArchivePrefixNew.Add(name);
   }
   
   return EnumerateDirItems_Spec(
-      *nextNode, phyParent, logParent, fi.Name,
-      phyPrefix,   // without (fi.Name)
-      newParts,    // relative to (*nextNode). (*nextNode + newParts) includes (fi.Name)
+      *nextNode, phyParent, logParent, fi.Name, phyPrefix,
+      addArchivePrefixNew,
       dirItems,
-      enterToSubFolders);
+      enterToSubFolders2);
 }
 
 
@@ -753,13 +513,10 @@ static bool CanUseFsDirect(const NWildcard::CCensorNode &curNode)
     
     /* Windows doesn't support file name with wildcard
        But if another system supports file name with wildcard,
-       and wildcard mode is disabled, we can ignore wildcard in name
-    */
+       and wildcard mode is disabled, we can ignore wildcard in name */
     /*
-    #ifndef _WIN32
     if (!item.WildcardParsing)
       continue;
-    #endif
     */
     if (DoesNameContainWildcard(name))
       return false;
@@ -775,33 +532,26 @@ static bool IsVirtualFsFolder(const FString &prefix, const UString &name)
   UString s = fs2us(prefix);
   s += name;
   s.Add_PathSepar();
-  // it returns (true) for non real FS folder path like - "\\SERVER\"
   return IsPathSepar(s[0]) && GetRootPrefixSize(s) == 0;
 }
 
 #endif
 
-
-
 static HRESULT EnumerateDirItems(
     const NWildcard::CCensorNode &curNode,
-    const int phyParent, const int logParent, const FString &phyPrefix,
-    const UStringVector &addParts,  // prefix from curNode including
+    int phyParent, int logParent, const FString &phyPrefix,
+    const UStringVector &addArchivePrefix,  // prefix from curNode
     CDirItems &dirItems,
     bool enterToSubFolders)
 {
   if (!enterToSubFolders)
-  {
-    /* if there are IncludeItems censor rules that affect items in subdirs,
-       then we will enter to all subfolders */
     if (curNode.NeedCheckSubDirs())
       enterToSubFolders = true;
-  }
   
-  RINOK(dirItems.ScanProgress(phyPrefix))
+  RINOK(dirItems.ScanProgress(phyPrefix));
 
   // try direct_names case at first
-  if (addParts.IsEmpty() && !enterToSubFolders)
+  if (addArchivePrefix.IsEmpty() && !enterToSubFolders)
   {
     if (CanUseFsDirect(curNode))
     {
@@ -816,20 +566,11 @@ static HRESULT EnumerateDirItems(
         const UString &name = item.PathParts.Front();
         FString fullPath = phyPrefix + us2fs(name);
 
-        /*
-        // not possible now
-        if (!item.ForDir && !item.ForFile)
-        {
-          RINOK(dirItems.AddError(fullPath, ERROR_INVALID_PARAMETER));
-          continue;
-        }
-        */
-
         #if defined(_WIN32) && !defined(UNDER_CE)
         bool needAltStreams = true;
         #endif
 
-        #ifdef Z7_USE_SECURITY_CODE
+        #ifdef _USE_SECURITY_CODE
         bool needSecurity = true;
         #endif
         
@@ -849,7 +590,7 @@ static HRESULT EnumerateDirItems(
 
               /*
               // do we need to ignore security info for "\\" folder ?
-              #ifdef Z7_USE_SECURITY_CODE
+              #ifdef _USE_SECURITY_CODE
               needSecurity = false;
               #endif
               */
@@ -875,27 +616,16 @@ static HRESULT EnumerateDirItems(
         }
         else
         #endif
-        if (!FindFile_KeepDots(fi, fullPath  FOLLOW_LINK_PARAM2))
+        if (!fi.Find(fullPath))
         {
-          RINOK(dirItems.AddError(fullPath))
+          RINOK(dirItems.AddError(fullPath));
           continue;
         }
 
-        /*
-        #ifdef _WIN32
-          #define MY_ERROR_IS_DIR     ERROR_FILE_NOT_FOUND
-          #define MY_ERROR_NOT_DIR    DI_DEFAULT_ERROR
-        #else
-          #define MY_ERROR_IS_DIR     EISDIR
-          #define MY_ERROR_NOT_DIR    ENOTDIR
-        #endif
-        */
-
-        const bool isDir = fi.IsDir();
-        if (isDir ? !item.ForDir : !item.ForFile)
+        bool isDir = fi.IsDir();
+        if (isDir && !item.ForDir || !isDir && !item.ForFile)
         {
-          // RINOK(dirItems.AddError(fullPath, isDir ? MY_ERROR_IS_DIR: MY_ERROR_NOT_DIR));
-          RINOK(dirItems.AddError(fullPath, DI_DEFAULT_ERROR))
+          RINOK(dirItems.AddError(fullPath, (DWORD)E_FAIL));
           continue;
         }
         {
@@ -905,90 +635,67 @@ static HRESULT EnumerateDirItems(
             continue;
         }
         
-
-       if (dirItems.CanIncludeItem(fi.IsDir()))
-       {
         int secureIndex = -1;
-        #ifdef Z7_USE_SECURITY_CODE
+        #ifdef _USE_SECURITY_CODE
         if (needSecurity && dirItems.ReadSecure)
         {
-          RINOK(dirItems.AddSecurityItem(fullPath, secureIndex))
+          RINOK(dirItems.AddSecurityItem(fullPath, secureIndex));
         }
         #endif
 
         dirItems.AddDirFileInfo(phyParent, logParent, secureIndex, fi);
 
-        // we don't scan AltStreams for link files
-
-        #if !defined(UNDER_CE)
+        #ifndef UNDER_CE
         {
           CDirItem &dirItem = dirItems.Items.Back();
-          RINOK(dirItems.SetLinkInfo(dirItem, fi, phyPrefix))
+          RINOK(dirItems.SetLinkInfo(dirItem, fi, phyPrefix));
           if (dirItem.ReparseData.Size() != 0)
+          {
+            if (fi.IsAltStream)
+              dirItems.Stat.AltStreamsSize -= fi.Size;
+            else
+              dirItems.Stat.FilesSize -= fi.Size;
             continue;
+          }
         }
-        
-        #if defined(_WIN32)
-        if (needAltStreams && dirItems.ScanAltStreams && !fi.IsAltStream)
+        #endif
+
+
+        #ifndef UNDER_CE
+        if (needAltStreams && dirItems.ScanAltStreams)
         {
           UStringVector pathParts;
           pathParts.Add(fs2us(fi.Name));
           RINOK(EnumerateAltStreams(fi, curNode, phyParent, logParent,
-              fullPath,  // including (name)
-              pathParts, // including (fi.Name)
+              fullPath, pathParts,
               true, /* addAllSubStreams */
-              dirItems))
+              dirItems));
         }
-        #endif // defined(_WIN32)
-
-        #endif // !defined(UNDER_CE)
-       }
-
-
-        #ifndef _WIN32
-        if (!fi.IsPosixLink()) // posix link can follow to dir
         #endif
+
         if (!isDir)
           continue;
-
-        UStringVector newParts;
-        const NWildcard::CCensorNode *nextNode = NULL;
+        
+        UStringVector addArchivePrefixNew;
+        const NWildcard::CCensorNode *nextNode = 0;
         int index = curNode.FindSubNode(name);
         if (index >= 0)
         {
-          for (int t = (int)needEnterVector.Size(); t <= index; t++)
+          for (int t = needEnterVector.Size(); t <= index; t++)
             needEnterVector.Add(true);
-          needEnterVector[(unsigned)index] = false;
-          nextNode = &curNode.SubNodes[(unsigned)index];
+          needEnterVector[index] = false;
+          nextNode = &curNode.SubNodes[index];
         }
         else
         {
-         #ifndef _WIN32
-          if (fi.IsPosixLink())
-          {
-            // here we can try to resolve posix link
-            // if the link to dir, then can we follow it
-            continue; // we don't follow posix link
-          }
-         #else
-          if (dirItems.SymLinks)
-          {
-            if (fi.HasReparsePoint())
-            {
-              /* 20.03: in SymLinks mode: we don't enter to directory that
-              has reparse point and has no CCensorNode */
-              continue;
-            }
-          }
-         #endif
           nextNode = &curNode;
-          newParts.Add(name); // don't change it to fi.Name. It's for shortnames support
+          addArchivePrefixNew.Add(name); // don't change it to fi.Name. It's for shortnames support
         }
 
         RINOK(EnumerateDirItems_Spec(*nextNode, phyParent, logParent, fi.Name, phyPrefix,
-            newParts, dirItems, true))
+            addArchivePrefixNew, dirItems, true));
       }
-
+      
       for (i = 0; i < curNode.SubNodes.Size(); i++)
       {
         if (i < needEnterVector.Size())
@@ -998,23 +705,20 @@ static HRESULT EnumerateDirItems(
         FString fullPath = phyPrefix + us2fs(nextNode.Name);
         NFind::CFileInfo fi;
         
-        if (nextNode.Name.IsEmpty())
-        {
-          if (phyPrefix.IsEmpty())
-            fullPath = CHAR_PATH_SEPARATOR;
-        }
-      #ifdef _WIN32
-        else if(phyPrefix.IsEmpty()
-            || (phyPrefix.Len() == NName::kSuperPathPrefixSize
-                && IsSuperPath(phyPrefix)))
+        if (phyPrefix.IsEmpty())
         {
-          if (NWildcard::IsDriveColonName(nextNode.Name))
-            fullPath.Add_PathSepar();
+          {
+            if (nextNode.Name.IsEmpty())
+              fullPath = CHAR_PATH_SEPARATOR;
+            #ifdef _WIN32
+            else if (NWildcard::IsDriveColonName(nextNode.Name))
+              fullPath.Add_PathSepar();
+            #endif
+          }
         }
-      #endif
 
         // we don't want to call fi.Find() for root folder or virtual folder
-        if ((phyPrefix.IsEmpty() && nextNode.Name.IsEmpty())
+        if (phyPrefix.IsEmpty() && nextNode.Name.IsEmpty()
             #if defined(_WIN32) && !defined(UNDER_CE)
             || IsVirtualFsFolder(phyPrefix, nextNode.Name)
             #endif
@@ -1025,23 +729,23 @@ static HRESULT EnumerateDirItems(
         }
         else
         {
-          if (!FindFile_KeepDots(fi, fullPath  FOLLOW_LINK_PARAM2))
+          if (!fi.Find(fullPath))
           {
             if (!nextNode.AreThereIncludeItems())
               continue;
-            RINOK(dirItems.AddError(fullPath))
+            RINOK(dirItems.AddError(fullPath));
             continue;
           }
         
           if (!fi.IsDir())
           {
-            RINOK(dirItems.AddError(fullPath, DI_DEFAULT_ERROR))
+            RINOK(dirItems.AddError(fullPath, (DWORD)E_FAIL));
             continue;
           }
         }
 
         RINOK(EnumerateDirItems_Spec(nextNode, phyParent, logParent, fi.Name, phyPrefix,
-            UStringVector(), dirItems, false))
+            UStringVector(), dirItems, false));
       }
 
       return S_OK;
@@ -1087,7 +791,7 @@ static HRESULT EnumerateDirItems(
         fi.Name = driveName;
 
         RINOK(EnumerateForItem(fi, curNode, phyParent, logParent, phyPrefix,
-            addParts, dirItems, enterToSubFolders))
+            addArchivePrefix, dirItems, enterToSubFolders));
       }
       return S_OK;
     }
@@ -1096,81 +800,43 @@ static HRESULT EnumerateDirItems(
   #endif
   #endif
 
+  NFind::CEnumerator enumerator;
+  enumerator.SetDirPrefix(phyPrefix);
 
-  CObjectVector<NFind::CFileInfo> files;
-  
-  // for (int y = 0; y < 1; y++)
-  {
-    // files.Clear();
-    RINOK(dirItems.EnumerateOneDir(phyPrefix, files))
-  /*
-  FOR_VECTOR (i, files)
+  for (unsigned ttt = 0; ; ttt++)
   {
-    #ifdef _WIN32
-    // const NFind::CFileInfo &fi = files[i];
-    #else
-    NFind::CFileInfo &fi = files[i];
+    NFind::CFileInfo fi;
+    bool found;
+    if (!enumerator.Next(fi, found))
     {
-      const NFind::CFileInfo &di = files[i];
-      const FString path = phyPrefix + di.Name;
-      if (!fi.Find_AfterEnumerator(path))
-      {
-        RINOK(dirItems.AddError(path));
-        continue;
-      }
-      fi.Name = di.Name;
+      RINOK(dirItems.AddError(phyPrefix));
+      break;
     }
-    #endif
-
-  }
-  */
-  }
+    if (!found)
+      break;
 
-  FOR_VECTOR (i, files)
-  {
-    #ifdef _WIN32
-    const NFind::CFileInfo &fi = files[i];
-    #else
-    const NFind::CFileInfo &fi = files[i];
-    /*
-    NFind::CFileInfo fi;
+    if (dirItems.Callback && (ttt & kScanProgressStepMask) == kScanProgressStepMask)
     {
-      const NFind::CDirEntry &di = files[i];
-      const FString path = phyPrefix + di.Name;
-      if (!fi.Find_AfterEnumerator(path))
-      {
-        RINOK(dirItems.AddError(path));
-        continue;
-      }
-      fi.Name = di.Name;
+      RINOK(dirItems.ScanProgress(phyPrefix));
     }
-    */
-    #endif
 
     RINOK(EnumerateForItem(fi, curNode, phyParent, logParent, phyPrefix,
-          addParts, dirItems, enterToSubFolders))
-    if (dirItems.Callback && (i & kScanProgressStepMask) == kScanProgressStepMask)
-    {
-      RINOK(dirItems.ScanProgress(phyPrefix))
-    }
+          addArchivePrefix, dirItems, enterToSubFolders));
   }
 
   return S_OK;
 }
 
-
-
-
 HRESULT EnumerateItems(
     const NWildcard::CCensor &censor,
     const NWildcard::ECensorPathMode pathMode,
-    const UString &addPathPrefix, // prefix that will be added to Logical Path
+    const UString &addPathPrefix,
     CDirItems &dirItems)
 {
   FOR_VECTOR (i, censor.Pairs)
   {
     const NWildcard::CPair &pair = censor.Pairs[i];
-    const int phyParent = pair.Prefix.IsEmpty() ? -1 : (int)dirItems.AddPrefix(-1, -1, pair.Prefix);
+    int phyParent = pair.Prefix.IsEmpty() ? -1 : dirItems.AddPrefix(-1, -1, pair.Prefix);
     int logParent = -1;
     
     if (pathMode == NWildcard::k_AbsPath)
@@ -1178,94 +844,45 @@ HRESULT EnumerateItems(
     else
     {
       if (!addPathPrefix.IsEmpty())
-        logParent = (int)dirItems.AddPrefix(-1, -1, addPathPrefix);
+        logParent = dirItems.AddPrefix(-1, -1, addPathPrefix);
     }
     
     RINOK(EnumerateDirItems(pair.Head, phyParent, logParent, us2fs(pair.Prefix), UStringVector(),
         dirItems,
         false // enterToSubFolders
-        ))
+        ));
   }
   dirItems.ReserveDown();
 
- #if defined(_WIN32) && !defined(UNDER_CE)
-  RINOK(dirItems.FillFixedReparse())
- #endif
-
- #ifndef _WIN32
-  RINOK(dirItems.FillDeviceSizes())
- #endif
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  dirItems.FillFixedReparse();
+  #endif
 
   return S_OK;
 }
 
-
 #if defined(_WIN32) && !defined(UNDER_CE)
 
-HRESULT CDirItems::FillFixedReparse()
+void CDirItems::FillFixedReparse()
 {
+  /* imagex/WIM reduces absolute pathes in links (raparse data),
+     if we archive non root folder. We do same thing here */
+
+  if (!SymLinks)
+    return;
+  
   FOR_VECTOR(i, Items)
   {
     CDirItem &item = Items[i];
-
-    if (!SymLinks)
-    {
-      // continue; // for debug
-      if (!item.Has_Attrib_ReparsePoint())
-        continue;
-      /*
-      We want to get properties of target file instead of properies of symbolic link.
-      Probably this code is unused, because
-      CFileInfo::Find(with followLink = true) called Fill_From_ByHandleFileInfo() already.
-      */
-      // if (item.IsDir()) continue;
-      const FString phyPath = GetPhyPath(i);
-      NFind::CFileInfo fi;
-      if (fi.Fill_From_ByHandleFileInfo(phyPath)) // item.IsDir()
-      {
-        item.Size = fi.Size;
-        item.CTime = fi.CTime;
-        item.ATime = fi.ATime;
-        item.MTime = fi.MTime;
-        item.Attrib = fi.Attrib;
-        continue;
-      }
-      RINOK(AddError(phyPath))
-      continue;
-    }
-
-    // (SymLinks == true)
     if (item.ReparseData.Size() == 0)
       continue;
-    // if (item.Size == 0)
-    {
-      // 20.03: we use Reparse Data instead of real data
-      item.Size = item.ReparseData.Size();
-    }
     
     CReparseAttr attr;
-    if (!attr.Parse(item.ReparseData, item.ReparseData.Size()))
-    {
-      const FString phyPath = GetPhyPath(i);
-      AddError(phyPath, attr.ErrorCode);
+    DWORD errorCode = 0;
+    if (!attr.Parse(item.ReparseData, item.ReparseData.Size(), errorCode))
       continue;
-    }
-
-    /* imagex/WIM reduces absolute paths in links (raparse data),
-       if we archive non root folder. We do same thing here */
-
-    // bool isWSL = false;
-    if (attr.IsSymLink_WSL())
-    {
-      // isWSL = true;
-      // we don't change WSL symlinks
+    if (attr.IsRelative())
       continue;
-    }
-    else
-    {
-      if (attr.IsRelative_Win())
-        continue;
-    }
 
     const UString &link = attr.GetPath();
     if (!IsDrivePath(link))
@@ -1275,7 +892,7 @@ HRESULT CDirItems::FillFixedReparse()
     FString fullPathF;
     if (!NDir::MyGetFullPathName(GetPhyPath(i), fullPathF))
       continue;
-    const UString fullPath = fs2us(fullPathF);
+    UString fullPath = fs2us(fullPathF);
     const UString logPath = GetLogPath(i);
     if (logPath.Len() >= fullPath.Len())
       continue;
@@ -1286,177 +903,26 @@ HRESULT CDirItems::FillFixedReparse()
     if (!IsPathSepar(prefix.Back()))
       continue;
 
-    const unsigned rootPrefixSize = GetRootPrefixSize(prefix);
+    unsigned rootPrefixSize = GetRootPrefixSize(prefix);
     if (rootPrefixSize == 0)
       continue;
     if (rootPrefixSize == prefix.Len())
       continue; // simple case: paths are from root
+
     if (link.Len() <= prefix.Len())
       continue;
+
     if (CompareFileNames(link.Left(prefix.Len()), prefix) != 0)
       continue;
 
     UString newLink = prefix.Left(rootPrefixSize);
     newLink += link.Ptr(prefix.Len());
 
-    CByteBuffer &data = item.ReparseData2;
-/*
-    if (isWSL)
-    {
-      Convert_WinPath_to_WslLinuxPath(newLink, true); // is absolute : change it
-      FillLinkData_WslLink(data, newLink);
-    }
-    else
-*/
-      FillLinkData_WinLink(data, newLink, !attr.IsMountPoint());
-    if (data.Size() == 0)
+    CByteBuffer data;
+    if (!FillLinkData(data, newLink, attr.IsSymLink()))
       continue;
-    // item.ReparseData2 = data;
+    item.ReparseData2 = data;
   }
-  return S_OK;
-}
-
-#endif
-
-
-#ifndef _WIN32
-
-HRESULT CDirItems::FillDeviceSizes()
-{
-  {
-    FOR_VECTOR (i, Items)
-    {
-      CDirItem &item = Items[i];
-      
-      if (S_ISBLK(item.mode) && item.Size == 0)
-      {
-        const FString phyPath = GetPhyPath(i);
-        NIO::CInFile inFile;
-        inFile.PreserveATime = true;
-        if (inFile.OpenShared(phyPath, ShareForWrite)) // fixme: OpenShared ??
-        {
-          UInt64 size = 0;
-          if (inFile.GetLength(size))
-            item.Size = size;
-        }
-      }
-      if (StoreOwnerName)
-      {
-        OwnerNameMap.Add_UInt32(item.uid);
-        OwnerGroupMap.Add_UInt32(item.gid);
-      }
-    }
-  }
-
-  if (StoreOwnerName)
-  {
-    UString u;
-    AString a;
-    {
-      FOR_VECTOR (i, OwnerNameMap.Numbers)
-      {
-        // 200K/sec speed
-        u.Empty();
-        const passwd *pw = getpwuid(OwnerNameMap.Numbers[i]);
-        // printf("\ngetpwuid=%s\n", pw->pw_name);
-        if (pw)
-        {
-          a = pw->pw_name;
-          ConvertUTF8ToUnicode(a, u);
-        }
-        OwnerNameMap.Strings.Add(u);
-      }
-    }
-    {
-      FOR_VECTOR (i, OwnerGroupMap.Numbers)
-      {
-        u.Empty();
-        const group *gr = getgrgid(OwnerGroupMap.Numbers[i]);
-        if (gr)
-        {
-          // printf("\ngetgrgid %d %s\n", OwnerGroupMap.Numbers[i], gr->gr_name);
-          a = gr->gr_name;
-          ConvertUTF8ToUnicode(a, u);
-        }
-        OwnerGroupMap.Strings.Add(u);
-      }
-    }
-    
-    FOR_VECTOR (i, Items)
-    {
-      CDirItem &item = Items[i];
-      {
-        const int index = OwnerNameMap.Find(item.uid);
-        if (index < 0) throw 1;
-        item.OwnerNameIndex = index;
-      }
-      {
-        const int index = OwnerGroupMap.Find(item.gid);
-        if (index < 0) throw 1;
-        item.OwnerGroupIndex = index;
-      }
-    }
-  }
-      
-
-  // if (NeedOwnerNames)
-  {
-    /*
-    {
-      for (unsigned i = 0 ; i < 10000; i++)
-      {
-        const passwd *pw = getpwuid(i);
-        if (pw)
-        {
-          UString u;
-          ConvertUTF8ToUnicode(AString(pw->pw_name), u);
-          OwnerNameMap.Add(i, u);
-          OwnerNameMap.Add(i, u);
-          OwnerNameMap.Add(i, u);
-        }
-        const group *gr = getgrgid(i);
-        if (gr)
-        {
-          // we can use utf-8 here.
-          UString u;
-          ConvertUTF8ToUnicode(AString(gr->gr_name), u);
-          OwnerGroupMap.Add(i, u);
-        }
-      }
-    }
-    */
-    /*
-    {
-      FOR_VECTOR (i, OwnerNameMap.Strings)
-      {
-        AString s;
-        ConvertUnicodeToUTF8(OwnerNameMap.Strings[i], s);
-        printf("\n%5d %s", (unsigned)OwnerNameMap.Numbers[i], s.Ptr());
-      }
-    }
-    {
-      printf("\n\n=========Groups\n");
-      FOR_VECTOR (i, OwnerGroupMap.Strings)
-      {
-        AString s;
-        ConvertUnicodeToUTF8(OwnerGroupMap.Strings[i], s);
-        printf("\n%5d %s", (unsigned)OwnerGroupMap.Numbers[i], s.Ptr());
-      }
-    }
-    */
-  }
-      /*
-      for (unsigned i = 0 ; i < 100000000; i++)
-      {
-        // const passwd *pw = getpwuid(1000);
-        // pw = pw;
-        int pos = OwnerNameMap.Find(1000);
-        if (pos < 0 - (int)i)
-          throw 1;
-      }
-      */
-
-  return S_OK;
 }
 
 #endif
@@ -1482,7 +948,7 @@ HRESULT EnumerateDirItemsAndSort(
     {
       HRESULT res = EnumerateItems(censor, censorPathMode, addPathPrefix, dirItems);
       st = dirItems.Stat;
-      RINOK(res)
+      RINOK(res);
     }
   
     FOR_VECTOR (i, dirItems.Items)
@@ -1532,18 +998,11 @@ HRESULT EnumerateDirItemsAndSort(
 
 #ifdef _WIN32
 
-static bool IsDotsName(const wchar_t *s)
-{
-  return s[0] == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0));
-}
-
 // This code converts all short file names to long file names.
 
 static void ConvertToLongName(const UString &prefix, UString &name)
 {
-  if (name.IsEmpty()
-      || DoesNameContainWildcard(name)
-      || IsDotsName(name))
+  if (name.IsEmpty() || DoesNameContainWildcard(name))
     return;
   NFind::CFileInfo fi;
   const FString path (us2fs(prefix + name));