git.oblomov.eu Git - wine/blob - dlls/kernel32/file16.c

   1 /*
   2  * File handling functions
   3  *
   4  * Copyright 1993 John Burton
   5  * Copyright 1996 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * TODO:
  22  *    Fix the CopyFileEx methods to implement the "extended" functionality.
  23  *    Right now, they simply call the CopyFile method.
  24  */
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <assert.h>
  32
  33 #define NONAMELESSUNION
  34 #define NONAMELESSSTRUCT
  35 #include "winerror.h"
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winternl.h"
  39 #include "wine/winbase16.h"
  40 #include "kernel_private.h"
  41 #include "wine/unicode.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(file);
  45
  46
  47 /***********************************************************************
  48  *           GetProfileInt   (KERNEL.57)
  49  */
  50 UINT16 WINAPI GetProfileInt16( LPCSTR section, LPCSTR entry, INT16 def_val )
  51 {
  52     return GetPrivateProfileInt16( section, entry, def_val, "win.ini" );
  53 }
  54
  55
  56 /***********************************************************************
  57  *           GetProfileString   (KERNEL.58)
  58  */
  59 INT16 WINAPI GetProfileString16( LPCSTR section, LPCSTR entry, LPCSTR def_val,
  60                                  LPSTR buffer, UINT16 len )
  61 {
  62     return GetPrivateProfileString16( section, entry, def_val,
  63                                       buffer, len, "win.ini" );
  64 }
  65
  66
  67 /***********************************************************************
  68  *           WriteProfileString   (KERNEL.59)
  69  */
  70 BOOL16 WINAPI WriteProfileString16( LPCSTR section, LPCSTR entry,
  71                                     LPCSTR string )
  72 {
  73     return WritePrivateProfileString16( section, entry, string, "win.ini" );
  74 }
  75
  76
  77 /* get the search path for the current module; helper for OpenFile16 */
  78 static char *get_search_path(void)
  79 {
  80     UINT len;
  81     char *ret, *p, module[OFS_MAXPATHNAME];
  82
  83     module[0] = 0;
  84     if (GetCurrentTask() && GetModuleFileName16( GetCurrentTask(), module, sizeof(module) ))
  85     {
  86         if (!(p = strrchr( module, '\\' ))) p = module;
  87         *p = 0;
  88     }
  89
  90     len = (2 +                                              /* search order: first current dir */
  91            GetSystemDirectoryA( NULL, 0 ) + 1 +             /* then system dir */
  92            GetWindowsDirectoryA( NULL, 0 ) + 1 +            /* then windows dir */
  93            strlen( module ) + 1 +                           /* then module path */
  94            GetEnvironmentVariableA( "PATH", NULL, 0 ) + 1); /* then look in PATH */
  95     if (!(ret = HeapAlloc( GetProcessHeap(), 0, len ))) return NULL;
  96     strcpy( ret, ".;" );
  97     p = ret + 2;
  98     GetSystemDirectoryA( p, ret + len - p );
  99     p += strlen( p );
 100     *p++ = ';';
 101     GetWindowsDirectoryA( p, ret + len - p );
 102     p += strlen( p );
 103     *p++ = ';';
 104     if (module[0])
 105     {
 106         strcpy( p, module );
 107         p += strlen( p );
 108         *p++ = ';';
 109     }
 110     GetEnvironmentVariableA( "PATH", p, ret + len - p );
 111     return ret;
 112 }
 113
 114 /***********************************************************************
 115  *           OpenFile   (KERNEL.74)
 116  *           OpenFileEx (KERNEL.360)
 117  */
 118 HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
 119 {
 120     HFILE hFileRet;
 121     HANDLE handle;
 122     FILETIME filetime;
 123     WORD filedatetime[2];
 124     const char *p, *filename;
 125
 126     if (!ofs) return HFILE_ERROR;
 127
 128     TRACE("%s %s %s %s%s%s%s%s%s%s%s%s\n",debugstr_a(name),
 129           ((mode & 0x3 )==OF_READ)?"OF_READ":
 130           ((mode & 0x3 )==OF_WRITE)?"OF_WRITE":
 131           ((mode & 0x3 )==OF_READWRITE)?"OF_READWRITE":"unknown",
 132           ((mode & 0x70 )==OF_SHARE_COMPAT)?"OF_SHARE_COMPAT":
 133           ((mode & 0x70 )==OF_SHARE_DENY_NONE)?"OF_SHARE_DENY_NONE":
 134           ((mode & 0x70 )==OF_SHARE_DENY_READ)?"OF_SHARE_DENY_READ":
 135           ((mode & 0x70 )==OF_SHARE_DENY_WRITE)?"OF_SHARE_DENY_WRITE":
 136           ((mode & 0x70 )==OF_SHARE_EXCLUSIVE)?"OF_SHARE_EXCLUSIVE":"unknown",
 137           ((mode & OF_PARSE )==OF_PARSE)?"OF_PARSE ":"",
 138           ((mode & OF_DELETE )==OF_DELETE)?"OF_DELETE ":"",
 139           ((mode & OF_VERIFY )==OF_VERIFY)?"OF_VERIFY ":"",
 140           ((mode & OF_SEARCH )==OF_SEARCH)?"OF_SEARCH ":"",
 141           ((mode & OF_CANCEL )==OF_CANCEL)?"OF_CANCEL ":"",
 142           ((mode & OF_CREATE )==OF_CREATE)?"OF_CREATE ":"",
 143           ((mode & OF_PROMPT )==OF_PROMPT)?"OF_PROMPT ":"",
 144           ((mode & OF_EXIST )==OF_EXIST)?"OF_EXIST ":"",
 145           ((mode & OF_REOPEN )==OF_REOPEN)?"OF_REOPEN ":""
 146         );
 147
 148     if (mode & OF_PARSE)
 149     {
 150         OpenFile( name, ofs, mode );
 151         return 0;
 152     }
 153
 154     if (mode & OF_CREATE)
 155     {
 156         handle = (HANDLE)OpenFile( name, ofs, mode );
 157         if (handle == (HANDLE)HFILE_ERROR) goto error;
 158     }
 159     else
 160     {
 161         ofs->cBytes = sizeof(OFSTRUCT);
 162         ofs->nErrCode = 0;
 163         if (mode & OF_REOPEN) name = ofs->szPathName;
 164
 165         if (!name) return HFILE_ERROR;
 166
 167         /* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName
 168            Are there any cases where getting the path here is wrong?
 169            Uwe Bonnes 1997 Apr 2 */
 170         if (!GetFullPathNameA( name, sizeof(ofs->szPathName), ofs->szPathName, NULL )) goto error;
 171
 172         /* If OF_SEARCH is set, ignore the given path */
 173
 174         filename = name;
 175         if ((mode & OF_SEARCH) && !(mode & OF_REOPEN))
 176         {
 177             /* First try the file name as is */
 178             if (GetFileAttributesA( filename ) != INVALID_FILE_ATTRIBUTES) filename = NULL;
 179             else
 180             {
 181                 /* Now remove the path */
 182                 if (filename[0] && (filename[1] == ':')) filename += 2;
 183                 if ((p = strrchr( filename, '\\' ))) filename = p + 1;
 184                 if ((p = strrchr( filename, '/' ))) filename = p + 1;
 185                 if (!filename[0])
 186                 {
 187                     SetLastError( ERROR_FILE_NOT_FOUND );
 188                     goto error;
 189                 }
 190             }
 191         }
 192
 193         /* Now look for the file */
 194
 195         if (filename)
 196         {
 197             BOOL found;
 198             char *path = get_search_path();
 199
 200             if (!path) goto error;
 201             found = SearchPathA( path, filename, NULL, sizeof(ofs->szPathName),
 202                                  ofs->szPathName, NULL );
 203             HeapFree( GetProcessHeap(), 0, path );
 204             if (!found) goto error;
 205         }
 206
 207         TRACE("found %s\n", debugstr_a(ofs->szPathName) );
 208
 209         if (mode & OF_DELETE)
 210         {
 211             if (!DeleteFileA( ofs->szPathName )) goto error;
 212             TRACE("(%s): OF_DELETE return = OK\n", name);
 213             return 1;
 214         }
 215
 216         handle = (HANDLE)_lopen( ofs->szPathName, mode );
 217         if (handle == INVALID_HANDLE_VALUE) goto error;
 218
 219         GetFileTime( handle, NULL, NULL, &filetime );
 220         FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] );
 221         if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
 222         {
 223             if (ofs->Reserved1 != filedatetime[0] || ofs->Reserved2 != filedatetime[1] )
 224             {
 225                 CloseHandle( handle );
 226                 WARN("(%s): OF_VERIFY failed\n", name );
 227                 /* FIXME: what error here? */
 228                 SetLastError( ERROR_FILE_NOT_FOUND );
 229                 goto error;
 230             }
 231         }
 232         ofs->Reserved1 = filedatetime[0];
 233         ofs->Reserved2 = filedatetime[1];
 234     }
 235
 236     TRACE("(%s): OK, return = %p\n", name, handle );
 237     hFileRet = Win32HandleToDosFileHandle( handle );
 238     if (hFileRet == HFILE_ERROR16) goto error;
 239     if (mode & OF_EXIST) _lclose16( hFileRet ); /* Return the handle, but close it first */
 240     return hFileRet;
 241
 242 error:  /* We get here if there was an error opening the file */
 243     ofs->nErrCode = GetLastError();
 244     WARN("(%s): return = HFILE_ERROR error= %d\n", name,ofs->nErrCode );
 245     return HFILE_ERROR16;
 246 }
 247
 248
 249 /***********************************************************************
 250  *           _lclose   (KERNEL.81)
 251  */
 252 HFILE16 WINAPI _lclose16( HFILE16 hFile )
 253 {
 254     if ((hFile >= DOS_TABLE_SIZE) || !dos_handles[hFile])
 255     {
 256         SetLastError( ERROR_INVALID_HANDLE );
 257         return HFILE_ERROR16;
 258     }
 259     TRACE("%d (handle32=%p)\n", hFile, dos_handles[hFile] );
 260     CloseHandle( dos_handles[hFile] );
 261     dos_handles[hFile] = 0;
 262     return 0;
 263 }
 264
 265 /***********************************************************************
 266  *           _lcreat   (KERNEL.83)
 267  */
 268 HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
 269 {
 270     return Win32HandleToDosFileHandle( (HANDLE)_lcreat( path, attr ) );
 271 }
 272
 273 /***********************************************************************
 274  *           _llseek   (KERNEL.84)
 275  *
 276  * FIXME:
 277  *   Seeking before the start of the file should be allowed for _llseek16,
 278  *   but cause subsequent I/O operations to fail (cf. interrupt list)
 279  *
 280  */
 281 LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
 282 {
 283     return SetFilePointer( DosFileHandleToWin32Handle(hFile), lOffset, NULL, nOrigin );
 284 }
 285
 286
 287 /***********************************************************************
 288  *           _lopen   (KERNEL.85)
 289  */
 290 HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
 291 {
 292     return Win32HandleToDosFileHandle( (HANDLE)_lopen( path, mode ) );
 293 }
 294
 295
 296 /***********************************************************************
 297  *           _lread16   (KERNEL.82)
 298  */
 299 UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
 300 {
 301     return (UINT16)_lread((HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
 302 }
 303
 304
 305 /***********************************************************************
 306  *           _lwrite   (KERNEL.86)
 307  */
 308 UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
 309 {
 310     return (UINT16)_hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
 311 }
 312
 313 /***********************************************************************
 314  *           _hread (KERNEL.349)
 315  */
 316 LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
 317 {
 318     LONG maxlen;
 319
 320     TRACE("%d %08x %d\n", hFile, (DWORD)buffer, count );
 321
 322     /* Some programs pass a count larger than the allocated buffer */
 323     maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
 324     if (count > maxlen) count = maxlen;
 325     return _lread((HFILE)DosFileHandleToWin32Handle(hFile), MapSL(buffer), count );
 326 }
 327
 328
 329 /***********************************************************************
 330  *           _lread (KERNEL.82)
 331  */
 332 UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
 333 {
 334     return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
 335 }
 336
 337
 338 /***********************************************************************
 339  *           _hwrite   (KERNEL.350)
 340  */
 341 LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
 342 {
 343     return _hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
 344 }
 345
 346
 347 /***********************************************************************
 348  *           GetTempDrive   (KERNEL.92)
 349  * A closer look at krnl386.exe shows what the SDK doesn't mention:
 350  *
 351  * returns:
 352  *   AL: driveletter
 353  *   AH: ':'            - yes, some kernel code even does stosw with
 354  *                            the returned AX.
 355  *   DX: 1 for success
 356  */
 357 UINT WINAPI GetTempDrive( BYTE ignored )
 358 {
 359     WCHAR buffer[8];
 360     BYTE ret;
 361
 362     if (GetTempPathW( 8, buffer )) ret = (BYTE)toupperW(buffer[0]);
 363     else ret = 'C';
 364     return MAKELONG( ret | (':' << 8), 1 );
 365 }
 366
 367
 368 /***********************************************************************
 369  *           GetTempFileName   (KERNEL.97)
 370  */
 371 UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
 372                                  LPSTR buffer )
 373 {
 374     char temppath[MAX_PATH];
 375     char *prefix16 = NULL;
 376     UINT16 ret;
 377
 378     if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */
 379     {
 380         GetCurrentDirectoryA(sizeof(temppath), temppath);
 381         drive |= temppath[0];
 382     }
 383
 384     if (drive & TF_FORCEDRIVE)
 385     {
 386         char    d[3];
 387
 388         d[0] = drive & ~TF_FORCEDRIVE;
 389         d[1] = ':';
 390         d[2] = '\0';
 391         if (GetDriveTypeA(d) == DRIVE_NO_ROOT_DIR)
 392         {
 393             drive &= ~TF_FORCEDRIVE;
 394             WARN("invalid drive %d specified\n", drive );
 395         }
 396     }
 397
 398     if (drive & TF_FORCEDRIVE)
 399         sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
 400     else
 401         GetTempPathA( MAX_PATH, temppath );
 402
 403     if (prefix)
 404     {
 405         prefix16 = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + 2);
 406         *prefix16 = '~';
 407         strcpy(prefix16 + 1, prefix);
 408     }
 409
 410     ret = GetTempFileNameA( temppath, prefix16, unique, buffer );
 411
 412     HeapFree(GetProcessHeap(), 0, prefix16);
 413     return ret;
 414 }
 415
 416
 417 /***********************************************************************
 418  *           GetPrivateProfileInt   (KERNEL.127)
 419  */
 420 UINT16 WINAPI GetPrivateProfileInt16( LPCSTR section, LPCSTR entry,
 421                                       INT16 def_val, LPCSTR filename )
 422 {
 423     /* we used to have some elaborate return value limitation (<= -32768 etc.)
 424      * here, but Win98SE doesn't care about this at all, so I deleted it.
 425      * AFAIR versions prior to Win9x had these limits, though. */
 426     return (INT16)GetPrivateProfileIntA(section,entry,def_val,filename);
 427 }
 428
 429
 430 /***********************************************************************
 431  *           GetPrivateProfileString   (KERNEL.128)
 432  */
 433 INT16 WINAPI GetPrivateProfileString16( LPCSTR section, LPCSTR entry,
 434                                         LPCSTR def_val, LPSTR buffer,
 435                                         UINT16 len, LPCSTR filename )
 436 {
 437     if (!section)
 438     {
 439         if (buffer && len) buffer[0] = 0;
 440         return 0;
 441     }
 442     if (!entry)
 443     {
 444         /* We have to return the list of keys in the section but without the values
 445          * so we need to massage the results of GetPrivateProfileSectionA.
 446          */
 447         UINT ret, oldlen = len, size = min( len, 1024 );
 448         LPSTR data, src;
 449
 450         for (;;)
 451         {
 452             if (!(data = HeapAlloc(GetProcessHeap(), 0, size ))) return 0;
 453             ret = GetPrivateProfileSectionA( section, data, size, filename );
 454             if (!ret)
 455             {
 456                 HeapFree( GetProcessHeap(), 0, data );
 457                 return 0;
 458             }
 459             if (ret != size - 2) break;
 460             /* overflow, try again */
 461             size *= 2;
 462             HeapFree( GetProcessHeap(), 0, data );
 463         }
 464
 465         src = data;
 466         while (len && *src)
 467         {
 468             char *p = strchr( src, '=' );
 469
 470             if (!p) p = src + strlen(src);
 471             if (p - src < len)
 472             {
 473                 memcpy( buffer, src, p - src );
 474                 buffer += p - src;
 475                 *buffer++ = 0;
 476                 len -= (p - src) + 1;
 477                 src += strlen(src) + 1;
 478             }
 479             else  /* overflow */
 480             {
 481                 memcpy( buffer, src, len );
 482                 buffer += len;
 483                 len = 0;
 484             }
 485         }
 486         HeapFree( GetProcessHeap(), 0, data );
 487
 488         if (len)
 489         {
 490             *buffer = 0;
 491             return oldlen - len;
 492         }
 493         if (oldlen > 2)
 494         {
 495             buffer[-2] = 0;
 496             buffer[-1] = 0;
 497             return oldlen - 2;
 498         }
 499         return 0;
 500     }
 501     return GetPrivateProfileStringA( section, entry, def_val, buffer, len, filename );
 502 }
 503
 504
 505 /***********************************************************************
 506  *           WritePrivateProfileString   (KERNEL.129)
 507  */
 508 BOOL16 WINAPI WritePrivateProfileString16( LPCSTR section, LPCSTR entry,
 509                                            LPCSTR string, LPCSTR filename )
 510 {
 511     return WritePrivateProfileStringA(section,entry,string,filename);
 512 }
 513
 514
 515 /***********************************************************************
 516  *           GetWindowsDirectory   (KERNEL.134)
 517  */
 518 UINT16 WINAPI GetWindowsDirectory16( LPSTR path, UINT16 count )
 519 {
 520     return GetWindowsDirectoryA( path, count );
 521 }
 522
 523
 524 /***********************************************************************
 525  *           GetSystemDirectory   (KERNEL.135)
 526  */
 527 UINT16 WINAPI GetSystemDirectory16( LPSTR path, UINT16 count )
 528 {
 529     return GetSystemDirectoryA( path, count );
 530 }
 531
 532
 533 /***********************************************************************
 534  *           GetDriveType   (KERNEL.136)
 535  * Get the type of a drive in Win16.
 536  *
 537  * RETURNS
 538  *  The type of the Drive. For a list see GetDriveTypeW from kernel32.
 539  *
 540  * NOTES
 541  *  Note that it returns DRIVE_REMOTE for CD-ROMs, since MSCDEX uses the
 542  *  remote drive API. The return value DRIVE_REMOTE for CD-ROMs has been
 543  *  verified on Win 3.11 and Windows 95. Some programs rely on it, so don't
 544  *  do any pseudo-clever changes.
 545  */
 546 UINT16 WINAPI GetDriveType16( UINT16 drive ) /* [in] number (NOT letter) of drive */
 547 {
 548     UINT type;
 549     WCHAR root[3];
 550
 551     root[0] = 'A' + drive;
 552     root[1] = ':';
 553     root[2] = 0;
 554     type = GetDriveTypeW( root );
 555     if (type == DRIVE_CDROM) type = DRIVE_REMOTE;
 556     else if (type == DRIVE_NO_ROOT_DIR) type = DRIVE_UNKNOWN;
 557     return type;
 558 }
 559
 560
 561 /***********************************************************************
 562  *           GetProfileSectionNames   (KERNEL.142)
 563  */
 564 WORD WINAPI GetProfileSectionNames16(LPSTR buffer, WORD size)
 565
 566 {
 567     return GetPrivateProfileSectionNamesA(buffer,size,"win.ini");
 568 }
 569
 570
 571 /***********************************************************************
 572  *           GetPrivateProfileSectionNames   (KERNEL.143)
 573  */
 574 WORD WINAPI GetPrivateProfileSectionNames16( LPSTR buffer, WORD size,
 575                                              LPCSTR filename )
 576 {
 577     return GetPrivateProfileSectionNamesA(buffer,size,filename);
 578 }
 579
 580
 581 /***********************************************************************
 582  *           CreateDirectory   (KERNEL.144)
 583  */
 584 BOOL16 WINAPI CreateDirectory16( LPCSTR path, LPVOID dummy )
 585 {
 586     return CreateDirectoryA( path, NULL );
 587 }
 588
 589
 590 /***********************************************************************
 591  *           RemoveDirectory   (KERNEL.145)
 592  */
 593 BOOL16 WINAPI RemoveDirectory16( LPCSTR path )
 594 {
 595     return RemoveDirectoryA( path );
 596 }
 597
 598
 599 /***********************************************************************
 600  *           DeleteFile   (KERNEL.146)
 601  */
 602 BOOL16 WINAPI DeleteFile16( LPCSTR path )
 603 {
 604     return DeleteFileA( path );
 605 }
 606
 607
 608 /***********************************************************************
 609  *           SetHandleCount   (KERNEL.199)
 610  */
 611 UINT16 WINAPI SetHandleCount16( UINT16 count )
 612 {
 613     return SetHandleCount( count );
 614 }
 615
 616
 617 /***********************************************************************
 618  *           GetShortPathName   (KERNEL.274)
 619  */
 620 WORD WINAPI GetShortPathName16( LPCSTR longpath, LPSTR shortpath, WORD len )
 621 {
 622     return GetShortPathNameA( longpath, shortpath, len );
 623 }
 624
 625
 626 /***********************************************************************
 627  *           WriteOutProfiles   (KERNEL.315)
 628  */
 629 void WINAPI WriteOutProfiles16(void)
 630 {
 631     WritePrivateProfileSectionW( NULL, NULL, NULL );
 632 }
 633
 634
 635 /***********************************************************************
 636  *           WritePrivateProfileStruct (KERNEL.406)
 637  */
 638 BOOL16 WINAPI WritePrivateProfileStruct16 (LPCSTR section, LPCSTR key,
 639                                            LPVOID buf, UINT16 bufsize, LPCSTR filename)
 640 {
 641     return WritePrivateProfileStructA( section, key, buf, bufsize, filename );
 642 }
 643
 644
 645 /***********************************************************************
 646  *           GetPrivateProfileStruct (KERNEL.407)
 647  */
 648 BOOL16 WINAPI GetPrivateProfileStruct16(LPCSTR section, LPCSTR key,
 649                                         LPVOID buf, UINT16 len, LPCSTR filename)
 650 {
 651     return GetPrivateProfileStructA( section, key, buf, len, filename );
 652 }
 653
 654
 655 /***********************************************************************
 656  *           GetCurrentDirectory   (KERNEL.411)
 657  */
 658 UINT16 WINAPI GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
 659 {
 660     return GetCurrentDirectoryA( buflen, buf );
 661 }
 662
 663
 664 /***********************************************************************
 665  *           SetCurrentDirectory   (KERNEL.412)
 666  */
 667 BOOL16 WINAPI SetCurrentDirectory16( LPCSTR dir )
 668 {
 669     char fulldir[MAX_PATH];
 670
 671     if (!GetFullPathNameA( dir, MAX_PATH, fulldir, NULL )) return FALSE;
 672
 673     if (!SetCurrentDirectoryA( dir )) return FALSE;
 674
 675     if (fulldir[0] && fulldir[1] == ':')
 676     {
 677         TDB *pTask = GlobalLock16( GetCurrentTask() );
 678         char env_var[4] = "=A:";
 679
 680         env_var[1] = fulldir[0];
 681         SetEnvironmentVariableA( env_var, fulldir );
 682
 683         /* update the directory in the TDB */
 684         if (pTask)
 685         {
 686             pTask->curdrive = 0x80 | (fulldir[0] - 'A');
 687             GetShortPathNameA( fulldir + 2, pTask->curdir, sizeof(pTask->curdir) );
 688         }
 689     }
 690     return TRUE;
 691 }
 692
 693
 694 /*************************************************************************
 695  *           FindFirstFile   (KERNEL.413)
 696  */
 697 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATAA *data )
 698 {
 699     HGLOBAL16 h16;
 700     HANDLE handle, *ptr;
 701
 702     if (!(h16 = GlobalAlloc16( GMEM_MOVEABLE, sizeof(handle) ))) return INVALID_HANDLE_VALUE16;
 703     ptr = GlobalLock16( h16 );
 704     *ptr = handle = FindFirstFileA( path, data );
 705     GlobalUnlock16( h16 );
 706
 707     if (handle == INVALID_HANDLE_VALUE)
 708     {
 709         GlobalFree16( h16 );
 710         h16 = INVALID_HANDLE_VALUE16;
 711     }
 712     return h16;
 713 }
 714
 715
 716 /*************************************************************************
 717  *           FindNextFile   (KERNEL.414)
 718  */
 719 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATAA *data )
 720 {
 721     HANDLE *ptr;
 722     BOOL ret = FALSE;
 723
 724     if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))
 725     {
 726         SetLastError( ERROR_INVALID_HANDLE );
 727         return ret;
 728     }
 729     ret = FindNextFileA( *ptr, data );
 730     GlobalUnlock16( handle );
 731     return ret;
 732 }
 733
 734
 735 /*************************************************************************
 736  *           FindClose   (KERNEL.415)
 737  */
 738 BOOL16 WINAPI FindClose16( HANDLE16 handle )
 739 {
 740     HANDLE *ptr;
 741
 742     if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))
 743     {
 744         SetLastError( ERROR_INVALID_HANDLE );
 745         return FALSE;
 746     }
 747     FindClose( *ptr );
 748     GlobalUnlock16( handle );
 749     GlobalFree16( handle );
 750     return TRUE;
 751 }
 752
 753
 754 /***********************************************************************
 755  *           WritePrivateProfileSection   (KERNEL.416)
 756  */
 757 BOOL16 WINAPI WritePrivateProfileSection16( LPCSTR section,
 758                                             LPCSTR string, LPCSTR filename )
 759 {
 760     return WritePrivateProfileSectionA( section, string, filename );
 761 }
 762
 763
 764 /***********************************************************************
 765  *           WriteProfileSection   (KERNEL.417)
 766  */
 767 BOOL16 WINAPI WriteProfileSection16( LPCSTR section, LPCSTR keys_n_values)
 768 {
 769     return WritePrivateProfileSection16( section, keys_n_values, "win.ini");
 770 }
 771
 772
 773 /***********************************************************************
 774  *           GetPrivateProfileSection   (KERNEL.418)
 775  */
 776 INT16 WINAPI GetPrivateProfileSection16( LPCSTR section, LPSTR buffer,
 777                                          UINT16 len, LPCSTR filename )
 778 {
 779     return GetPrivateProfileSectionA( section, buffer, len, filename );
 780 }
 781
 782
 783 /***********************************************************************
 784  *           GetProfileSection   (KERNEL.419)
 785  */
 786 INT16 WINAPI GetProfileSection16( LPCSTR section, LPSTR buffer, UINT16 len )
 787 {
 788     return GetPrivateProfileSection16( section, buffer, len, "win.ini" );
 789 }
 790
 791
 792 /**************************************************************************
 793  *           GetFileAttributes   (KERNEL.420)
 794  */
 795 DWORD WINAPI GetFileAttributes16( LPCSTR name )
 796 {
 797     return GetFileAttributesA( name );
 798 }
 799
 800
 801 /**************************************************************************
 802  *              SetFileAttributes       (KERNEL.421)
 803  */
 804 BOOL16 WINAPI SetFileAttributes16( LPCSTR lpFileName, DWORD attributes )
 805 {
 806     return SetFileAttributesA( lpFileName, attributes );
 807 }
 808
 809
 810 /***********************************************************************
 811  *           GetDiskFreeSpace   (KERNEL.422)
 812  */
 813 BOOL16 WINAPI GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
 814                                   LPDWORD sector_bytes, LPDWORD free_clusters,
 815                                   LPDWORD total_clusters )
 816 {
 817     return GetDiskFreeSpaceA( root, cluster_sectors, sector_bytes,
 818                                 free_clusters, total_clusters );
 819 }
 820
 821 /***********************************************************************
 822  *      FileCDR (KERNEL.130)
 823  */
 824 FARPROC16 WINAPI FileCDR16(FARPROC16 x)
 825 {
 826     FIXME("(%p): stub\n", x);
 827     return (FARPROC16)TRUE;
 828 }