11 files changed, 464 insertions, 150 deletions

diff --git a/CPP/Windows/FileDir.cpp b/CPP/Windows/FileDir.cpp
index 2cb83b2..10c4e98 100644
--- a/CPP/Windows/FileDir.cpp
+++ b/CPP/Windows/FileDir.cpp
@@ -651,6 +651,35 @@ bool RemoveDirWithSubItems(const FString &path)
   return RemoveDir(path);
 }
 
+bool RemoveDirAlways_if_Empty(const FString &path)
+{
+  const DWORD attrib = NFind::GetFileAttrib(path);
+  if (attrib != INVALID_FILE_ATTRIBUTES
+      && (attrib & FILE_ATTRIBUTE_READONLY))
+  {
+    bool need_ClearAttrib = true;
+    if ((attrib & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
+    {
+      FString s (path);
+      s.Add_PathSepar();
+      NFind::CEnumerator enumerator;
+      enumerator.SetDirPrefix(s);
+      NFind::CDirEntry fi;
+      if (enumerator.Next(fi))
+      {
+        // we don't want to change attributes, if there are files
+        // in directory, because RemoveDir(path) will fail.
+        need_ClearAttrib = false;
+        // SetLastError(ERROR_DIR_NOT_EMPTY);
+        // return false;
+      }
+    }
+    if (need_ClearAttrib)
+      SetFileAttrib(path, 0); // we clear read-only attrib to remove read-only dir
+  }
+  return RemoveDir(path);
+}
+
 #endif // _WIN32
 
 #ifdef UNDER_CE
diff --git a/CPP/Windows/FileDir.h b/CPP/Windows/FileDir.h
index 74675ee..65e6368 100644
--- a/CPP/Windows/FileDir.h
+++ b/CPP/Windows/FileDir.h
@@ -78,6 +78,11 @@ bool CreateComplexDir(CFSTR path);
 
 bool DeleteFileAlways(CFSTR name);
 bool RemoveDirWithSubItems(const FString &path);
+#ifdef _WIN32
+bool RemoveDirAlways_if_Empty(const FString &path);
+#else
+#define RemoveDirAlways_if_Empty RemoveDir
+#endif
 
 bool MyGetFullPathName(CFSTR path, FString &resFullPath);
 bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName);
diff --git a/CPP/Windows/FileFind.cpp b/CPP/Windows/FileFind.cpp
index ca387f6..64075ab 100644
--- a/CPP/Windows/FileFind.cpp
+++ b/CPP/Windows/FileFind.cpp
@@ -731,7 +731,7 @@ bool CFileInfo::Find(CFSTR path, bool followLink)
             bool isOK = false;
             if (finder.FindFirst(s, *this))
             {
-              if (Name == FTEXT("."))
+              if (Name.IsEqualTo("."))
               {
                 Name = path + prefixSize;
                 return true;
@@ -769,6 +769,13 @@ bool CFileInfo::Find(CFSTR path, bool followLink)
 
   // return FollowReparse(path, IsDir());
   return Fill_From_ByHandleFileInfo(path);
+/*
+  // Fill_From_ByHandleFileInfo returns false (with Access Denied error),
+  // if there is reparse link file (not directory reparse item).
+  if (Fill_From_ByHandleFileInfo(path))
+    return true;
+  return HasReparsePoint();
+*/
 }
 
 bool CFileInfoBase::Fill_From_ByHandleFileInfo(CFSTR path)
diff --git a/CPP/Windows/FileIO.h b/CPP/Windows/FileIO.h
index 6ba40eb..26edef4 100644
--- a/CPP/Windows/FileIO.h
+++ b/CPP/Windows/FileIO.h
@@ -11,8 +11,7 @@
 
 #define Z7_WIN_SYMLINK_FLAG_RELATIVE 1
 
-// what the meaning of that FLAG or field (2)?
-#define Z7_WIN_LX_SYMLINK_FLAG 2
+#define Z7_WIN_LX_SYMLINK_VERSION_2 2
 
 #ifdef _WIN32
 
@@ -44,7 +43,33 @@ namespace NWindows {
 namespace NFile {
 
 #if defined(_WIN32) && !defined(UNDER_CE)
-bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL);
+/*
+  in:  (CByteBuffer &dest) is empty
+  in:  (path) uses Windows path separator (\).
+  out: (path) uses   Linux path separator (/).
+       if (isAbsPath == true), then "c:\\" prefix is replaced to "/mnt/c/" prefix
+*/
+void Convert_WinPath_to_WslLinuxPath(FString &path, bool convertDrivePath);
+// (path) must use Linux path separator (/).
+void FillLinkData_WslLink(CByteBuffer &dest, const wchar_t *path);
+
+/*
+  in:  (CByteBuffer &dest) is empty
+  if (isSymLink == false) : MOUNT_POINT : (path) must be absolute.
+  if (isSymLink == true)  : SYMLINK : Windows
+  (path) must use Windows path separator (\).
+  (path) must be without link "\\??\\" prefix.
+  link "\\??\\" prefix will be added inside FillLinkData(), if path is absolute.
+*/
+void FillLinkData_WinLink(CByteBuffer &dest, const wchar_t *path, bool isSymLink);
+// in: (CByteBuffer &dest) is empty
+inline void FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL)
+{
+  if (isWSL)
+    FillLinkData_WslLink(dest, path);
+  else
+    FillLinkData_WinLink(dest, path, isSymLink);
+}
 #endif
 
 struct CReparseShortInfo
@@ -61,7 +86,6 @@ struct CReparseAttr
   UInt32 Flags;
   UString SubsName;
   UString PrintName;
-
   AString WslName;
 
   bool HeaderError;
@@ -71,8 +95,7 @@ struct CReparseAttr
 
   CReparseAttr(): Tag(0), Flags(0) {}
 
-  // Parse()
-  // returns (true) and (ErrorCode = 0), if (it'a correct known link)
+  // returns (true) and (ErrorCode = 0), if (it's correct known link)
   // returns (false) and (ErrorCode = ERROR_REPARSE_TAG_INVALID), if unknown tag
   bool Parse(const Byte *p, size_t size);
 
@@ -80,18 +103,14 @@ struct CReparseAttr
   bool IsSymLink_Win() const { return Tag == Z7_WIN_IO_REPARSE_TAG_SYMLINK; }
   bool IsSymLink_WSL() const { return Tag == Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK; }
 
+  // note: "/dir1/path" is marked as relative.
   bool IsRelative_Win() const { return Flags == Z7_WIN_SYMLINK_FLAG_RELATIVE; }
 
   bool IsRelative_WSL() const
   {
-    if (WslName.IsEmpty())
-      return true;
-    char c = WslName[0];
-    return !IS_PATH_SEPAR(c);
+    return WslName[0] != '/'; // WSL uses unix path separator
   }
 
-  // bool IsVolume() const;
-
   bool IsOkNamePair() const;
   UString GetPath() const;
 };
diff --git a/CPP/Windows/FileLink.cpp b/CPP/Windows/FileLink.cpp
index bb380ec..2883c82 100644
--- a/CPP/Windows/FileLink.cpp
+++ b/CPP/Windows/FileLink.cpp
@@ -39,12 +39,24 @@ namespace NFile {
 using namespace NName;
 
 /*
+Win10 Junctions/SymLinks:
+  - (/) slash doesn't work as path separator
+  - Win10 preinstalled junctions don't use tail backslash, but tail backslashes also work.
+  - double backslash works only after drive prefix "c:\\dir1\dir2\",
+    and doesn't work in another places.
+  - absolute path without \??\ prefix doesn't work
+  - absolute path "c:" doesn't work
+*/
+
+/*
   Reparse Points (Junctions and Symbolic Links):
   struct
   {
     UInt32 Tag;
     UInt16 Size;     // not including starting 8 bytes
-    UInt16 Reserved; // = 0
+    UInt16 Reserved; // = 0, DOCs: // Length, in bytes, of the unparsed portion of
+       // the file name pointed to by the FileName member of the associated file object.
+       // This member is only valid for create operations when the I/O fails with STATUS_REPARSE.
     
     UInt16 SubstituteOffset; // offset in bytes from  start of namesChars
     UInt16 SubstituteLen;    // size in bytes, it doesn't include tailed NUL
@@ -68,6 +80,16 @@ using namespace NName;
     2) Default Order in table:
          Print Path
          Substitute Path
+
+DOCS:
+  The print name SHOULD be an informative pathname, suitable for display
+  to a user, that also identifies the target of the mount point.
+  Neither of these pathnames can contain dot directory names.
+
+reparse tags, with the exception of IO_REPARSE_TAG_SYMLINK,
+are processed on the server and are not processed by a client
+after transmission over the wire.
+Clients SHOULD treat associated reparse data as opaque data.
 */
 
 /*
@@ -93,7 +115,8 @@ static const UInt32 kReparseFlags_Microsoft   = ((UInt32)1 << 31);
 #define Get16(p) GetUi16(p)
 #define Get32(p) GetUi32(p)
 
-static const wchar_t * const k_LinkPrefix = L"\\??\\";
+static const char * const k_LinkPrefix = "\\??\\";
+static const char * const k_LinkPrefix_UNC = "\\??\\UNC\\";
 static const unsigned k_LinkPrefix_Size = 4;
 
 static bool IsLinkPrefix(const wchar_t *s)
@@ -102,7 +125,7 @@ static bool IsLinkPrefix(const wchar_t *s)
 }
 
 /*
-static const wchar_t * const k_VolumePrefix = L"Volume{";
+static const char * const k_VolumePrefix = "Volume{";
 static const bool IsVolumeName(const wchar_t *s)
 {
   return IsString1PrefixedByString2(s, k_VolumePrefix);
@@ -118,7 +141,7 @@ static void WriteString(Byte *dest, const wchar_t *path)
 {
   for (;;)
   {
-    wchar_t c = *path++;
+    const wchar_t c = *path++;
     if (c == 0)
       return;
     Set16(dest, (UInt16)c)
@@ -126,62 +149,103 @@ static void WriteString(Byte *dest, const wchar_t *path)
   }
 }
 
-bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL)
+#ifdef _WIN32
+void Convert_WinPath_to_WslLinuxPath(FString &s, bool convertDrivePath)
 {
-  bool isAbs = IsAbsolutePath(path);
-  if (!isAbs && !isSymLink)
-    return false;
-
-  if (isWSL)
+  if (convertDrivePath && IsDrivePath(s))
   {
-    // unsupported characters probably use Replacement Character UTF-16 0xFFFD
-    AString utf;
-    ConvertUnicodeToUTF8(path, utf);
-    const size_t size = 4 + utf.Len();
-    if (size != (UInt16)size)
-      return false;
-    dest.Alloc(8 + size);
-    Byte *p = dest;
-    Set32(p, Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
-    Set16(p + 4, (UInt16)(size))
-    Set16(p + 6, 0)
-    Set32(p + 8, Z7_WIN_LX_SYMLINK_FLAG)
-    memcpy(p + 12, utf.Ptr(), utf.Len());
-    return true;
+    FChar c = s[0];
+    c = MyCharLower_Ascii(c);
+    s.DeleteFrontal(2);
+    s.InsertAtFront(c);
+    s.Insert(0, FTEXT("/mnt/"));
   }
+  s.Replace(FCHAR_PATH_SEPARATOR, FTEXT('/'));
+}
+#endif
 
-  // usual symbolic LINK (NOT WSL)
 
-  bool needPrintName = true;
+static const unsigned k_Link_Size_Limit = 1u << 16; // 16-bit field is used for size.
+
+void FillLinkData_WslLink(CByteBuffer &dest, const wchar_t *path)
+{
+  // dest.Free(); // it's empty already
+  // WSL probably uses Replacement Character UTF-16 0xFFFD for unsupported characters?
+  AString utf;
+  ConvertUnicodeToUTF8(path, utf);
+  const unsigned size = 4 + utf.Len();
+  if (size >= k_Link_Size_Limit)
+    return;
+  dest.Alloc(8 + size);
+  Byte *p = dest;
+  Set32(p, Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
+  // Set32(p + 4, (UInt32)size)
+  Set16(p + 4, (UInt16)size)
+  Set16(p + 6, 0)
+  Set32(p + 8, Z7_WIN_LX_SYMLINK_VERSION_2)
+  memcpy(p + 12, utf.Ptr(), utf.Len());
+}
+
 
-  if (IsSuperPath(path))
+void FillLinkData_WinLink(CByteBuffer &dest, const wchar_t *path, bool isSymLink)
+{
+  // dest.Free(); // it's empty already
+  bool isAbs = false;
+  if (IS_PATH_SEPAR(path[0]))
   {
-    path += kSuperPathPrefixSize;
-    if (!IsDrivePath(path))
-      needPrintName = false;
+    // root paths "\dir1\path" are marked as relative
+    if (IS_PATH_SEPAR(path[1]))
+      isAbs = true;
+  }
+  else
+    isAbs = IsAbsolutePath(path);
+  if (!isAbs && !isSymLink)
+  {
+    // Win10 allows us to create relative MOUNT_POINT.
+    // But relative MOUNT_POINT will not work when accessing it.
+    // So we prevent useless creation of a relative MOUNT_POINT.
+    return;
   }
 
-  const unsigned add_Prefix_Len = isAbs ? k_LinkPrefix_Size : 0;
-    
+  bool needPrintName = true;
+  UString subs (path);
+  if (isAbs)
+  {
+    const bool isSuperPath = IsSuperPath(path);
+    if (!isSuperPath && NName::IsNetworkPath(us2fs(path)))
+    {
+      subs = k_LinkPrefix_UNC;
+      subs += (path + 2);
+    }
+    else
+    {
+      if (isSuperPath)
+      {
+        // we remove super prefix:
+        path += kSuperPathPrefixSize;
+        // we want to get correct abolute path in PrintName still.
+        if (!IsDrivePath(path))
+          needPrintName = false; // we need "\\server\path" for print name.
+      }
+      subs = k_LinkPrefix;
+      subs += path;
+    }
+  }
+  const size_t len1 = subs.Len() * 2;
   size_t len2 = (size_t)MyStringLen(path) * 2;
-  const size_t len1 = len2 + add_Prefix_Len * 2;
   if (!needPrintName)
     len2 = 0;
-
-  size_t totalNamesSize = (len1 + len2);
-
+  size_t totalNamesSize = len1 + len2;
   /* some WIM imagex software uses old scheme for symbolic links.
-     so we can old scheme for byte to byte compatibility */
-
-  bool newOrderScheme = isSymLink;
+     so we can use old scheme for byte to byte compatibility */
+  const bool newOrderScheme = isSymLink;
   // newOrderScheme = false;
-
   if (!newOrderScheme)
-    totalNamesSize += 2 * 2;
+    totalNamesSize += 2 * 2; // we use NULL terminators in old scheme.
 
   const size_t size = 8 + 8 + (isSymLink ? 4 : 0) + totalNamesSize;
-  if (size != (UInt16)size)
-    return false;
+  if (size >= k_Link_Size_Limit)
+    return;
   dest.Alloc(size);
   memset(dest, 0, size);
   const UInt32 tag = isSymLink ?
@@ -189,6 +253,7 @@ bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool i
       Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT;
   Byte *p = dest;
   Set32(p, tag)
+  // Set32(p + 4, (UInt32)(size - 8))
   Set16(p + 4, (UInt16)(size - 8))
   Set16(p + 6, 0)
   p += 8;
@@ -204,21 +269,16 @@ bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool i
   Set16(p + 2, (UInt16)len1)
   Set16(p + 4, (UInt16)printOffs)
   Set16(p + 6, (UInt16)len2)
-
   p += 8;
   if (isSymLink)
   {
-    UInt32 flags = isAbs ? 0 : Z7_WIN_SYMLINK_FLAG_RELATIVE;
+    const UInt32 flags = isAbs ? 0 : Z7_WIN_SYMLINK_FLAG_RELATIVE;
     Set32(p, flags)
     p += 4;
   }
-
-  if (add_Prefix_Len != 0)
-    WriteString(p + subOffs, k_LinkPrefix);
-  WriteString(p + subOffs + add_Prefix_Len * 2, path);
+  WriteString(p + subOffs, subs);
   if (needPrintName)
     WriteString(p + printOffs, path);
-  return true;
 }
 
 #endif // defined(_WIN32) && !defined(UNDER_CE)
@@ -230,7 +290,7 @@ static void GetString(const Byte *p, unsigned len, UString &res)
   unsigned i;
   for (i = 0; i < len; i++)
   {
-    wchar_t c = Get16(p + i * 2);
+    const wchar_t c = Get16(p + (size_t)i * 2);
     if (c == 0)
       break;
     s[i] = c;
@@ -239,6 +299,7 @@ static void GetString(const Byte *p, unsigned len, UString &res)
   res.ReleaseBuf_SetLen(i);
 }
 
+
 bool CReparseAttr::Parse(const Byte *p, size_t size)
 {
   ErrorCode = (DWORD)ERROR_INVALID_REPARSE_DATA;
@@ -250,7 +311,12 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
     return false;
   Tag = Get32(p);
   if (Get16(p + 6) != 0) // padding
-    return false;
+  {
+    // DOCs: Reserved : the field SHOULD be set to 0
+    // and MUST be ignored (by parser).
+    // Win10 ignores it.
+    MinorError = true; // optional
+  }
   unsigned len = Get16(p + 4);
   p += 8;
   size -= 8;
@@ -262,8 +328,6 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
       (type & kReparseFlags_Microsoft) == 0 ||
       (type & 0xFFFF) != 3)
   */
-
-
   HeaderError = false;
 
   if (   Tag != Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT
@@ -282,8 +346,7 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
   {
     if (len < 4)
       return false;
-    Flags = Get32(p); // maybe it's not Flags
-    if (Flags != Z7_WIN_LX_SYMLINK_FLAG)
+    if (Get32(p) != Z7_WIN_LX_SYMLINK_VERSION_2)
       return false;
     len -= 4;
     p += 4;
@@ -291,12 +354,13 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
     unsigned i;
     for (i = 0; i < len; i++)
     {
-      char c = (char)p[i];
+      const char c = (char)p[i];
       s[i] = c;
       if (c == 0)
         break;
     }
-    WslName.ReleaseBuf_SetEnd(i);
+    s[i] = 0;
+    WslName.ReleaseBuf_SetLen(i);
     MinorError = (i != len);
     ErrorCode = 0;
     return true;
@@ -304,10 +368,10 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
   
   if (len < 8)
     return false;
-  unsigned subOffs = Get16(p);
-  unsigned subLen = Get16(p + 2);
-  unsigned printOffs = Get16(p + 4);
-  unsigned printLen = Get16(p + 6);
+  const unsigned subOffs = Get16(p);
+  const unsigned subLen = Get16(p + 2);
+  const unsigned printOffs = Get16(p + 4);
+  const unsigned printLen = Get16(p + 6);
   len -= 8;
   p += 8;
 
@@ -335,15 +399,17 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
 
 bool CReparseShortInfo::Parse(const Byte *p, size_t size)
 {
-  const Byte *start = p;
-  Offset= 0;
+  const Byte * const start = p;
+  Offset = 0;
   Size = 0;
   if (size < 8)
     return false;
-  UInt32 Tag = Get32(p);
+  const UInt32 Tag = Get32(p);
   UInt32 len = Get16(p + 4);
+  /*
   if (len + 8 > size)
     return false;
+  */
   /*
   if ((type & kReparseFlags_Alias) == 0 ||
       (type & kReparseFlags_Microsoft) == 0 ||
@@ -353,16 +419,14 @@ bool CReparseShortInfo::Parse(const Byte *p, size_t size)
       Tag != Z7_WIN_IO_REPARSE_TAG_SYMLINK)
     // return true;
     return false;
-
+  /*
   if (Get16(p + 6) != 0) // padding
     return false;
-  
+  */
   p += 8;
   size -= 8;
-  
   if (len != size) // do we need that check?
     return false;
-  
   if (len < 8)
     return false;
   unsigned subOffs = Get16(p);
@@ -396,10 +460,14 @@ bool CReparseAttr::IsOkNamePair() const
 {
   if (IsLinkPrefix(SubsName))
   {
+    if (PrintName == GetPath())
+      return true;
+/*
     if (!IsDrivePath(SubsName.Ptr(k_LinkPrefix_Size)))
       return PrintName.IsEmpty();
     if (wcscmp(SubsName.Ptr(k_LinkPrefix_Size), PrintName) == 0)
       return true;
+*/
   }
   return wcscmp(SubsName, PrintName) == 0;
 }
@@ -415,21 +483,26 @@ bool CReparseAttr::IsVolume() const
 
 UString CReparseAttr::GetPath() const
 {
+  UString s (SubsName);
   if (IsSymLink_WSL())
   {
-    UString u;
     // if (CheckUTF8(attr.WslName)
-    if (!ConvertUTF8ToUnicode(WslName, u))
-      MultiByteToUnicodeString2(u, WslName);
-    return u;
+    if (!ConvertUTF8ToUnicode(WslName, s))
+      MultiByteToUnicodeString2(s, WslName);
   }
-
-  UString s (SubsName);
-  if (IsLinkPrefix(s))
+  else if (IsLinkPrefix(s))
   {
-    s.ReplaceOneCharAtPos(1, '\\'); // we normalize prefix from "\??\" to "\\?\"
-    if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
-      s.DeleteFrontal(k_LinkPrefix_Size);
+    if (IsString1PrefixedByString2_NoCase_Ascii(s.Ptr(), k_LinkPrefix_UNC))
+    {
+      s.DeleteFrontal(6);
+      s.ReplaceOneCharAtPos(0, '\\');
+    }
+    else
+    {
+      s.ReplaceOneCharAtPos(1, '\\'); // we normalize prefix from "\??\" to "\\?\"
+      if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
+        s.DeleteFrontal(k_LinkPrefix_Size);
+    }
   }
   return s;
 }
@@ -468,7 +541,7 @@ bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMA
 static bool CreatePrefixDirOfFile(CFSTR path)
 {
   FString path2 (path);
-  int pos = path2.ReverseFind_PathSepar();
+  const int pos = path2.ReverseFind_PathSepar();
   if (pos < 0)
     return true;
   #ifdef _WIN32
@@ -494,6 +567,8 @@ static bool OutIoReparseData(DWORD controlCode, CFSTR path, void *data, DWORD si
 }
 
 
+// MOUNT_POINT (Junction Point) and LX_SYMLINK (WSL) can be written without administrator rights.
+// SYMLINK requires administrator rights.
 // If there is Reparse data already, it still writes new Reparse data
 bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size)
 {
@@ -540,10 +615,11 @@ bool DeleteReparseData(CFSTR path)
     SetLastError(ERROR_INVALID_REPARSE_DATA);
     return false;
   }
-  BYTE buf[my_REPARSE_DATA_BUFFER_HEADER_SIZE];
-  memset(buf, 0, sizeof(buf));
-  memcpy(buf, reparseData, 4); // tag
-  return OutIoReparseData(my_FSCTL_DELETE_REPARSE_POINT, path, buf, sizeof(buf));
+  // BYTE buf[my_REPARSE_DATA_BUFFER_HEADER_SIZE];
+  // memset(buf, 0, sizeof(buf));
+  // memcpy(buf, reparseData, 4); // tag
+  memset(reparseData + 4, 0, my_REPARSE_DATA_BUFFER_HEADER_SIZE - 4);
+  return OutIoReparseData(my_FSCTL_DELETE_REPARSE_POINT, path, reparseData, my_REPARSE_DATA_BUFFER_HEADER_SIZE);
 }
 
 }
diff --git a/CPP/Windows/FileName.cpp b/CPP/Windows/FileName.cpp
index 1f4a6da..eb62567 100644
--- a/CPP/Windows/FileName.cpp
+++ b/CPP/Windows/FileName.cpp
@@ -65,8 +65,15 @@ void NormalizeDirPathPrefix(UString &dirPath)
     dirPath.Add_PathSepar();
 }
 
+
+#define IS_LETTER_CHAR(c) ((((unsigned)(int)(c) | 0x20) - (unsigned)'a' <= (unsigned)('z' - 'a')))
+bool IsDrivePath (const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
+// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
+
 #ifdef _WIN32
 
+bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
+
 #ifndef USE_UNICODE_FSTRING
 #ifdef Z7_LONG_PATH
 static void NormalizeDirSeparators(UString &s)
@@ -87,13 +94,6 @@ void NormalizeDirSeparators(FString &s)
       s.ReplaceOneCharAtPos(i, FCHAR_PATH_SEPARATOR);
 }
 
-#endif
-
-
-#define IS_LETTER_CHAR(c) ((((unsigned)(int)(c) | 0x20) - (unsigned)'a' <= (unsigned)('z' - 'a')))
-
-bool IsDrivePath(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
-
 bool IsAltPathPrefix(CFSTR s) throw()
 {
   unsigned len = MyStringLen(s);
@@ -117,16 +117,23 @@ bool IsAltPathPrefix(CFSTR s) throw()
   return true;
 }
 
-#if defined(_WIN32) && !defined(UNDER_CE)
+#endif // _WIN32
+
 
-const char * const kSuperPathPrefix = "\\\\?\\";
+const char * const kSuperPathPrefix =
+    STRING_PATH_SEPARATOR
+    STRING_PATH_SEPARATOR "?"
+    STRING_PATH_SEPARATOR;
 #ifdef Z7_LONG_PATH
-static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
+static const char * const kSuperUncPrefix =
+    STRING_PATH_SEPARATOR
+    STRING_PATH_SEPARATOR "?"
+    STRING_PATH_SEPARATOR "UNC"
+    STRING_PATH_SEPARATOR;
 #endif
 
 #define IS_DEVICE_PATH(s)          (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '.' && IS_SEPAR((s)[3]))
 #define IS_SUPER_PREFIX(s)         (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '?' && IS_SEPAR((s)[3]))
-#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
 
 #define IS_UNC_WITH_SLASH(s) ( \
      ((s)[0] == 'U' || (s)[0] == 'u') \
@@ -134,6 +141,16 @@ static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
   && ((s)[2] == 'C' || (s)[2] == 'c') \
   && IS_SEPAR((s)[3]))
 
+static const unsigned kDrivePrefixSize = 3; /* c:\ */
+
+bool IsSuperPath(const wchar_t *s) throw();
+bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
+// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
+bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
 bool IsDevicePath(CFSTR s) throw()
 {
   #ifdef UNDER_CE
@@ -154,7 +171,7 @@ bool IsDevicePath(CFSTR s) throw()
   
   if (!IS_DEVICE_PATH(s))
     return false;
-  unsigned len = MyStringLen(s);
+  const unsigned len = MyStringLen(s);
   if (len == 6 && s[5] == ':')
     return true;
   if (len < 18 || len > 22 || !IsString1PrefixedByString2(s + kDevicePathPrefixSize, "PhysicalDrive"))
@@ -174,7 +191,7 @@ bool IsNetworkPath(CFSTR s) throw()
     return false;
   if (IsSuperUncPath(s))
     return true;
-  FChar c = s[2];
+  const FChar c = s[2];
   return (c != '.' && c != '?');
 }
 
@@ -187,7 +204,7 @@ unsigned GetNetworkServerPrefixSize(CFSTR s) throw()
     prefixSize = kSuperUncPathPrefixSize;
   else
   {
-    FChar c = s[2];
+    const FChar c = s[2];
     if (c == '.' || c == '?')
       return 0;
   }
@@ -209,14 +226,6 @@ bool IsNetworkShareRootPath(CFSTR s) throw()
   return s[(unsigned)pos + 1] == 0;
 }
 
