dart:io on Windows treats every reparse point as a link instead of checking IsReparseTagNameSurrogate #64535

import 'dart:ffi';
import 'dart:io';

import 'package:ffi/ffi.dart';

final class GUID extends Struct {
  @Uint32()
  external int data1;
  @Uint16()
  external int data2;
  @Uint16()
  external int data3;
  @Array(8)
  external Array<Uint8> data4;
}

final class CF_SYNC_REGISTRATION extends Struct {
  @Uint32()
  external int structSize;
  external Pointer<Utf16> providerName;
  external Pointer<Utf16> providerVersion;
  external Pointer<Void> syncRootIdentity;
  @Uint32()
  external int syncRootIdentityLength;
  external Pointer<Void> fileIdentity;
  @Uint32()
  external int fileIdentityLength;
  external GUID providerId;
}

final class CF_SYNC_POLICIES extends Struct {
  @Uint32()
  external int structSize;
  @Uint16()
  external int hydrationPrimary;
  @Uint16()
  external int hydrationModifier;
  @Uint16()
  external int populationPrimary;
  @Uint16()
  external int populationModifier;
  @Uint32()
  external int inSync;
  @Uint32()
  external int hardLink;
  @Uint32()
  external int placeholderManagement;
}

final cldapi = DynamicLibrary.open('cldapi.dll');
final kernel32 = DynamicLibrary.open('kernel32.dll');
final ntdll = DynamicLibrary.open('ntdll.dll');

final cfRegisterSyncRoot = cldapi.lookupFunction<
    Int32 Function(Pointer<Utf16>, Pointer<CF_SYNC_REGISTRATION>,
        Pointer<CF_SYNC_POLICIES>, Int32),
    int Function(Pointer<Utf16>, Pointer<CF_SYNC_REGISTRATION>,
        Pointer<CF_SYNC_POLICIES>, int)>('CfRegisterSyncRoot');
final cfConvertToPlaceholder = cldapi.lookupFunction<
    Int32 Function(Pointer<Void>, Pointer<Void>, Uint32, Int32, Pointer<Int64>,
        Pointer<Void>),
    int Function(Pointer<Void>, Pointer<Void>, int, int, Pointer<Int64>,
        Pointer<Void>)>('CfConvertToPlaceholder');
final cfUnregisterSyncRoot = cldapi.lookupFunction<
    Int32 Function(Pointer<Utf16>),
    int Function(Pointer<Utf16>)>('CfUnregisterSyncRoot');
final createFileW = kernel32.lookupFunction<
    Pointer<Void> Function(Pointer<Utf16>, Uint32, Uint32, Pointer<Void>,
        Uint32, Uint32, Pointer<Void>),
    Pointer<Void> Function(Pointer<Utf16>, int, int, Pointer<Void>, int, int,
        Pointer<Void>)>('CreateFileW');
final closeHandle = kernel32.lookupFunction<Int32 Function(Pointer<Void>),
    int Function(Pointer<Void>)>('CloseHandle');
final getFileAttributesW = kernel32.lookupFunction<
    Uint32 Function(Pointer<Utf16>),
    int Function(Pointer<Utf16>)>('GetFileAttributesW');
final queryPlaceholderCompatibilityMode =
    ntdll.lookupFunction<Int8 Function(), int Function()>(
        'RtlQueryProcessPlaceholderCompatibilityMode');
final setPlaceholderCompatibilityMode =
    ntdll.lookupFunction<Int8 Function(Int8), int Function(int)>(
        'RtlSetProcessPlaceholderCompatibilityMode');

void check(int hresult, String call) {
  if (hresult != 0) {
    throw StateError(
        '$call failed: 0x${hresult.toUnsigned(32).toRadixString(16)}');
  }
}

void convertToPlaceholder(Pointer<Utf16> path) {
  final handle = createFileW(path, 0x80000000 | 0x40000000, 0x1 | 0x2 | 0x4,
      nullptr, 3, 0x02000000, nullptr);
  if (handle.address == -1) throw StateError('CreateFileW failed');
  try {
    check(cfConvertToPlaceholder(handle, nullptr, 0, 0x1, nullptr, nullptr),
        'CfConvertToPlaceholder(${path.toDartString()})');
  } finally {
    closeHandle(handle);
  }
}

bool hasReparseAttribute(Pointer<Utf16> path) =>
    getFileAttributesW(path) & 0x400 != 0;

