[33426] | 1 | /* $Id: symlink-win.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * IPRT - Symbolic Links, Windows.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2010-2023 Oracle and/or its affiliates.
|
---|
[33426] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
[33426] | 11 | *
|
---|
[96407] | 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
[33426] | 25 | * The contents of this file may alternatively be used under the terms
|
---|
| 26 | * of the Common Development and Distribution License Version 1.0
|
---|
[96407] | 27 | * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
|
---|
| 28 | * in the VirtualBox distribution, in which case the provisions of the
|
---|
[33426] | 29 | * CDDL are applicable instead of those of the GPL.
|
---|
| 30 | *
|
---|
| 31 | * You may elect to license modified versions of this file under the
|
---|
| 32 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
[96407] | 33 | *
|
---|
| 34 | * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
|
---|
[33426] | 35 | */
|
---|
| 36 |
|
---|
| 37 |
|
---|
[57358] | 38 | /*********************************************************************************************************************************
|
---|
| 39 | * Header Files *
|
---|
| 40 | *********************************************************************************************************************************/
|
---|
[33426] | 41 | #define LOG_GROUP RTLOGGROUP_SYMLINK
|
---|
[62592] | 42 | #include <iprt/win/windows.h>
|
---|
[33426] | 43 |
|
---|
| 44 | #include <iprt/symlink.h>
|
---|
[47596] | 45 | #include "internal-r3-win.h"
|
---|
[33426] | 46 |
|
---|
| 47 | #include <iprt/assert.h>
|
---|
| 48 | #include <iprt/err.h>
|
---|
| 49 | #include <iprt/log.h>
|
---|
| 50 | #include <iprt/path.h>
|
---|
| 51 | #include <iprt/mem.h>
|
---|
| 52 | #include <iprt/string.h>
|
---|
[76409] | 53 | #include <iprt/utf16.h>
|
---|
[33426] | 54 | #include "internal/path.h"
|
---|
| 55 |
|
---|
| 56 |
|
---|
| 57 |
|
---|
[57358] | 58 | /*********************************************************************************************************************************
|
---|
| 59 | * Structures and Typedefs *
|
---|
| 60 | *********************************************************************************************************************************/
|
---|
[33437] | 61 | typedef struct MY_REPARSE_DATA_BUFFER
|
---|
| 62 | {
|
---|
| 63 | ULONG ReparseTag;
|
---|
| 64 | #define MY_IO_REPARSE_TAG_SYMLINK 0xa000000c
|
---|
| 65 | #define MY_IO_REPARSE_TAG_MOUNT_POINT 0xa0000003
|
---|
| 66 |
|
---|
| 67 | USHORT ReparseDataLength;
|
---|
| 68 | USHORT Reserved;
|
---|
| 69 | union
|
---|
| 70 | {
|
---|
| 71 | struct
|
---|
| 72 | {
|
---|
| 73 | USHORT SubstituteNameOffset;
|
---|
| 74 | USHORT SubstituteNameLength;
|
---|
| 75 | USHORT PrintNameOffset;
|
---|
| 76 | USHORT PrintNameLength;
|
---|
| 77 | ULONG Flags;
|
---|
| 78 | #define MY_SYMLINK_FLAG_RELATIVE 1
|
---|
| 79 | WCHAR PathBuffer[1];
|
---|
| 80 | } SymbolicLinkReparseBuffer;
|
---|
| 81 | struct
|
---|
| 82 | {
|
---|
| 83 | USHORT SubstituteNameOffset;
|
---|
| 84 | USHORT SubstituteNameLength;
|
---|
| 85 | USHORT PrintNameOffset;
|
---|
| 86 | USHORT PrintNameLength;
|
---|
| 87 | WCHAR PathBuffer[1];
|
---|
| 88 | } MountPointReparseBuffer;
|
---|
| 89 | struct
|
---|
| 90 | {
|
---|
| 91 | UCHAR DataBuffer[1];
|
---|
| 92 | } GenericReparseBuffer;
|
---|
| 93 | };
|
---|
| 94 | } MY_REPARSE_DATA_BUFFER;
|
---|
| 95 | #define MY_FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
---|
| 96 |
|
---|
| 97 |
|
---|
[33426] | 98 | RTDECL(bool) RTSymlinkExists(const char *pszSymlink)
|
---|
| 99 | {
|
---|
| 100 | bool fRc = false;
|
---|
| 101 | RTFSOBJINFO ObjInfo;
|
---|
| 102 | int rc = RTPathQueryInfoEx(pszSymlink, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
|
---|
| 103 | if (RT_SUCCESS(rc))
|
---|
| 104 | fRc = RTFS_IS_SYMLINK(ObjInfo.Attr.fMode);
|
---|
| 105 |
|
---|
| 106 | LogFlow(("RTSymlinkExists(%p={%s}): returns %RTbool\n", pszSymlink, pszSymlink, fRc));
|
---|
| 107 | return fRc;
|
---|
| 108 | }
|
---|
| 109 |
|
---|
| 110 |
|
---|
| 111 | RTDECL(bool) RTSymlinkIsDangling(const char *pszSymlink)
|
---|
| 112 | {
|
---|
| 113 | bool fRc = false;
|
---|
| 114 | RTFSOBJINFO ObjInfo;
|
---|
| 115 | int rc = RTPathQueryInfoEx(pszSymlink, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
|
---|
| 116 | if (RT_SUCCESS(rc))
|
---|
| 117 | {
|
---|
| 118 | fRc = RTFS_IS_SYMLINK(ObjInfo.Attr.fMode);
|
---|
| 119 | if (fRc)
|
---|
| 120 | {
|
---|
| 121 | rc = RTPathQueryInfoEx(pszSymlink, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK);
|
---|
[33437] | 122 | fRc = !RT_SUCCESS_NP(rc);
|
---|
[33426] | 123 | }
|
---|
| 124 | }
|
---|
| 125 |
|
---|
| 126 | LogFlow(("RTSymlinkIsDangling(%p={%s}): returns %RTbool\n", pszSymlink, pszSymlink, fRc));
|
---|
| 127 | return fRc;
|
---|
| 128 | }
|
---|
| 129 |
|
---|
| 130 |
|
---|
[39612] | 131 | RTDECL(int) RTSymlinkCreate(const char *pszSymlink, const char *pszTarget, RTSYMLINKTYPE enmType, uint32_t fCreate)
|
---|
[33426] | 132 | {
|
---|
| 133 | /*
|
---|
| 134 | * Validate the input.
|
---|
| 135 | */
|
---|
| 136 | AssertReturn(enmType > RTSYMLINKTYPE_INVALID && enmType < RTSYMLINKTYPE_END, VERR_INVALID_PARAMETER);
|
---|
| 137 | AssertPtrReturn(pszSymlink, VERR_INVALID_POINTER);
|
---|
| 138 | AssertPtrReturn(pszTarget, VERR_INVALID_POINTER);
|
---|
[62584] | 139 | RT_NOREF_PV(fCreate);
|
---|
[33426] | 140 |
|
---|
| 141 | /*
|
---|
| 142 | * Resolve the API.
|
---|
| 143 | */
|
---|
| 144 | typedef BOOLEAN (WINAPI *PFNCREATESYMBOLICLINKW)(LPCWSTR, LPCWSTR, DWORD);
|
---|
| 145 | static PFNCREATESYMBOLICLINKW s_pfnCreateSymbolicLinkW = NULL;
|
---|
| 146 | static bool s_fTried = FALSE;
|
---|
| 147 | if (!s_fTried)
|
---|
| 148 | {
|
---|
[46593] | 149 | PFNCREATESYMBOLICLINKW pfn = (PFNCREATESYMBOLICLINKW)GetProcAddress(g_hModKernel32, "CreateSymbolicLinkW");
|
---|
| 150 | if (pfn)
|
---|
| 151 | s_pfnCreateSymbolicLinkW = pfn;
|
---|
[33426] | 152 | s_fTried = true;
|
---|
| 153 | }
|
---|
| 154 | if (!s_pfnCreateSymbolicLinkW)
|
---|
| 155 | {
|
---|
[39612] | 156 | LogFlow(("RTSymlinkCreate(%p={%s}, %p={%s}, %d, %#x): returns VERR_NOT_SUPPORTED - Windows API not found\n",
|
---|
| 157 | pszSymlink, pszSymlink, pszTarget, pszTarget, enmType, fCreate));
|
---|
[33426] | 158 | return VERR_NOT_SUPPORTED;
|
---|
| 159 | }
|
---|
| 160 |
|
---|
| 161 | /*
|
---|
| 162 | * Convert the paths.
|
---|
| 163 | */
|
---|
| 164 | PRTUTF16 pwszNativeSymlink;
|
---|
[74460] | 165 | int rc = RTPathWinFromUtf8(&pwszNativeSymlink, pszSymlink, 0 /*fFlags*/);
|
---|
[33426] | 166 | if (RT_SUCCESS(rc))
|
---|
| 167 | {
|
---|
| 168 | PRTUTF16 pwszNativeTarget;
|
---|
[74460] | 169 | rc = RTPathWinFromUtf8(&pwszNativeTarget, pszTarget, 0 /*fFlags*/);
|
---|
[33426] | 170 | if (RT_SUCCESS(rc))
|
---|
| 171 | {
|
---|
[49043] | 172 | /* The link target path must use backslashes to work reliably. */
|
---|
| 173 | RTUTF16 wc;
|
---|
| 174 | PRTUTF16 pwsz = pwszNativeTarget;
|
---|
| 175 | while ((wc = *pwsz) != '\0')
|
---|
| 176 | {
|
---|
| 177 | if (wc == '/')
|
---|
| 178 | *pwsz = '\\';
|
---|
| 179 | pwsz++;
|
---|
| 180 | }
|
---|
| 181 |
|
---|
[33426] | 182 | /*
|
---|
| 183 | * Massage the target path, determin the link type.
|
---|
| 184 | */
|
---|
| 185 | size_t cchTarget = strlen(pszTarget);
|
---|
| 186 | size_t cchVolSpecTarget = rtPathVolumeSpecLen(pszTarget);
|
---|
[33437] | 187 | #if 0 /* looks like this isn't needed after all. That makes everything much simper :-) */
|
---|
[33426] | 188 | if ( cchTarget > RT_MIN(cchVolSpecTarget, 1)
|
---|
| 189 | && RTPATH_IS_SLASH(pszTarget[cchTarget - 1]))
|
---|
| 190 | {
|
---|
| 191 | size_t cwcNativeTarget = RTUtf16Len(pwszNativeTarget);
|
---|
| 192 | size_t offFromEnd = 1;
|
---|
| 193 | while ( offFromEnd < cchTarget
|
---|
| 194 | && cchTarget - offFromEnd >= cchVolSpecTarget
|
---|
| 195 | && RTPATH_IS_SLASH(pszTarget[cchTarget - offFromEnd]))
|
---|
| 196 | {
|
---|
| 197 | Assert(offFromEnd < cwcNativeTarget);
|
---|
| 198 | pwszNativeTarget[cwcNativeTarget - offFromEnd] = 0;
|
---|
| 199 | offFromEnd++;
|
---|
| 200 | }
|
---|
| 201 | }
|
---|
[33437] | 202 | #endif
|
---|
[33426] | 203 |
|
---|
| 204 | if (enmType == RTSYMLINKTYPE_UNKNOWN)
|
---|
| 205 | {
|
---|
| 206 | if ( cchTarget > cchVolSpecTarget
|
---|
| 207 | && RTPATH_IS_SLASH(pszTarget[cchTarget - 1]))
|
---|
| 208 | enmType = RTSYMLINKTYPE_DIR;
|
---|
| 209 | else if (cchVolSpecTarget)
|
---|
| 210 | {
|
---|
[33437] | 211 | /** @todo this is subject to sharing violations. */
|
---|
[33426] | 212 | DWORD dwAttr = GetFileAttributesW(pwszNativeTarget);
|
---|
| 213 | if ( dwAttr != INVALID_FILE_ATTRIBUTES
|
---|
| 214 | && (dwAttr & FILE_ATTRIBUTE_DIRECTORY))
|
---|
| 215 | enmType = RTSYMLINKTYPE_DIR;
|
---|
| 216 | }
|
---|
| 217 | else
|
---|
| 218 | {
|
---|
| 219 | /** @todo Join the symlink directory with the target and
|
---|
| 220 | * look up the attributes on that. -lazy bird. */
|
---|
| 221 | }
|
---|
| 222 | }
|
---|
| 223 |
|
---|
| 224 | /*
|
---|
| 225 | * Create the link.
|
---|
| 226 | */
|
---|
| 227 | if (s_pfnCreateSymbolicLinkW(pwszNativeSymlink, pwszNativeTarget, enmType == RTSYMLINKTYPE_DIR))
|
---|
| 228 | rc = VINF_SUCCESS;
|
---|
| 229 | else
|
---|
| 230 | rc = RTErrConvertFromWin32(GetLastError());
|
---|
| 231 |
|
---|
[74460] | 232 | RTPathWinFree(pwszNativeTarget);
|
---|
[33426] | 233 | }
|
---|
[74460] | 234 | RTPathWinFree(pwszNativeSymlink);
|
---|
[33426] | 235 | }
|
---|
| 236 |
|
---|
[39612] | 237 | LogFlow(("RTSymlinkCreate(%p={%s}, %p={%s}, %d, %#x): returns %Rrc\n", pszSymlink, pszSymlink, pszTarget, pszTarget, enmType, fCreate, rc));
|
---|
[33426] | 238 | return rc;
|
---|
| 239 | }
|
---|
| 240 |
|
---|
| 241 |
|
---|
[39612] | 242 | RTDECL(int) RTSymlinkDelete(const char *pszSymlink, uint32_t fDelete)
|
---|
[33426] | 243 | {
|
---|
[62584] | 244 | RT_NOREF_PV(fDelete);
|
---|
| 245 |
|
---|
[33426] | 246 | /*
|
---|
| 247 | * Convert the path.
|
---|
| 248 | */
|
---|
| 249 | PRTUTF16 pwszNativeSymlink;
|
---|
[74460] | 250 | int rc = RTPathWinFromUtf8(&pwszNativeSymlink, pszSymlink, 0 /*fFlags*/);
|
---|
[33426] | 251 | if (RT_SUCCESS(rc))
|
---|
| 252 | {
|
---|
| 253 | /*
|
---|
| 254 | * We have to use different APIs depending on whether this is a
|
---|
| 255 | * directory or file link. This means we're subject to one more race
|
---|
| 256 | * than on posix at the moment. We could probably avoid this though,
|
---|
| 257 | * if we wanted to go talk with the native API layer below Win32...
|
---|
| 258 | */
|
---|
| 259 | DWORD dwAttr = GetFileAttributesW(pwszNativeSymlink);
|
---|
| 260 | if (dwAttr != INVALID_FILE_ATTRIBUTES)
|
---|
| 261 | {
|
---|
| 262 | if (dwAttr & FILE_ATTRIBUTE_REPARSE_POINT)
|
---|
| 263 | {
|
---|
| 264 | BOOL fRc;
|
---|
| 265 | if (dwAttr & FILE_ATTRIBUTE_DIRECTORY)
|
---|
| 266 | fRc = RemoveDirectoryW(pwszNativeSymlink);
|
---|
| 267 | else
|
---|
| 268 | fRc = DeleteFileW(pwszNativeSymlink);
|
---|
| 269 | if (fRc)
|
---|
| 270 | rc = VINF_SUCCESS;
|
---|
| 271 | else
|
---|
| 272 | rc = RTErrConvertFromWin32(GetLastError());
|
---|
| 273 | }
|
---|
| 274 | else
|
---|
| 275 | rc = VERR_NOT_SYMLINK;
|
---|
| 276 | }
|
---|
| 277 | else
|
---|
| 278 | rc = RTErrConvertFromWin32(GetLastError());
|
---|
[74460] | 279 | RTPathWinFree(pwszNativeSymlink);
|
---|
[33426] | 280 | }
|
---|
| 281 |
|
---|
[39612] | 282 | LogFlow(("RTSymlinkDelete(%p={%s}, %#x): returns %Rrc\n", pszSymlink, pszSymlink, fDelete, rc));
|
---|
[33426] | 283 | return rc;
|
---|
| 284 | }
|
---|
| 285 |
|
---|
| 286 |
|
---|
[39612] | 287 | RTDECL(int) RTSymlinkRead(const char *pszSymlink, char *pszTarget, size_t cbTarget, uint32_t fRead)
|
---|
[33426] | 288 | {
|
---|
[62584] | 289 | RT_NOREF_PV(fRead);
|
---|
| 290 |
|
---|
[33426] | 291 | char *pszMyTarget;
|
---|
| 292 | int rc = RTSymlinkReadA(pszSymlink, &pszMyTarget);
|
---|
| 293 | if (RT_SUCCESS(rc))
|
---|
| 294 | {
|
---|
| 295 | rc = RTStrCopy(pszTarget, cbTarget, pszMyTarget);
|
---|
| 296 | RTStrFree(pszMyTarget);
|
---|
| 297 | }
|
---|
| 298 | LogFlow(("RTSymlinkRead(%p={%s}): returns %Rrc\n", pszSymlink, pszSymlink, rc));
|
---|
| 299 | return rc;
|
---|
| 300 | }
|
---|
| 301 |
|
---|
| 302 |
|
---|
| 303 | RTDECL(int) RTSymlinkReadA(const char *pszSymlink, char **ppszTarget)
|
---|
| 304 | {
|
---|
| 305 | AssertPtr(ppszTarget);
|
---|
| 306 | PRTUTF16 pwszNativeSymlink;
|
---|
[74460] | 307 | int rc = RTPathWinFromUtf8(&pwszNativeSymlink, pszSymlink, 0 /*fFlags*/);
|
---|
[33426] | 308 | if (RT_SUCCESS(rc))
|
---|
| 309 | {
|
---|
| 310 | HANDLE hSymlink = CreateFileW(pwszNativeSymlink,
|
---|
| 311 | GENERIC_READ,
|
---|
| 312 | FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
---|
| 313 | NULL,
|
---|
| 314 | OPEN_EXISTING,
|
---|
[33437] | 315 | FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
|
---|
[33426] | 316 | NULL);
|
---|
| 317 | if (hSymlink != INVALID_HANDLE_VALUE)
|
---|
| 318 | {
|
---|
[33437] | 319 | DWORD cbReturned = 0;
|
---|
| 320 | union
|
---|
| 321 | {
|
---|
| 322 | MY_REPARSE_DATA_BUFFER Buf;
|
---|
| 323 | uint8_t abBuf[16*_1K + sizeof(WCHAR)];
|
---|
| 324 | } u;
|
---|
| 325 | if (DeviceIoControl(hSymlink,
|
---|
| 326 | MY_FSCTL_GET_REPARSE_POINT,
|
---|
| 327 | NULL /*pInBuffer */,
|
---|
| 328 | 0 /*cbInBuffer */,
|
---|
| 329 | &u.Buf,
|
---|
| 330 | sizeof(u) - sizeof(WCHAR),
|
---|
| 331 | &cbReturned,
|
---|
| 332 | NULL /*pOverlapped*/))
|
---|
| 333 | {
|
---|
| 334 | if (u.Buf.ReparseTag == MY_IO_REPARSE_TAG_SYMLINK)
|
---|
| 335 | {
|
---|
| 336 | PWCHAR pwszTarget = &u.Buf.SymbolicLinkReparseBuffer.PathBuffer[0];
|
---|
| 337 | pwszTarget += u.Buf.SymbolicLinkReparseBuffer.SubstituteNameOffset / 2;
|
---|
| 338 | pwszTarget[u.Buf.SymbolicLinkReparseBuffer.SubstituteNameLength / 2] = 0;
|
---|
| 339 | if ( !(u.Buf.SymbolicLinkReparseBuffer.Flags & MY_SYMLINK_FLAG_RELATIVE)
|
---|
| 340 | && pwszTarget[0] == '\\'
|
---|
| 341 | && pwszTarget[1] == '?'
|
---|
| 342 | && pwszTarget[2] == '?'
|
---|
| 343 | && pwszTarget[3] == '\\'
|
---|
| 344 | && pwszTarget[4] != 0
|
---|
| 345 | )
|
---|
| 346 | pwszTarget += 4;
|
---|
| 347 | rc = RTUtf16ToUtf8(pwszTarget, ppszTarget);
|
---|
| 348 | }
|
---|
| 349 | else
|
---|
| 350 | rc = VERR_NOT_SYMLINK;
|
---|
| 351 | }
|
---|
| 352 | else
|
---|
| 353 | rc = RTErrConvertFromWin32(GetLastError());
|
---|
[33426] | 354 | CloseHandle(hSymlink);
|
---|
| 355 | }
|
---|
| 356 | else
|
---|
| 357 | rc = RTErrConvertFromWin32(GetLastError());
|
---|
[74460] | 358 | RTPathWinFree(pwszNativeSymlink);
|
---|
[33426] | 359 | }
|
---|
| 360 |
|
---|
| 361 | if (RT_SUCCESS(rc))
|
---|
| 362 | LogFlow(("RTSymlinkReadA(%p={%s},%p): returns %Rrc *ppszTarget=%p:{%s}\n", pszSymlink, pszSymlink, ppszTarget, rc, *ppszTarget, *ppszTarget));
|
---|
| 363 | else
|
---|
| 364 | LogFlow(("RTSymlinkReadA(%p={%s},%p): returns %Rrc\n", pszSymlink, pszSymlink, ppszTarget, rc));
|
---|
| 365 | return rc;
|
---|
| 366 | }
|
---|
| 367 |
|
---|