-static const unsigned kDrivePrefixSize = 3; /* c:\ */
-
-bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
-// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
-bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
-bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
-// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
-
 bool IsAltStreamPrefixWithColon(const UString &s) throw()
 {
   if (s.IsEmpty())
@@ -349,14 +358,16 @@ unsigned GetRootPrefixSize(CFSTR s) throw()
 }
 
 #endif // USE_UNICODE_FSTRING
+#endif // _WIN32
+
 
 static unsigned GetRootPrefixSize_Of_NetworkPath(const wchar_t *s) throw()
 {
   // Network path: we look "server\path\" as root prefix
-  int pos = FindSepar(s);
+  const int pos = FindSepar(s);
   if (pos < 0)
     return 0;
-  int pos2 = FindSepar(s + (unsigned)pos + 1);
+  const int pos2 = FindSepar(s + (unsigned)pos + 1);
   if (pos2 < 0)
     return 0;
   return (unsigned)(pos + pos2 + 2);
@@ -370,7 +381,7 @@ static unsigned GetRootPrefixSize_Of_SimplePath(const wchar_t *s) throw()
     return 0;
   if (s[1] == 0 || !IS_SEPAR(s[1]))
     return 1;
-  unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
+  const unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
   return (size == 0) ? 0 : 2 + size;
 }
 
