reactos/lib/kernel32/file/curdir.c

   1 /* $Id: curdir.c,v 1.33 2002/11/07 02:52:37 robd 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         NTSTATUS Status;
 254
 255         if (lpBuffer == NULL)
 256                 return 0;
 257
 258         Length = RtlUnicodeStringToAnsiSize (&SystemDirectory);   //len of ansi str incl. nullchar
 259
 260         if (uSize >= Length){
 261                 String.Length = 0;
 262                 String.MaximumLength = uSize;
 263                 String.Buffer = lpBuffer;
 264
 265                 /* convert unicode string to ansi (or oem) */
 266                 if (bIsFileApiAnsi)
 267                         Status = RtlUnicodeStringToAnsiString (&String,
 268                                                       &SystemDirectory,
 269                                                       FALSE);
 270                 else
 271                         Status = RtlUnicodeStringToOemString (&String,
 272                                                      &SystemDirectory,
 273                                                      FALSE);
 274                 if (!NT_SUCCESS(Status) )
 275                         return 0;
 276
 277                 return Length-1;  //good: ret chars excl. nullchar
 278
 279         }
 280
 281         return Length;   //bad: ret space needed incl. nullchar
 282 }
 283
 284
 285 UINT
 286 STDCALL
 287 GetSystemDirectoryW (
 288         LPWSTR  lpBuffer,
 289         UINT    uSize
 290         )
 291 {
 292         ULONG Length;
 293
 294         if (lpBuffer == NULL)
 295                 return 0;
 296
 297         Length = SystemDirectory.Length / sizeof (WCHAR);
 298         if (uSize > Length)     {
 299                 memmove (lpBuffer,
 300                          SystemDirectory.Buffer,
 301                          SystemDirectory.Length);
 302                 lpBuffer[Length] = 0;
 303
 304                 return Length;    //good: ret chars excl. nullchar
 305         }
 306
 307         return Length+1;         //bad: ret space needed incl. nullchar
 308 }
 309
 310
 311 UINT
 312 STDCALL
 313 GetWindowsDirectoryA (
 314         LPSTR   lpBuffer,
 315         UINT    uSize
 316         )
 317 {
 318         ANSI_STRING String;
 319         ULONG Length;
 320         NTSTATUS Status;
 321
 322         if (lpBuffer == NULL)
 323                 return 0;
 324
 325         Length = RtlUnicodeStringToAnsiSize (&WindowsDirectory); //len of ansi str incl. nullchar
 326
 327         if (uSize >= Length){
 328
 329                 String.Length = 0;
 330                 String.MaximumLength = uSize;
 331                 String.Buffer = lpBuffer;
 332
 333                 /* convert unicode string to ansi (or oem) */
 334                 if (bIsFileApiAnsi)
 335                         Status = RtlUnicodeStringToAnsiString (&String,
 336                                                       &WindowsDirectory,
 337                                                       FALSE);
 338                 else
 339                         Status = RtlUnicodeStringToOemString (&String,
 340                                                      &WindowsDirectory,
 341                                                      FALSE);
 342
 343                 if (!NT_SUCCESS(Status))
 344                         return 0;
 345
 346                 return Length-1;        //good: ret chars excl. nullchar
 347         }
 348
 349         return Length;  //bad: ret space needed incl. nullchar
 350 }
 351
 352
 353 UINT
 354 STDCALL
 355 GetWindowsDirectoryW (
 356         LPWSTR  lpBuffer,
 357         UINT    uSize
 358         )
 359 {
 360         ULONG Length;
 361
 362         if (lpBuffer == NULL)
 363                 return 0;
 364
 365         Length = WindowsDirectory.Length / sizeof (WCHAR);
 366         if (uSize > Length)
 367         {
 368                 memmove (lpBuffer,
 369                          WindowsDirectory.Buffer,
 370                          WindowsDirectory.Length);
 371                 lpBuffer[Length] = 0;
 372
 373                 return Length;    //good: ret chars excl. nullchar
 374         }
 375
 376         return Length+1;        //bad: ret space needed incl. nullchar
 377 }
 378
 379 /* EOF */