1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
|
// Copyright 2016 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.windows;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
import com.google.devtools.build.lib.util.Preconditions;
import com.google.devtools.build.lib.vfs.FileStatus;
import com.google.devtools.build.lib.vfs.FileSystem;
import com.google.devtools.build.lib.vfs.JavaIoFileSystem;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.Path.PathFactory;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.devtools.build.lib.windows.jni.WindowsFileOperations;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.attribute.DosFileAttributes;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.Nullable;
/** File system implementation for Windows. */
@ThreadSafe
public class WindowsFileSystem extends JavaIoFileSystem {
// Properties of 8dot3 (DOS-style) short file names:
// - they are at most 11 characters long
// - they have a prefix (before "~") that is {1..6} characters long, may contain numbers, letters,
// "_", even "~", and maybe even more
// - they have a "~" after the prefix
// - have {1..6} numbers after "~" (according to [1] this is only one digit, but MSDN doesn't
// clarify this), the combined length up till this point is at most 8
// - they have an optional "." afterwards, and another {0..3} more characters
// - just because a path looks like a short name it isn't necessarily one; the user may create
// such names and they'd resolve to themselves
// [1] https://en.wikipedia.org/wiki/8.3_filename#VFAT_and_Computer-generated_8.3_filenames
// bullet point (3) (on 2016-12-05)
@VisibleForTesting
static final Predicate<String> SHORT_NAME_MATCHER =
new Predicate<String>() {
private final Pattern pattern = Pattern.compile("^(.{1,6})~([0-9]{1,6})(\\..{0,3}){0,1}");
@Override
public boolean apply(@Nullable String input) {
Matcher m = pattern.matcher(input);
return input.length() <= 12
&& m.matches()
&& m.groupCount() >= 2
&& (m.group(1).length() + m.group(2).length()) < 8; // the "~" makes it at most 8
}
};
/** Resolves DOS-style, shortened path names, returning the last segment's long form. */
private static final Function<String, String> WINDOWS_SHORT_PATH_RESOLVER =
path -> {
try {
// Since Path objects are created hierarchically, we know for sure that every segment of
// the path, except the last one, is already canonicalized, so we can return just that.
// Plus the returned value is passed to Path.getChild so we must not return a full
// path here.
return PathFragment.create(WindowsFileOperations.getLongPath(path)).getBaseName();
} catch (IOException e) {
return null;
}
};
@VisibleForTesting
private enum WindowsPathFactory implements PathFactory {
INSTANCE {
@Override
public Path createRootPath(FileSystem filesystem) {
return new WindowsPath(filesystem, PathFragment.ROOT_DIR, null);
}
@Override
public Path createChildPath(Path parent, String childName) {
Preconditions.checkState(parent instanceof WindowsPath);
return new WindowsPath(parent.getFileSystem(), childName, (WindowsPath) parent);
}
@Override
public Path getCachedChildPathInternal(Path path, String childName) {
return WindowsPathFactory.getCachedChildPathInternalImpl(
path, childName, WINDOWS_SHORT_PATH_RESOLVER);
}
};
private static Path getCachedChildPathInternalImpl(
Path parent, String child, Function<String, String> resolver) {
if (parent != null && parent.isRootDirectory()) {
// This is a top-level directory. It's either a drive name ("C:" or "c") or some other
// Unix path (e.g. "/usr").
//
// We need to translate it to an absolute Windows path. The correct way would be looking
// up /etc/mtab to see if any mount point matches the prefix of the path, and change the
// prefix to the mounted path. Looking up /etc/mtab each time we create a path however
// would be too expensive so we use a heuristic instead.
//
// If the name looks like a volume name ("C:" or "c") then we treat it as such, otherwise
// we make it relative to UNIX_ROOT, thus "/usr" becomes "C:/tools/msys64/usr".
//
// This heuristic ignores other mount points as well as procfs.
// TODO(laszlocsomor): use GetLogicalDrives to retrieve the list of drives and only apply
// this heuristic for the valid drives. It's possible that the user has a directory "/a"
// but no "A:\" drive, so in that case we should prepend the MSYS root.
if (WindowsPath.isWindowsVolumeName(child)) {
child = WindowsPath.getDriveLetter((WindowsPath) parent, child) + ":";
} else {
if (UNIX_ROOT.get() == null) {
String jvmFlag = "bazel.windows_unix_root";
PathFragment value = determineUnixRoot(jvmFlag);
if (value == null) {
throw new IllegalStateException(
String.format(
"\"%1$s\" JVM flag is not set. Use the --host_jvm_args flag or export the "
+ "BAZEL_SH environment variable. For example "
+ "\"--host_jvm_args=-D%1$s=c:/tools/msys64\" or "
+ "\"set BAZEL_SH=c:/tools/msys64/usr/bin/bash.exe\". "
+ "parent=(%2$s) name=(%3$s)",
jvmFlag, parent, child));
}
UNIX_ROOT.set(value);
}
parent = parent.getRelative(UNIX_ROOT.get());
}
}
String resolvedChild = child;
if (parent != null && !parent.isRootDirectory() && SHORT_NAME_MATCHER.apply(child)) {
String pathString = parent.getPathString();
if (!pathString.endsWith("/")) {
pathString += "/";
}
pathString += child;
resolvedChild = resolver.apply(pathString);
}
return Path.getCachedChildPathInternal(
parent,
// If resolution succeeded, or we didn't attempt to resolve, then `resolvedChild` has the
// child name. If it's null, then resolution failed; use the unresolved child name in that
// case.
resolvedChild != null ? resolvedChild : child,
// If resolution failed, likely because the path doesn't exist, then do not cache the
// child. If we did, then in case the path later came into existence, we'd have a stale
// cache entry.
/* cacheable */ resolvedChild != null);
}
/**
* Creates a {@link PathFactory} with a mock shortname resolver.
*
* <p>The factory works exactly like the actual one ({@link WindowsPathFactory#INSTANCE}) except
* it's using the mock resolver.
*/
public static PathFactory createForTesting(final Function<String, String> mockResolver) {
return new PathFactory() {
@Override
public Path createRootPath(FileSystem filesystem) {
return INSTANCE.createRootPath(filesystem);
}
@Override
public Path createChildPath(Path parent, String childName) {
return INSTANCE.createChildPath(parent, childName);
}
@Override
public Path getCachedChildPathInternal(Path path, String childName) {
return WindowsPathFactory.getCachedChildPathInternalImpl(path, childName, mockResolver);
}
};
}
}
/** A windows-specific subclass of Path. */
@VisibleForTesting
protected static final class WindowsPath extends Path {
// The drive letter is '\0' if and only if this Path is the filesystem root "/".
private char driveLetter;
private WindowsPath(FileSystem fileSystem) {
super(fileSystem);
this.driveLetter = '\0';
}
private WindowsPath(FileSystem fileSystem, String name, WindowsPath parent) {
super(fileSystem, name, parent);
this.driveLetter = getDriveLetter(parent, name);
}
@Override
protected void buildPathString(StringBuilder result) {
if (isRootDirectory()) {
result.append(PathFragment.ROOT_DIR);
} else {
if (isTopLevelDirectory()) {
result.append(driveLetter).append(':').append(PathFragment.SEPARATOR_CHAR);
} else {
WindowsPath parent = (WindowsPath) getParentDirectory();
parent.buildPathString(result);
if (!parent.isTopLevelDirectory()) {
result.append(PathFragment.SEPARATOR_CHAR);
}
result.append(getBaseName());
}
}
}
@Override
public void reinitializeAfterDeserialization() {
Preconditions.checkState(
getParentDirectory().isRootDirectory() || getParentDirectory() instanceof WindowsPath);
this.driveLetter =
(getParentDirectory() != null) ? ((WindowsPath) getParentDirectory()).driveLetter : '\0';
}
@Override
public boolean isMaybeRelativeTo(Path ancestorCandidate) {
Preconditions.checkState(ancestorCandidate instanceof WindowsPath);
return ancestorCandidate.isRootDirectory()
|| driveLetter == ((WindowsPath) ancestorCandidate).driveLetter;
}
@Override
public boolean isTopLevelDirectory() {
return isRootDirectory() || getParentDirectory().isRootDirectory();
}
@Override
public PathFragment asFragment() {
String[] segments = getSegments();
if (segments.length > 0) {
// Strip off the first segment that contains the volume name.
segments = Arrays.copyOfRange(segments, 1, segments.length);
}
return PathFragment.create(driveLetter, true, segments);
}
@Override
protected Path getRootForRelativePathComputation(PathFragment relative) {
Path result = this;
if (relative.isAbsolute()) {
result = getFileSystem().getRootDirectory();
if (!relative.windowsVolume().isEmpty()) {
result = result.getRelative(relative.windowsVolume());
}
}
return result;
}
private static boolean isWindowsVolumeName(String name) {
return (name.length() == 1 || (name.length() == 2 && name.charAt(1) == ':'))
&& Character.isLetter(name.charAt(0));
}
private static char getDriveLetter(WindowsPath parent, String name) {
if (parent == null) {
return '\0';
} else {
if (parent.isRootDirectory()) {
Preconditions.checkState(
isWindowsVolumeName(name),
"top-level directory on Windows must be a drive (name = '%s')",
name);
return Character.toUpperCase(name.charAt(0));
} else {
return parent.driveLetter;
}
}
}
@VisibleForTesting
@Override
protected synchronized void applyToChildren(Predicate<Path> function) {
super.applyToChildren(function);
}
}
@VisibleForTesting
static PathFactory getPathFactoryForTesting(Function<String, String> mockResolver) {
return WindowsPathFactory.createForTesting(mockResolver);
}
private static final AtomicReference<PathFragment> UNIX_ROOT = new AtomicReference<>(null);
public static final LinkOption[] NO_OPTIONS = new LinkOption[0];
public static final LinkOption[] NO_FOLLOW = new LinkOption[] {LinkOption.NOFOLLOW_LINKS};
@Override
protected PathFactory getPathFactory() {
return WindowsPathFactory.INSTANCE;
}
@Override
public String getFileSystemType(Path path) {
// TODO(laszlocsomor): implement this properly, i.e. actually query this information from
// somewhere (java.nio.Filesystem? System.getProperty? implement JNI method and use WinAPI?).
return "ntfs";
}
@Override
protected void createSymbolicLink(Path linkPath, PathFragment targetFragment) throws IOException {
Path targetPath =
targetFragment.isAbsolute()
? getPath(targetFragment)
: linkPath.getParentDirectory().getRelative(targetFragment);
try {
java.nio.file.Path link = getIoFile(linkPath).toPath();
java.nio.file.Path target = getIoFile(targetPath).toPath();
// Still Create a dangling junction if the target doesn't exist.
if (!target.toFile().exists() || target.toFile().isDirectory()) {
WindowsFileOperations.createJunction(link.toString(), target.toString());
} else {
Files.copy(target, link);
}
} catch (java.nio.file.FileAlreadyExistsException e) {
throw new IOException(linkPath + ERR_FILE_EXISTS);
} catch (java.nio.file.AccessDeniedException e) {
throw new IOException(linkPath + ERR_PERMISSION_DENIED);
} catch (java.nio.file.NoSuchFileException e) {
throw new FileNotFoundException(linkPath + ERR_NO_SUCH_FILE_OR_DIR);
}
}
@Override
public boolean supportsSymbolicLinksNatively() {
return false;
}
@Override
public boolean isFilePathCaseSensitive() {
return false;
}
@Override
protected boolean fileIsSymbolicLink(File file) {
try {
if (isJunction(file)) {
return true;
}
} catch (IOException e) {
// Did not work, try in another way
}
return super.fileIsSymbolicLink(file);
}
public static LinkOption[] symlinkOpts(boolean followSymlinks) {
return followSymlinks ? NO_OPTIONS : NO_FOLLOW;
}
@Override
protected FileStatus stat(Path path, boolean followSymlinks) throws IOException {
File file = getIoFile(path);
final DosFileAttributes attributes;
try {
attributes = getAttribs(file, followSymlinks);
} catch (IOException e) {
throw new FileNotFoundException(path + ERR_NO_SUCH_FILE_OR_DIR);
}
final boolean isSymbolicLink = !followSymlinks && fileIsSymbolicLink(file);
FileStatus status =
new FileStatus() {
@Override
public boolean isFile() {
return attributes.isRegularFile() || (isSpecialFile() && !isDirectory());
}
@Override
public boolean isSpecialFile() {
return attributes.isOther();
}
@Override
public boolean isDirectory() {
return attributes.isDirectory();
}
@Override
public boolean isSymbolicLink() {
return isSymbolicLink;
}
@Override
public long getSize() throws IOException {
return attributes.size();
}
@Override
public long getLastModifiedTime() throws IOException {
return attributes.lastModifiedTime().toMillis();
}
@Override
public long getLastChangeTime() {
// This is the best we can do with Java NIO...
return attributes.lastModifiedTime().toMillis();
}
@Override
public long getNodeId() {
// TODO(bazel-team): Consider making use of attributes.fileKey().
return -1;
}
};
return status;
}
@Override
protected boolean isDirectory(Path path, boolean followSymlinks) {
if (!followSymlinks) {
try {
if (isJunction(getIoFile(path))) {
return false;
}
} catch (IOException e) {
return false;
}
}
return super.isDirectory(path, followSymlinks);
}
/**
* Returns true if the path refers to a directory junction, directory symlink, or regular symlink.
*
* <p>Directory junctions are symbolic links created with "mklink /J" where the target is a
* directory or another directory junction. Directory junctions can be created without any user
* privileges.
*
* <p>Directory symlinks are symbolic links created with "mklink /D" where the target is a
* directory or another directory symlink. Note that directory symlinks can only be created by
* Administrators.
*
* <p>Normal symlinks are symbolic links created with "mklink". Normal symlinks should not point
* at directories, because even though "mklink" can create the link, it will not be a functional
* one (the linked directory's contents cannot be listed). Only Administrators may create regular
* symlinks.
*
* <p>This method returns true for all three types as long as their target is a directory (even if
* they are dangling), though only directory junctions and directory symlinks are useful.
*/
@VisibleForTesting
static boolean isJunction(File file) throws IOException {
return WindowsFileOperations.isJunction(file.getPath());
}
private static DosFileAttributes getAttribs(File file, boolean followSymlinks)
throws IOException {
return Files.readAttributes(
file.toPath(), DosFileAttributes.class, symlinkOpts(followSymlinks));
}
private static PathFragment determineUnixRoot(String jvmArgName) {
// Get the path from a JVM flag, if specified.
String path = System.getProperty(jvmArgName);
if (path == null) {
return null;
}
path = path.trim();
if (path.isEmpty()) {
return null;
}
PathFragment result = PathFragment.create(path);
if (result.getDriveLetter() == '\0' || !result.isAbsolute()) {
return null;
}
return result;
}
}
|