lib/kernel32/file/curdir.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/kernel32/file/curdir.c
   6  * PURPOSE:         Current directory functions
   7  * UPDATE HISTORY:
   8  *                  Created 30/09/98
   9  */
  10
  11
  12 /* INCLUDES ******************************************************************/
  13
  14 #include <k32.h>
  15
  16 #define NDEBUG
  17 #include <kernel32/kernel32.h>
  18
  19
  20 /* GLOBAL VARIABLES **********************************************************/
  21
  22 UNICODE_STRING SystemDirectory;
  23 UNICODE_STRING WindowsDirectory;
  24
  25
  26 /* FUNCTIONS *****************************************************************/
  27
  28 DWORD
  29 STDCALL
  30 GetCurrentDirectoryA (
  31         DWORD   nBufferLength,
  32         LPSTR   lpBuffer
  33         )
  34 {
  35         ANSI_STRING AnsiString;
  36         UNICODE_STRING UnicodeString;
  37
  38         /* initialize ansi string */
  39         AnsiString.Length = 0;
  40         AnsiString.MaximumLength = nBufferLength;
  41         AnsiString.Buffer = lpBuffer;
  42
  43         /* allocate buffer for unicode string */
  44         UnicodeString.Length = 0;
  45         UnicodeString.MaximumLength = nBufferLength * sizeof(WCHAR);
  46         UnicodeString.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
  47                                                 0,
  48                                                 UnicodeString.MaximumLength);
  49
  50         /* get current directory */
  51         UnicodeString.Length = RtlGetCurrentDirectory_U (UnicodeString.MaximumLength,
  52                                                          UnicodeString.Buffer);
  53         DPRINT("UnicodeString.Buffer %S\n", UnicodeString.Buffer);
  54
  55         /* convert unicode string to ansi (or oem) */
  56         if (bIsFileApiAnsi)
  57                 RtlUnicodeStringToAnsiString (&AnsiString,
  58                                               &UnicodeString,
  59                                               FALSE);
  60         else
  61                 RtlUnicodeStringToOemString (&AnsiString,
  62                                              &UnicodeString,
  63                                              FALSE);
  64         DPRINT("AnsiString.Buffer %s\n", AnsiString.Buffer);
  65
  66         /* free unicode string */
  67         RtlFreeHeap (RtlGetProcessHeap (),
  68                      0,
  69                      UnicodeString.Buffer);
  70
  71         return AnsiString.Length;
  72 }
  73
  74
  75 DWORD
  76 STDCALL
  77 GetCurrentDirectoryW (
  78         DWORD   nBufferLength,
  79         LPWSTR  lpBuffer
  80         )
  81 {
  82         ULONG Length;
  83
  84         Length = RtlGetCurrentDirectory_U (nBufferLength,
  85                                            lpBuffer);
  86
  87         return (Length / sizeof (WCHAR));
  88 }
  89
  90
  91 WINBOOL
  92 STDCALL
  93 SetCurrentDirectoryA (
  94         LPCSTR  lpPathName
  95         )
  96 {
  97         ANSI_STRING AnsiString;
  98         UNICODE_STRING UnicodeString;
  99         NTSTATUS Status;
 100
 101         RtlInitAnsiString (&AnsiString,
 102                            (LPSTR)lpPathName);
 103
 104         /* convert ansi (or oem) to unicode */
 105         if (bIsFileApiAnsi)
 106                 RtlAnsiStringToUnicodeString (&UnicodeString,
 107                                               &AnsiString,
 108                                               TRUE);
 109         else
 110                 RtlOemStringToUnicodeString (&UnicodeString,
 111                                              &AnsiString,
 112                                              TRUE);
 113
 114         Status = RtlSetCurrentDirectory_U (&UnicodeString);
 115
 116         RtlFreeUnicodeString (&UnicodeString);
 117
 118         if (!NT_SUCCESS(Status))
 119         {
 120                 SetLastErrorByStatus (Status);
 121                 return FALSE;
 122         }
 123
 124         return TRUE;
 125 }
 126
 127
 128 WINBOOL
 129 STDCALL
 130 SetCurrentDirectoryW (
 131         LPCWSTR lpPathName
 132         )
 133 {
 134         UNICODE_STRING UnicodeString;
 135         NTSTATUS Status;
 136
 137         RtlInitUnicodeString (&UnicodeString,
 138                               lpPathName);
 139
 140         Status = RtlSetCurrentDirectory_U (&UnicodeString);
 141         if (!NT_SUCCESS(Status))
 142         {
 143                 SetLastErrorByStatus (Status);
 144                 return FALSE;
 145         }
 146
 147         return TRUE;
 148 }
 149
 150
 151 DWORD
 152 STDCALL
 153 GetTempPathA (
 154         DWORD   nBufferLength,
 155         LPSTR   lpBuffer
 156         )
 157 {
 158         UNICODE_STRING UnicodeString;
 159         ANSI_STRING AnsiString;
 160
 161         AnsiString.Length = 0;
 162         AnsiString.MaximumLength = nBufferLength;
 163         AnsiString.Buffer = lpBuffer;
 164
 165         /* initialize allocate unicode string */
 166         UnicodeString.Length = 0;
 167         UnicodeString.MaximumLength = nBufferLength * sizeof(WCHAR);
 168         UnicodeString.Buffer = RtlAllocateHeap (RtlGetProcessHeap(),
 169                                                 0,
 170                                                 UnicodeString.MaximumLength);
 171
 172         UnicodeString.Length = GetTempPathW (nBufferLength,
 173                                              UnicodeString.Buffer) * sizeof(WCHAR);
 174
 175         /* convert unicode string to ansi (or oem) */
 176         if (bIsFileApiAnsi)
 177                 RtlUnicodeStringToAnsiString (&AnsiString,
 178                                               &UnicodeString,
 179                                               FALSE);
 180         else
 181                 RtlUnicodeStringToOemString (&AnsiString,
 182                                              &UnicodeString,
 183                                              FALSE);
 184
 185         /* free unicode string buffer */
 186         RtlFreeHeap (RtlGetProcessHeap (),
 187                      0,
 188                      UnicodeString.Buffer);
 189
 190         return AnsiString.Length;
 191 }
 192
 193
 194 DWORD
 195 STDCALL
 196 GetTempPathW (
 197         DWORD   nBufferLength,
 198         LPWSTR  lpBuffer
 199         )
 200 {
 201         UNICODE_STRING Name;
 202         UNICODE_STRING Value;
 203         NTSTATUS Status;
 204
 205         Value.Length = 0;
 206         Value.MaximumLength = (nBufferLength - 1) * sizeof(WCHAR);
 207         Value.Buffer = lpBuffer;
 208
 209         RtlInitUnicodeStringFromLiteral (&Name,
 210                               L"TMP");
 211
 212         Status = RtlQueryEnvironmentVariable_U (NULL,
 213                                                 &Name,
 214                                                 &Value);
 215         if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL)
 216         {
 217                 RtlInitUnicodeStringFromLiteral (&Name,
 218                                       L"TEMP");
 219
 220                 Status = RtlQueryEnvironmentVariable_U (NULL,
 221                                                         &Name,
 222                                                         &Value);
 223
 224                 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL)
 225                 {
 226                         Value.Length = RtlGetCurrentDirectory_U (Value.MaximumLength,
 227                                                                  Value.Buffer);
 228                 }
 229         }
 230
 231         if (NT_SUCCESS(Status))
 232         {
 233                 lpBuffer[Value.Length / sizeof(WCHAR)] = L'\\';
 234                 lpBuffer[Value.Length / sizeof(WCHAR) + 1] = 0;
 235         }
 236
 237         return Value.Length / sizeof(WCHAR) + 1;
 238 }
 239
 240
 241 UINT
 242 STDCALL
 243 GetSystemDirectoryA (
 244         LPSTR   lpBuffer,
 245         UINT    uSize
 246         )
 247 {
 248         ANSI_STRING String;
 249         ULONG Length;
 250         NTSTATUS Status;
 251
 252         if (lpBuffer == NULL)
 253                 return 0;
 254
 255         Length = RtlUnicodeStringToAnsiSize (&SystemDirectory);   //len of ansi str incl. nullchar
 256
 257         if (uSize >= Length){
 258                 String.Length = 0;
 259                 String.MaximumLength = uSize;
 260                 String.Buffer = lpBuffer;
 261
 262                 /* convert unicode string to ansi (or oem) */
 263                 if (bIsFileApiAnsi)
 264                         Status = RtlUnicodeStringToAnsiString (&String,
 265                                                       &SystemDirectory,
 266                                                       FALSE);
 267                 else
 268                         Status = RtlUnicodeStringToOemString (&String,
 269                                                      &SystemDirectory,
 270                                                      FALSE);
 271                 if (!NT_SUCCESS(Status) )
 272                         return 0;
 273
 274                 return Length-1;  //good: ret chars excl. nullchar
 275
 276         }
 277
 278         return Length;   //bad: ret space needed incl. nullchar
 279 }
 280
 281
 282 UINT
 283 STDCALL
 284 GetSystemDirectoryW (
 285         LPWSTR  lpBuffer,
 286         UINT    uSize
 287         )
 288 {
 289         ULONG Length;
 290
 291         if (lpBuffer == NULL)
 292                 return 0;
 293
 294         Length = SystemDirectory.Length / sizeof (WCHAR);
 295         if (uSize > Length)     {
 296                 memmove (lpBuffer,
 297                          SystemDirectory.Buffer,
 298                          SystemDirectory.Length);
 299                 lpBuffer[Length] = 0;
 300
 301                 return Length;    //good: ret chars excl. nullchar
 302         }
 303
 304         return Length+1;         //bad: ret space needed incl. nullchar
 305 }
 306
 307
 308 UINT
 309 STDCALL
 310 GetWindowsDirectoryA (
 311         LPSTR   lpBuffer,
 312         UINT    uSize
 313         )
 314 {
 315         ANSI_STRING String;
 316         ULONG Length;
 317         NTSTATUS Status;
 318
 319         if (lpBuffer == NULL)
 320                 return 0;
 321
 322         Length = RtlUnicodeStringToAnsiSize (&WindowsDirectory); //len of ansi str incl. nullchar
 323
 324         if (uSize >= Length){
 325
 326                 String.Length = 0;
 327                 String.MaximumLength = uSize;
 328                 String.Buffer = lpBuffer;
 329
 330                 /* convert unicode string to ansi (or oem) */
 331                 if (bIsFileApiAnsi)
 332                         Status = RtlUnicodeStringToAnsiString (&String,
 333                                                       &WindowsDirectory,
 334                                                       FALSE);
 335                 else
 336                         Status = RtlUnicodeStringToOemString (&String,
 337                                                      &WindowsDirectory,
 338                                                      FALSE);
 339
 340                 if (!NT_SUCCESS(Status))
 341                         return 0;
 342
 343                 return Length-1;        //good: ret chars excl. nullchar
 344         }
 345
 346         return Length;  //bad: ret space needed incl. nullchar
 347 }
 348
 349
 350 UINT
 351 STDCALL
 352 GetWindowsDirectoryW (
 353         LPWSTR  lpBuffer,
 354         UINT    uSize
 355         )
 356 {
 357         ULONG Length;
 358
 359         if (lpBuffer == NULL)
 360                 return 0;
 361
 362         Length = WindowsDirectory.Length / sizeof (WCHAR);
 363         if (uSize > Length)
 364         {
 365                 memmove (lpBuffer,
 366                          WindowsDirectory.Buffer,
 367                          WindowsDirectory.Length);
 368                 lpBuffer[Length] = 0;
 369
 370                 return Length;    //good: ret chars excl. nullchar
 371         }
 372
 373         return Length+1;        //bad: ret space needed incl. nullchar
 374 }
 375
 376 /* EOF */