@@ -378,17 +389,21 @@ static unsigned GetRootPrefixSize_Of_SuperPath(const wchar_t *s) throw()
 {
   if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
   {
-    unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
+    const unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
     return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
   }
   // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
-  int pos = FindSepar(s + kSuperPathPrefixSize);
+  const int pos = FindSepar(s + kSuperPathPrefixSize);
   if (pos < 0)
     return 0;
   return kSuperPathPrefixSize + (unsigned)(pos + 1);
 }
 
+#ifdef _WIN32
 unsigned GetRootPrefixSize(const wchar_t *s) throw()
+#else
+unsigned GetRootPrefixSize_WINDOWS(const wchar_t *s) throw()
+#endif
 {
   if (IS_DEVICE_PATH(s))
     return kDevicePathPrefixSize;
@@ -397,7 +412,7 @@ unsigned GetRootPrefixSize(const wchar_t *s) throw()
   return GetRootPrefixSize_Of_SimplePath(s);
 }
 
-#else // _WIN32
+#ifndef _WIN32
 
 bool IsAbsolutePath(const wchar_t *s) throw() { return IS_SEPAR(s[0]); }
 
diff --git a/CPP/Windows/FileName.h b/CPP/Windows/FileName.h
index 219b656..ce26e78 100644
--- a/CPP/Windows/FileName.h
+++ b/CPP/Windows/FileName.h
@@ -25,13 +25,13 @@ bool IsDrivePath(const wchar_t *s) throw();  // first 3 chars are drive chars li
 
 bool IsAltPathPrefix(CFSTR s) throw(); /* name: */
 
