base/system/subst/subst.c

   1 /*
   2  * PROJECT:         ReactOS Subst Command
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            base/system/subst/subst.c
   5  * PURPOSE:         Maps a path with a drive letter
   6  * PROGRAMMERS:     Sam Arun Raj
   7  *                  Peter Hater
   8  *                  Hermes Belusca-Maito
   9  */
  10
  11 /* INCLUDES *****************************************************************/
  12
  13 #include <stdio.h>
  14
  15 #define WIN32_NO_STATUS
  16 #include <windef.h>
  17 #include <winbase.h>
  18
  19 #include <conutils.h>
  20
  21 #include "resource.h"
  22
  23 /* FUNCTIONS ****************************************************************/
  24
  25 VOID PrintError(IN DWORD ErrCode)
  26 {
  27     // DWORD dwLength = 0;
  28     PWSTR pMsgBuf  = NULL;
  29
  30 #if 0
  31     if (ErrCode == ERROR_SUCCESS)
  32         return;
  33 #endif
  34
  35     /* Retrieve the message string without appending extra newlines */
  36     // dwLength =
  37     FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
  38                    FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_MAX_WIDTH_MASK,
  39                    NULL,
  40                    ErrCode,
  41                    LANG_USER_DEFAULT,
  42                    (PWSTR)&pMsgBuf,
  43                    0, NULL);
  44     if (pMsgBuf /* && dwLength */)
  45     {
  46         ConResPrintf(StdErr, IDS_FAILED_WITH_ERRORCODE,
  47                      ErrCode, pMsgBuf);
  48         LocalFree(pMsgBuf);
  49     }
  50 }
  51
  52 ULONG QuerySubstedDrive(IN WCHAR DriveLetter,
  53                         IN OUT PWSTR* TargetPath OPTIONAL,
  54                         IN OUT PULONG Size)
  55 {
  56     ULONG Result = ERROR_INVALID_DRIVE;
  57     WCHAR Drive[] = L"A:";
  58     DWORD dwSize, CharCount = 0;
  59     PWSTR lpTargetPath = NULL, tmp;
  60
  61     Drive[0] = DriveLetter;
  62
  63     /* Check whether the user has given a pointer to a target path buffer */
  64     if (!TargetPath)
  65     {
  66         /* No, therefore use a local buffer */
  67         dwSize = MAX_PATH;
  68         lpTargetPath = (PWSTR)HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
  69         if (!lpTargetPath)
  70             return ERROR_NOT_ENOUGH_MEMORY;
  71     }
  72     else
  73     {
  74         /* Just use the user-given pointer to a buffer; Size should point to a valid ULONG */
  75         if (!Size)
  76             return ERROR_INVALID_PARAMETER;
  77
  78         lpTargetPath = *TargetPath;
  79         dwSize = *Size;
  80     }
  81
  82 Retry:
  83     /* Try querying DOS device information */
  84     CharCount = QueryDosDeviceW(Drive, lpTargetPath, dwSize);
  85     if (!CharCount)
  86         Result = GetLastError();
  87
  88     if (!CharCount && (Result == ERROR_INSUFFICIENT_BUFFER))
  89     {
  90         /* Reallocate the buffer with double size */
  91         dwSize *= 2;
  92         tmp = (PWSTR)HeapReAlloc(GetProcessHeap(), 0, lpTargetPath, dwSize * sizeof(WCHAR));
  93         if (!tmp)
  94         {
  95             /* Memory problem, bail out */
  96             CharCount = 0;
  97             Result = ERROR_NOT_ENOUGH_MEMORY;
  98         }
  99         else
 100         {
 101             /* Retry again */
 102             lpTargetPath = tmp;
 103             goto Retry;
 104         }
 105     }
 106
 107     if (CharCount)
 108     {
 109         if ( wcsncmp(lpTargetPath, L"\\??\\", 4) == 0 &&
 110              ( (lpTargetPath[4] >= L'A' && lpTargetPath[4] <= L'Z') ||
 111                (lpTargetPath[4] >= L'a' && lpTargetPath[4] <= L'z') ) )
 112         {
 113             /* The drive exists and is SUBSTed */
 114             Result = ERROR_IS_SUBSTED;
 115         }
 116 #if 0
 117         else
 118         {
 119             /* The drive exists but is not SUBSTed */
 120             Result = ERROR_INVALID_DRIVE;
 121         }
 122 #endif
 123     }
 124
 125     if (!TargetPath)
 126     {
 127         /* Free the local buffer */
 128         HeapFree(GetProcessHeap(), 0, lpTargetPath);
 129     }
 130     else
 131     {
 132         /* Update the user-given pointers */
 133         *TargetPath = lpTargetPath;
 134         *Size = dwSize;
 135     }
 136
 137     return Result;
 138 }
 139
 140 VOID DumpSubstedDrives(VOID)
 141 {
 142     WCHAR DriveLetter;
 143     PWSTR lpTargetPath = NULL;
 144     DWORD dwSize;
 145     UCHAR i = 0;
 146
 147     dwSize = MAX_PATH;
 148     lpTargetPath = (PWSTR)HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
 149     if (!lpTargetPath)
 150         return;
 151
 152     while (i < 26)
 153     {
 154         DriveLetter = L'A' + i;
 155         if (QuerySubstedDrive(DriveLetter, &lpTargetPath, &dwSize) == ERROR_IS_SUBSTED)
 156         {
 157             ConPrintf(StdOut, L"%c:\\: => %s\n", DriveLetter, lpTargetPath + 4);
 158         }
 159
 160         i++;
 161     }
 162
 163     HeapFree(GetProcessHeap(), 0, lpTargetPath);
 164 }
 165
 166 INT DeleteSubst(IN PWSTR Drive)
 167 {
 168     DWORD dwResult;
 169
 170     if ((wcslen(Drive) != 2) || (Drive[1] != L':'))
 171     {
 172         dwResult = ERROR_INVALID_PARAMETER;
 173         goto Quit;
 174     }
 175
 176     if (QuerySubstedDrive(Drive[0], NULL, NULL) != ERROR_IS_SUBSTED)
 177     {
 178         dwResult = ERROR_INVALID_PARAMETER;
 179         goto Quit;
 180     }
 181
 182     if (!DefineDosDeviceW(DDD_REMOVE_DEFINITION, Drive, NULL))
 183         dwResult = GetLastError();
 184     else
 185         dwResult = ERROR_SUCCESS;
 186
 187 Quit:
 188     switch (dwResult)
 189     {
 190         case ERROR_SUCCESS:
 191             break;
 192
 193         // case ERROR_INVALID_DRIVE:
 194         case ERROR_INVALID_PARAMETER:
 195         {
 196             ConResPrintf(StdErr, IDS_INVALID_PARAMETER2, Drive);
 197             return 1;
 198         }
 199
 200         case ERROR_ACCESS_DENIED:
 201         {
 202             ConResPrintf(StdErr, IDS_ACCESS_DENIED, Drive);
 203             return 1;
 204         }
 205
 206         default:
 207         {
 208             PrintError(GetLastError());
 209             return 1;
 210         }
 211     }
 212
 213     return 0;
 214 }
 215
 216 INT AddSubst(IN PWSTR Drive, IN PWSTR Path)
 217 {
 218     DWORD dwResult, dwPathAttr;
 219
 220     if ((wcslen(Drive) != 2) || (Drive[1] != L':'))
 221     {
 222         dwResult = ERROR_INVALID_PARAMETER;
 223         goto Quit;
 224     }
 225
 226     /*
 227      * Even if DefineDosDevice allows to map files to drive letters (yes yes!!)
 228      * it is not the purpose of SUBST to allow that. Therefore check whether
 229      * the given path exists and really is a path to a directory, and if not,
 230      * just fail with an error.
 231      */
 232     dwPathAttr = GetFileAttributesW(Path);
 233     if ( (dwPathAttr == INVALID_FILE_ATTRIBUTES) ||
 234         !(dwPathAttr & FILE_ATTRIBUTE_DIRECTORY) )
 235     {
 236         dwResult = ERROR_PATH_NOT_FOUND;
 237         goto Quit;
 238     }
 239
 240     /*
 241      * QuerySubstedDrive (via QueryDosDevice) returns ERROR_FILE_NOT_FOUND only
 242      * if there is no already existing drive mapping. For all other results
 243      * (existing drive, be it already subst'ed or not, or other errors...)
 244      * no attempt at defining a drive mapping should be done.
 245      */
 246     dwResult = QuerySubstedDrive(Drive[0], NULL, NULL);
 247     if (dwResult != ERROR_FILE_NOT_FOUND)
 248         goto Quit;
 249
 250     if (!DefineDosDeviceW(0, Drive, Path))
 251         dwResult = GetLastError();
 252     else
 253         dwResult = ERROR_SUCCESS;
 254
 255 Quit:
 256     switch (dwResult)
 257     {
 258         case ERROR_SUCCESS:
 259             break;
 260
 261         case ERROR_INVALID_DRIVE:
 262         case ERROR_INVALID_PARAMETER:
 263         {
 264             ConResPrintf(StdErr, IDS_INVALID_PARAMETER2, Drive);
 265             return 1;
 266         }
 267
 268         case ERROR_IS_SUBSTED:
 269         {
 270             ConResPuts(StdErr, IDS_DRIVE_ALREADY_SUBSTED);
 271             return 1;
 272         }
 273
 274         case ERROR_FILE_NOT_FOUND:
 275         case ERROR_PATH_NOT_FOUND:
 276         {
 277             ConResPrintf(StdErr, IDS_PATH_NOT_FOUND, Path);
 278             return 1;
 279         }
 280
 281         case ERROR_ACCESS_DENIED:
 282         {
 283             ConResPrintf(StdErr, IDS_ACCESS_DENIED, Path);
 284             return 1;
 285         }
 286
 287         default:
 288         {
 289             PrintError(GetLastError());
 290             return 1;
 291         }
 292     }
 293
 294     return 0;
 295 }
 296
 297 int wmain(int argc, WCHAR* argv[])
 298 {
 299     INT i;
 300
 301     /* Initialize the Console Standard Streams */
 302     ConInitStdStreams();
 303
 304     for (i = 0; i < argc; i++)
 305     {
 306         if (!_wcsicmp(argv[i], L"/?"))
 307         {
 308             ConResPuts(StdOut, IDS_USAGE);
 309             return 0;
 310         }
 311     }
 312
 313     if (argc < 3)
 314     {
 315         if (argc >= 2)
 316         {
 317             ConResPrintf(StdErr, IDS_INVALID_PARAMETER, argv[1]);
 318             return 1;
 319         }
 320         DumpSubstedDrives();
 321         return 0;
 322     }
 323
 324     if (argc > 3)
 325     {
 326         ConResPrintf(StdErr, IDS_INCORRECT_PARAMETER_COUNT, argv[3]);
 327         return 1;
 328     }
 329
 330     if (!_wcsicmp(argv[1], L"/D"))
 331         return DeleteSubst(argv[2]);
 332     if (!_wcsicmp(argv[2], L"/D"))
 333         return DeleteSubst(argv[1]);
 334     return AddSubst(argv[1], argv[2]);
 335 }
 336
 337 /* EOF */