mklink2.cc

   1 #include <stdlib.h>
   2 #include <wchar.h>
   3 #include "win32.h"
   4 #include "ntdll.h"
   5 #include "shlobj.h"
   6 #include "mklink2.h"
   7 #include "filemanip.h"
   8 #include "winioctl.h"
   9 #include "LogSingleton.h"
  10 #include "mount.h"
  11
  12 SymlinkTypeEnum symlinkType = SymlinkTypeMagic; // default to historical behaviour
  13
  14 /* This part of the code must be in C because the C++ interface to COM
  15 doesn't work. */
  16
  17 /* Initialized in WinMain.  This is required under Windows 7.  If
  18    CoCreateInstance gets called from here, it fails to create the
  19    instance with an undocumented error code 0x80110474.
  20    FIXME: I have no idea why this happens. */
  21 IShellLink *sl;
  22
  23 extern "C"
  24 void
  25 make_link_2 (char const *exepath, char const *args, char const *icon, char const *lname)
  26 {
  27   IPersistFile *pf;
  28   WCHAR widepath[MAX_PATH];
  29   if (sl)
  30     {
  31       sl->QueryInterface (IID_IPersistFile, (void **) &pf);
  32
  33       sl->SetPath (exepath);
  34       sl->SetArguments (args);
  35       sl->SetIconLocation (icon, 0);
  36
  37       MultiByteToWideChar (CP_ACP, 0, lname, -1, widepath, MAX_PATH);
  38       pf->Save (widepath, TRUE);
  39
  40       pf->Release ();
  41     }
  42 }
  43
  44 #define SYMLINK_COOKIE "!<symlink>"
  45
  46 static int
  47 mkmagiccygsymlink (const char *from, const char *to)
  48 {
  49   char buf[strlen (SYMLINK_COOKIE) + 4096];
  50   unsigned long w;
  51   const size_t len = strlen (from) + 7;
  52   WCHAR wfrom[len];
  53   HANDLE h;
  54   SECURITY_DESCRIPTOR sd;
  55   acl_t acl;
  56   SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES),
  57                              nt_sec.GetPosixPerms (from, NULL, NULL, 0644,
  58                                                    sd, acl),
  59                              FALSE };
  60
  61   mklongpath (wfrom, from, len);
  62   h = CreateFileW (wfrom, GENERIC_WRITE, 0, &sa, CREATE_NEW,
  63                    FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, 0);
  64   if (h == INVALID_HANDLE_VALUE)
  65     return 1;
  66   strcpy (buf, SYMLINK_COOKIE);
  67   strncat (buf, to, 4095);
  68   if (WriteFile (h, buf, strlen (buf) + 1, &w, NULL))
  69     {
  70       CloseHandle (h);
  71       SetFileAttributesW (wfrom, FILE_ATTRIBUTE_SYSTEM);
  72       return 0;
  73     }
  74   CloseHandle (h);
  75   DeleteFileW (wfrom);
  76   return 1;
  77 }
  78
  79 #ifndef IO_REPARSE_TAG_LX_SYMLINK
  80 #define IO_REPARSE_TAG_LX_SYMLINK (0xa000001d)
  81 #endif
  82
  83 typedef struct _REPARSE_LX_SYMLINK_BUFFER
  84 {
  85   DWORD ReparseTag;
  86   WORD  ReparseDataLength;
  87   WORD  Reserved;
  88   struct {
  89     DWORD FileType;     /* Value is apparently always 2 for symlinks. */
  90     char  PathBuffer[1];/* UTF-8 encoded POSIX path
  91                            Isn't \0 terminated.
  92                            Length is ReparseDataLength - sizeof (FileType).
  93                         */
  94   } LxSymlinkReparseBuffer;
  95 } REPARSE_LX_SYMLINK_BUFFER,*PREPARSE_LX_SYMLINK_BUFFER;
  96
  97 static int
  98 mkwslsymlink (const char *from, const char *to)
  99 {
 100   /* Construct the reparse path */
 101   std::string lxsymto;
 102   if (to[0] == '/')
 103     {
 104       /* If 'to' is absolute and starts with '/cygdrive' or /proc/cygdrive',
 105          this is a problem because: (i) the cygdrive prefix might be different,
 106          and (ii) the target drive might not exist, on the install system.
 107
 108          Because of these problems, we don't expect any install packages to have
 109          links like that (they should instead be created by post-install
 110          scripts), but fail if they do.
 111       */
 112       if ((strncmp(to, "/cygdrive", 9) == 0) ||
 113           (strncmp(to, "/proc/cygdrive", 14) == 0))
 114         {
 115           Log (LOG_PLAIN) << "Refusing to create WSL symlink to" << to << " as it starts with /cygdrive" << endLog;
 116           return 1;
 117         }
 118
 119       /* Otherwise, we convert the absolute path 'to' into a form a WSL
 120          compatible form, constructed from the '/mnt' prefix and the cygwin root
 121          directory e.g. /mnt/c/cygwin64/ */
 122       lxsymto = "/mnt/";
 123       std::string root = get_root_dir();
 124       if (root[1] == ':')
 125         {
 126           lxsymto.append(1, tolower(root.c_str()[0]));
 127           lxsymto.append("/");
 128           lxsymto.append(&(root[3]));
 129         }
 130       else
 131         {
 132           // root dir is UNC path ???
 133           lxsymto.append(root.c_str());
 134         }
 135       lxsymto.append(to);
 136     }
 137   else
 138     {
 139       /* Otherwise 'to' is relative to 'from', so leave it alone */
 140       lxsymto = to;
 141     }
 142
 143   /* Create reparse point. */
 144   SECURITY_DESCRIPTOR sd;
 145   acl_t acl;
 146   nt_sec.GetPosixPerms (from, NULL, NULL, 0644, sd, acl);
 147
 148   const size_t flen = strlen (from) + 7;
 149   WCHAR wfrom[flen];
 150   mklongpath (wfrom, from, flen);
 151   wfrom[1] = '?';
 152
 153   HANDLE fh;
 154   UNICODE_STRING ufrom;
 155   IO_STATUS_BLOCK io;
 156   OBJECT_ATTRIBUTES attr;
 157   RtlInitUnicodeString (&ufrom, wfrom);
 158   InitializeObjectAttributes (&attr, &ufrom, OBJ_CASE_INSENSITIVE, NULL, &sd);
 159   NTSTATUS status = NtCreateFile (&fh,
 160                          DELETE | FILE_GENERIC_WRITE | READ_CONTROL | WRITE_DAC,
 161                          &attr,
 162                          &io,
 163                          NULL,
 164                          FILE_ATTRIBUTE_NORMAL,
 165                          FILE_SHARE_VALID_FLAGS,
 166                          FILE_CREATE,
 167                          FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
 168                          | FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_REPARSE_POINT,
 169                          NULL, 0);
 170   if (!NT_SUCCESS (status))
 171     {
 172       Log (LOG_PLAIN) << "NtCreateFile status " << std::hex << status << endLog;
 173       return 1;
 174     }
 175
 176   /* Set content of the reparse point */
 177   size_t tlen = lxsymto.length();
 178   REPARSE_LX_SYMLINK_BUFFER *rpl = (REPARSE_LX_SYMLINK_BUFFER *) new char[sizeof(REPARSE_LX_SYMLINK_BUFFER) + tlen];
 179   rpl->ReparseTag = IO_REPARSE_TAG_LX_SYMLINK;
 180   rpl->ReparseDataLength = sizeof (DWORD) + tlen;
 181   rpl->Reserved = 0;
 182   rpl->LxSymlinkReparseBuffer.FileType = 2;
 183   memcpy(rpl->LxSymlinkReparseBuffer.PathBuffer, lxsymto.c_str(), tlen);
 184
 185   status = NtFsControlFile (fh, NULL, NULL, NULL, &io, FSCTL_SET_REPARSE_POINT,
 186                             (LPVOID) rpl,
 187                             REPARSE_DATA_BUFFER_HEADER_SIZE + rpl->ReparseDataLength,
 188                             NULL, 0);
 189   if (!NT_SUCCESS (status))
 190     {
 191       Log (LOG_PLAIN) << "FSCTL_SET_REPARSE_POINT status " << std::hex << status << endLog;
 192     }
 193
 194   delete rpl;
 195   NtClose(fh);
 196   return NT_SUCCESS (status) ? 0 : 1;
 197 }
 198
 199 static int
 200 mknativesymlink (const char *from, const char *to)
 201 {
 202   /* Construct the absolute Windows path of 'to' ... */
 203   std::string absto;
 204   if (to[0] == '/')
 205     {
 206       absto = get_root_dir();
 207       absto.append(to);
 208     }
 209   else
 210     {
 211       /* 'from' is already absolute */
 212       absto.append(from);
 213       /* remove the last pathname component */
 214       size_t i = absto.rfind('/');
 215       if (i != std::string::npos)
 216         absto.resize(i);
 217       /* ... and add relative path 'to'. */
 218       absto.append("/");
 219       absto.append(to);
 220     }
 221
 222   /* ... so we can discover if it's a file or directory (if it already exists) */
 223   size_t abstlen = strlen (absto.c_str()) + 7;
 224   wchar_t wabsto[abstlen];
 225   mklongpath (wabsto, absto.c_str(), abstlen);
 226   wabsto[1] = '?';
 227
 228   bool isdir = FALSE;
 229   bool isdir_known = FALSE;
 230   HANDLE fh;
 231   NTSTATUS status;
 232   UNICODE_STRING uto;
 233   OBJECT_ATTRIBUTES attr;
 234   IO_STATUS_BLOCK io;
 235   RtlInitUnicodeString (&uto, wabsto);
 236   InitializeObjectAttributes (&attr, &uto, OBJ_CASE_INSENSITIVE, NULL, NULL);
 237   status = NtOpenFile (&fh, FILE_READ_ATTRIBUTES, &attr, &io, FILE_SHARE_VALID_FLAGS,
 238                        FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_REPARSE_POINT);
 239   if (NT_SUCCESS (status))
 240     {
 241       FILE_BASIC_INFORMATION fi;
 242       status = NtQueryInformationFile(fh, &io, &fi, sizeof(fi), FileBasicInformation);
 243       if (!NT_SUCCESS (status))
 244         Log (LOG_BABBLE) << "Querying " << absto << " failed " << std::hex << status << endLog;
 245       else
 246         {
 247           isdir = fi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY;
 248           isdir_known = TRUE;
 249           Log (LOG_BABBLE) << "Querying " << absto << " isdir is " << isdir << endLog;
 250         }
 251       NtClose(fh);
 252     }
 253   else
 254     {
 255       Log (LOG_BABBLE) << "Opening " << absto << " failed " << std::hex << status << endLog;
 256     }
 257
 258   /*
 259     Fail, if we failed to determine if the symlink target is a directory
 260     (probably because it doesn't exist (yet))
 261
 262     (We could guess that it's a file, since that works for Cygwin (and WSL),
 263     which don't care if the directory flag in the symlink is wrong (when the
 264     target comes into existence), but native tools will fail.
 265   */
 266
 267   if (!isdir_known)
 268     return 1;
 269
 270   /* Try to create the native symlink. */
 271   const size_t flen = strlen (from) + 7;
 272   WCHAR wfrom[flen];
 273   mklongpath (wfrom, from, flen);
 274   wfrom[1] = '?';
 275
 276   size_t tlen = strlen (to) + 7;
 277   wchar_t wrelto[tlen];
 278   wchar_t *wto;
 279   if (to[0] == '/')
 280     {
 281       wto = wabsto;
 282       // convert back from nt namespace to win32 file namespace to use with
 283       // CreateSymbolicLinkW()
 284       wabsto[1] = '\\';
 285       // Some parts of Windows don't correctly handle a win32 file namespace
 286       // prefix in the symlink target. So, for maximum interoperability, we use
 287       // a short path instead, if the target path will be less than MAX_PATH.
 288       if (wcslen(wabsto) < (MAX_PATH + 4))
 289         wto = wabsto + 4;
 290     }
 291   else
 292     {
 293       mklongrelpath (wrelto, to, tlen);
 294       wto = wrelto;
 295     }
 296
 297   DWORD flags = isdir ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
 298   /* Windows 10 1703 and later allow unprivileged symlink creation when
 299      'Developer Mode' is on.*/
 300   VersionInfo v = GetVer();
 301   if ((v.major() > 10) ||
 302       ((v.major() == 10) && (v.buildNumber() >= 15063)))
 303     flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
 304
 305   status = CreateSymbolicLinkW (wfrom, wto, flags);
 306
 307   if (!status)
 308     Log (LOG_PLAIN) << "Linking " << from << " to " << to << " failed " << std::hex << GetLastError() << endLog;
 309
 310   return !status;
 311 }
 312
 313 int
 314 mkcygsymlink (const char *from, const char *to)
 315 {
 316   if (symlinkType == SymlinkTypeWsl)
 317     {
 318       if (!mkwslsymlink (from, to))
 319         return 0;
 320     }
 321
 322   if (symlinkType == SymlinkTypeNative)
 323     {
 324       if (!mknativesymlink (from, to))
 325         return 0;
 326     }
 327
 328   /* fall back to magic symlink, if selected method fails */
 329   return mkmagiccygsymlink(from, to);
 330 }
 331
 332 static struct {
 333   FILE_LINK_INFORMATION fli;
 334   WCHAR namebuf[32768];
 335 } sfli;
 336
 337 extern "C"
 338 int
 339 mkcyghardlink (const char *from, const char *to)
 340 {
 341   size_t flen = strlen (from) + 7;
 342   size_t tlen = strlen (to) + 7;
 343   wchar_t wfrom[flen];
 344   wchar_t wto[tlen];
 345   mklongpath (wfrom, from, flen);
 346   wfrom[1] = '?';
 347   mklongpath (wto, to, tlen);
 348   wto[1] = '?';
 349
 350   HANDLE fh;
 351   NTSTATUS status;
 352   UNICODE_STRING uto;
 353   OBJECT_ATTRIBUTES attr;
 354   IO_STATUS_BLOCK io;
 355
 356   /* Open the existing file. */
 357   RtlInitUnicodeString (&uto, wto);
 358   InitializeObjectAttributes (&attr, &uto, OBJ_CASE_INSENSITIVE, NULL, NULL);
 359   status = NtOpenFile (&fh, READ_CONTROL, &attr, &io, FILE_SHARE_VALID_FLAGS,
 360                        FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_REPARSE_POINT);
 361   if (!NT_SUCCESS (status))
 362     return 1;
 363   /* Create from as link to to. */
 364   flen = wcslen (wfrom) * sizeof (WCHAR);
 365   ULONG size = sizeof (FILE_LINK_INFORMATION) + flen;
 366   sfli.fli.ReplaceIfExists = TRUE;
 367   sfli.fli.RootDirectory = NULL;
 368   sfli.fli.FileNameLength = flen;
 369   memcpy (sfli.fli.FileName, wfrom, flen);
 370   status = NtSetInformationFile (fh, &io, &sfli.fli, size, FileLinkInformation);
 371   NtClose (fh);
 372   return NT_SUCCESS (status) ? 0 : 1;
 373 }