-#if defined(_WIN32) && !defined(UNDER_CE)
-
 extern const char * const kSuperPathPrefix; /* \\?\ */
 const unsigned kDevicePathPrefixSize = 4;
 const unsigned kSuperPathPrefixSize = 4;
 const unsigned kSuperUncPathPrefixSize = kSuperPathPrefixSize + 4;
 
+#if defined(_WIN32) && !defined(UNDER_CE)
+
 bool IsDevicePath(CFSTR s) throw();   /* \\.\ */
 bool IsSuperUncPath(CFSTR s) throw(); /* \\?\UNC\ */
 bool IsNetworkPath(CFSTR s) throw();  /* \\?\UNC\ or \\SERVER */
@@ -86,6 +86,15 @@ int FindAltStreamColon(CFSTR path) throw();
 bool IsAbsolutePath(const wchar_t *s) throw();
 unsigned GetRootPrefixSize(const wchar_t *s) throw();
 
+#ifndef _WIN32
+/* GetRootPrefixSize_WINDOWS() is called in linux, but it parses path by windows rules.
+   It supports only paths system (linux) slash separators (STRING_PATH_SEPARATOR),
+   It doesn't parses paths with backslash (windows) separators.
+   "c:/dir/file" is supported.
+*/
+unsigned GetRootPrefixSize_WINDOWS(const wchar_t *s) throw();
+#endif
+
 #ifdef Z7_LONG_PATH
 
 const int kSuperPathType_UseOnlyMain = 0;
