reactos/lib/kernel32/file/curdir.c

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