String describe(String path) =>
    'typeSync(followLinks: false)=${FileSystemEntity.typeSync(path, followLinks: false)} '
    'typeSync(followLinks: true)=${FileSystemEntity.typeSync(path, followLinks: true)} '
    'isLinkSync=${FileSystemEntity.isLinkSync(path)}';

List<String> names(Directory directory,
        {required bool recursive, required bool followLinks}) =>
    directory
        .listSync(recursive: recursive, followLinks: followLinks)
        .map((e) =>
            '${e.runtimeType}(${e.path.substring(directory.path.length + 1)})')
        .toList()
      ..sort();

void main() {
  final temp = Directory.systemTemp.createTempSync('placeholders_');
  final syncRoot = Directory('${temp.path}\\sync_root')..createSync();
  final sub = Directory('${syncRoot.path}\\sub')..createSync();
  final subSub = Directory('${sub.path}\\sub_sub')..createSync();
  final nested = File('${subSub.path}\\nested.txt')..writeAsStringSync('n');
  final plain = File('${syncRoot.path}\\plain.txt')..writeAsStringSync('p');

  final arena = Arena();
  final syncRootPath = syncRoot.path.toNativeUtf16(allocator: arena);
  final subPath = sub.path.toNativeUtf16(allocator: arena);
  final subSubPath = subSub.path.toNativeUtf16(allocator: arena);
  final plainPath = plain.path.toNativeUtf16(allocator: arena);
  var oldMode = -1;
  try {
    final registration = arena<CF_SYNC_REGISTRATION>();
    registration.ref
      ..structSize = sizeOf<CF_SYNC_REGISTRATION>()
      ..providerName = 'ReproProvider'.toNativeUtf16(allocator: arena)
      ..providerVersion = '1.0'.toNativeUtf16(allocator: arena)
      ..syncRootIdentity = (arena<Uint32>()..value = 1).cast()
      ..syncRootIdentityLength = 4
      ..providerId.data1 = 0x52657072;
    final policies = arena<CF_SYNC_POLICIES>()
      ..ref.structSize = sizeOf<CF_SYNC_POLICIES>();
    check(cfRegisterSyncRoot(syncRootPath, registration, policies, 0x2 | 0x4),
        'CfRegisterSyncRoot');

    convertToPlaceholder(subPath);
    convertToPlaceholder(subSubPath);
    convertToPlaceholder(plainPath);

    void report(String phase) {
      print('[$phase] mode=${queryPlaceholderCompatibilityMode()}');
      print(
          '[$phase] reparse attr: sync_root=${hasReparseAttribute(syncRootPath)} '
          'sub=${hasReparseAttribute(subPath)} '
          'sub_sub=${hasReparseAttribute(subSubPath)} '
          'plain.txt=${hasReparseAttribute(plainPath)}');
      print('[$phase] sync_root: ${describe(syncRoot.path)}');
      print('[$phase] sub: ${describe(sub.path)}');
      print('[$phase] plain.txt: ${describe(plain.path)}');
      print('[$phase] temp.listSync(followLinks: false): '
          '${names(temp, recursive: false, followLinks: false)}');
      print('[$phase] sync_root.listSync(followLinks: false): '
          '${names(syncRoot, recursive: false, followLinks: false)}');
      print('[$phase] sync_root recursive/noFollow: '
          '${names(syncRoot, recursive: true, followLinks: false)}');
    }

    report('default');
    oldMode = setPlaceholderCompatibilityMode(2);
    report('exposed');
    try {
      print('[exposed] Link(sub).targetSync(): ${Link(sub.path).targetSync()}');
    } on FileSystemException catch (e) {
      print('[exposed] Link(sub).targetSync(): $e');
    }
    try {
      syncRoot.deleteSync(recursive: true);
      print('[exposed] deleteSync(recursive: true): ok');
    } on FileSystemException catch (e) {
      print('[exposed] deleteSync(recursive: true): $e');
    }
  } finally {
    cfUnregisterSyncRoot(syncRootPath);
    arena.releaseAll();
    if (oldMode >= 0) setPlaceholderCompatibilityMode(oldMode);
    for (final entity in [nested, subSub, plain, sub, syncRoot, temp]) {
      try {
        entity.deleteSync();
      } on FileSystemException catch (_) {}
    }
  }
}