diff --git a/CPP/Windows/System.cpp b/CPP/Windows/System.cpp
index 5fa87f3..4745785 100644
--- a/CPP/Windows/System.cpp
+++ b/CPP/Windows/System.cpp
@@ -25,6 +25,69 @@ namespace NSystem {
 
 #ifdef _WIN32
 
+/*
+note: returned value in 32-bit version can be limited by value 32.
+      while 64-bit version returns full value.
+GetMaximumProcessorCount(groupNumber) can return higher value than
+GetActiveProcessorCount(groupNumber) in some cases, because CPUs can be added.
+*/
+// typedef DWORD (WINAPI *Func_GetMaximumProcessorCount)(WORD GroupNumber);
+typedef DWORD (WINAPI *Func_GetActiveProcessorCount)(WORD GroupNumber);
+typedef WORD (WINAPI *Func_GetActiveProcessorGroupCount)(VOID);
+/*
+#if 0 && defined(ALL_PROCESSOR_GROUPS)
+#define MY_ALL_PROCESSOR_GROUPS   ALL_PROCESSOR_GROUPS
+#else
+#define MY_ALL_PROCESSOR_GROUPS   0xffff
+#endif
+*/
+
+Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
+
+bool CCpuGroups::Load()
+{
+  NumThreadsTotal = 0;
+  GroupSizes.Clear();
+  const HMODULE hmodule = ::GetModuleHandleA("kernel32.dll");
+  // Is_Win11_Groups = GetProcAddress(hmodule, "SetThreadSelectedCpuSetMasks") != NULL;
+  const
+      Func_GetActiveProcessorGroupCount
+        fn_GetActiveProcessorGroupCount = Z7_GET_PROC_ADDRESS(
+      Func_GetActiveProcessorGroupCount, hmodule,
+          "GetActiveProcessorGroupCount");
+  const
+      Func_GetActiveProcessorCount
+        fn_GetActiveProcessorCount = Z7_GET_PROC_ADDRESS(
+      Func_GetActiveProcessorCount, hmodule,
+          "GetActiveProcessorCount");
+  if (!fn_GetActiveProcessorGroupCount ||
+      !fn_GetActiveProcessorCount)
+    return false;
+
+  const unsigned numGroups = fn_GetActiveProcessorGroupCount();
+  if (numGroups == 0)
+    return false;
+  UInt32 sum = 0;
+  for (unsigned i = 0; i < numGroups; i++)
+  {
+    const UInt32 num = fn_GetActiveProcessorCount((WORD)i);
+    /*
+    if (num == 0)
+    {
+      // it means error
+      // but is it possible that some group is empty by some reason?
+      // GroupSizes.Clear();
+      // return false;
+    }
+    */
+    sum += num;
+    GroupSizes.Add(num);
+  }
+  NumThreadsTotal = sum;
+  // NumThreadsTotal = fn_GetActiveProcessorCount(MY_ALL_PROCESSOR_GROUPS);
+  return true;
+}
+
 UInt32 CountAffinity(DWORD_PTR mask)
 {
   UInt32 num = 0;
@@ -38,31 +101,62 @@ UInt32 CountAffinity(DWORD_PTR mask)
 
 BOOL CProcessAffinity::Get()
 {
-  #ifndef UNDER_CE
-  return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
-  #else
-  return FALSE;
-  #endif
+  IsGroupMode = false;
+  Groups.Load();
+  // SetThreadAffinityMask(GetCurrentThread(), 1);
+  // SetProcessAffinityMask(GetCurrentProcess(), 1);
+  BOOL res = GetProcessAffinityMask(GetCurrentProcess(),
+      &processAffinityMask, &systemAffinityMask);
+  /* DOCs: On a system with more than 64 processors, if the threads
+     of the calling process  are in a single processor group, the
+     function sets the variables pointed to by lpProcessAffinityMask
+     and lpSystemAffinityMask to the process affinity mask and the
+     processor mask of active logical processors for that group.
+     If the calling process contains threads in multiple groups,
+     the function returns zero for both affinity masks
+
+     note: tested in Win10: GetProcessAffinityMask() doesn't return 0
+           in (processAffinityMask) and (systemAffinityMask) masks.
+     We need to test it in Win11: how to get mask==0 from GetProcessAffinityMask()?
+  */
+  if (!res)
+  {
+    processAffinityMask = 0;
+    systemAffinityMask = 0;
+  }
+  if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
+    if (// !res ||
+        processAffinityMask == 0 || // to support case described in DOCs and for (!res) case
+        processAffinityMask == systemAffinityMask) // for default nonchanged affinity
+    {
+      // we set IsGroupMode only if processAffinity is default (not changed).
+      res = TRUE;
+      IsGroupMode = true;
+    }
+  return res;
 }
 
 
+UInt32 CProcessAffinity::Load_and_GetNumberOfThreads()
+{
+  if (Get())
+  {
+    const UInt32 numProcessors = GetNumProcessThreads();
+    if (numProcessors)
+      return numProcessors;
+  }
+  SYSTEM_INFO systemInfo;
+  GetSystemInfo(&systemInfo);
+  // the number of logical processors in the current group
+  return systemInfo.dwNumberOfProcessors;
+}
+
 UInt32 GetNumberOfProcessors()
 {
   // We need to know how many threads we can use.
   // By default the process is assigned to one group.
-  // So we get the number of logical processors (threads)
-  // assigned to current process in the current group.
-  // Group size can be smaller than total number logical processors, for exammple, 2x36
-
   CProcessAffinity pa;
-
-  if (pa.Get() && pa.processAffinityMask != 0)
-    return pa.GetNumProcessThreads();
-
-  SYSTEM_INFO systemInfo;
-  GetSystemInfo(&systemInfo);
-  // the number of logical processors in the current group
-  return (UInt32)systemInfo.dwNumberOfProcessors;
+  return pa.Load_and_GetNumberOfThreads();
 }
 
 #else
diff --git a/CPP/Windows/System.h b/CPP/Windows/System.h
index 9951b8b..0c80373 100644
--- a/CPP/Windows/System.h
+++ b/CPP/Windows/System.h
@@ -9,6 +9,7 @@
 #endif
 
 #include "../Common/MyTypes.h"
+#include "../Common/MyVector.h"
 #include "../Common/MyWindows.h"
 
 namespace NWindows {
@@ -16,6 +17,34 @@ namespace NSystem {
 
 #ifdef _WIN32
 
+struct CCpuGroups
+{
+  CRecordVector<UInt32> GroupSizes;
+  UInt32 NumThreadsTotal; // sum of threads in all groups
+  // bool Is_Win11_Groups; // useless
+  
+  void Get_GroupSize_Min_Max(UInt32 &minSize, UInt32 &maxSize) const
+  {
+    unsigned num = GroupSizes.Size();
+    UInt32 minSize2 = 0, maxSize2 = 0;
+    if (num)
+    {
+      minSize2 = (UInt32)0 - 1;
+      do
+      {
+        const UInt32 v = GroupSizes[--num];
+        if (minSize2 > v) minSize2 = v;
+        if (maxSize2 < v) maxSize2 = v;
+      }
+      while (num);
+    }
+    minSize = minSize2;
+    maxSize = maxSize2;
+  }
+  bool Load();
+  CCpuGroups(): NumThreadsTotal(0) {}
+};
+
 UInt32 CountAffinity(DWORD_PTR mask);
 
 struct CProcessAffinity
@@ -25,14 +54,28 @@ struct CProcessAffinity
   DWORD_PTR processAffinityMask;
   DWORD_PTR systemAffinityMask;
 
+  CCpuGroups Groups;
+  bool IsGroupMode;
+    /*
+      IsGroupMode == true, if
+          Groups.GroupSizes.Size() > 1) && { dafalt affinity was not changed }
+      IsGroupMode == false, if single group or affinity was changed
+    */
+  
+  UInt32 Load_and_GetNumberOfThreads();
+
   void InitST()
   {
     // numProcessThreads = 1;
     // numSysThreads = 1;
     processAffinityMask = 1;
     systemAffinityMask = 1;
+    IsGroupMode = false;
+    // Groups.NumThreadsTotal = 0;
+    // Groups.Is_Win11_Groups = false;
   }
 
+/*
   void CpuZero()
   {
     processAffinityMask = 0;
@@ -42,9 +85,23 @@ struct CProcessAffinity
   {
     processAffinityMask |= ((DWORD_PTR)1 << cpuIndex);
   }
+*/
 
-  UInt32 GetNumProcessThreads() const { return CountAffinity(processAffinityMask); }
-  UInt32 GetNumSystemThreads() const { return CountAffinity(systemAffinityMask); }
+  UInt32 GetNumProcessThreads() const
+  {
+    if (IsGroupMode)
+      return Groups.NumThreadsTotal;
+    // IsGroupMode == false
+    // so we don't want to use groups
+    // we return number of threads in default primary group:
+    return CountAffinity(processAffinityMask);
+  }
+  UInt32 GetNumSystemThreads() const
+  {
+    if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
+      return Groups.NumThreadsTotal;
+    return CountAffinity(systemAffinityMask);
+  }
 
   BOOL Get();
 
diff --git a/CPP/Windows/Thread.h b/CPP/Windows/Thread.h
index d72f64c..75c1616 100644
--- a/CPP/Windows/Thread.h
+++ b/CPP/Windows/Thread.h
@@ -26,8 +26,10 @@ public:
     { return Thread_Create_With_Affinity(&thread, startAddress, param, affinity); }
   WRes Create_With_CpuSet(THREAD_FUNC_TYPE startAddress, LPVOID param, const CCpuSet *cpuSet)
     { return Thread_Create_With_CpuSet(&thread, startAddress, param, cpuSet); }
-  
-  #ifdef _WIN32
+ 
+#ifdef _WIN32
+  WRes Create_With_Group(THREAD_FUNC_TYPE startAddress, LPVOID param, unsigned group, CAffinityMask affinity = 0)
+    { return Thread_Create_With_Group(&thread, startAddress, param, group, affinity); }
   operator HANDLE() { return thread; }
   void Attach(HANDLE handle) { thread = handle; }
   HANDLE Detach() { HANDLE h = thread; thread = NULL; return h; }
@@ -36,7 +38,7 @@ public:
   bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread, exitCode)); }
   int GetPriority() { return ::GetThreadPriority(thread); }
   bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread, priority)); }
-  #endif
+#endif
 };
 
 }
diff --git a/CPP/Windows/TimeUtils.cpp b/CPP/Windows/TimeUtils.cpp
index bbd79ba..4e3bc59 100644
--- a/CPP/Windows/TimeUtils.cpp
+++ b/CPP/Windows/TimeUtils.cpp
@@ -258,8 +258,9 @@ bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
       FreeBSD 11.0, NetBSD 7.1, OpenBSD 6.0,
       Minix 3.1.8, AIX 7.1, HP-UX 11.31, IRIX 6.5, Solaris 11.3,
       Cygwin 2.9, mingw, MSVC 14, Android 9.0.
+  Android NDK defines TIME_UTC but doesn't have the timespec_get().
 */
-#if defined(TIME_UTC)
+#if defined(TIME_UTC) && !defined(__ANDROID__)
 #define ZIP7_USE_timespec_get
 // #pragma message("ZIP7_USE_timespec_get")
 #elif defined(CLOCK_REALTIME)