include: Add missing local attributes to shobjidl.idl.
[wine] / 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  *           WritePrivateProfileString   (KERNEL.129)
432  */
433 BOOL16 WINAPI WritePrivateProfileString16( LPCSTR section, LPCSTR entry,
434                                            LPCSTR string, LPCSTR filename )
435 {
436     return WritePrivateProfileStringA(section,entry,string,filename);
437 }
438
439
440 /***********************************************************************
441  *           GetWindowsDirectory   (KERNEL.134)
442  */
443 UINT16 WINAPI GetWindowsDirectory16( LPSTR path, UINT16 count )
444 {
445     return GetWindowsDirectoryA( path, count );
446 }
447
448
449 /***********************************************************************
450  *           GetSystemDirectory   (KERNEL.135)
451  */
452 UINT16 WINAPI GetSystemDirectory16( LPSTR path, UINT16 count )
453 {
454     return GetSystemDirectoryA( path, count );
455 }
456
457
458 /***********************************************************************
459  *           GetDriveType   (KERNEL.136)
460  * Get the type of a drive in Win16.
461  *
462  * RETURNS
463  *  The type of the Drive. For a list see GetDriveTypeW from kernel32.
464  *
465  * NOTES
466  *  Note that it returns DRIVE_REMOTE for CD-ROMs, since MSCDEX uses the
467  *  remote drive API. The return value DRIVE_REMOTE for CD-ROMs has been
468  *  verified on Win 3.11 and Windows 95. Some programs rely on it, so don't
469  *  do any pseudo-clever changes.
470  */
471 UINT16 WINAPI GetDriveType16( UINT16 drive ) /* [in] number (NOT letter) of drive */
472 {
473     UINT type;
474     WCHAR root[3];
475
476     root[0] = 'A' + drive;
477     root[1] = ':';
478     root[2] = 0;
479     type = GetDriveTypeW( root );
480     if (type == DRIVE_CDROM) type = DRIVE_REMOTE;
481     else if (type == DRIVE_NO_ROOT_DIR) type = DRIVE_UNKNOWN;
482     return type;
483 }
484
485
486 /***********************************************************************
487  *           GetProfileSectionNames   (KERNEL.142)
488  */
489 WORD WINAPI GetProfileSectionNames16(LPSTR buffer, WORD size)
490
491 {
492     return GetPrivateProfileSectionNamesA(buffer,size,"win.ini");
493 }
494
495
496 /***********************************************************************
497  *           GetPrivateProfileSectionNames   (KERNEL.143)
498  */
499 WORD WINAPI GetPrivateProfileSectionNames16( LPSTR buffer, WORD size,
500                                              LPCSTR filename )
501 {
502     return GetPrivateProfileSectionNamesA(buffer,size,filename);
503 }
504
505
506 /***********************************************************************
507  *           CreateDirectory   (KERNEL.144)
508  */
509 BOOL16 WINAPI CreateDirectory16( LPCSTR path, LPVOID dummy )
510 {
511     return CreateDirectoryA( path, NULL );
512 }
513
514
515 /***********************************************************************
516  *           RemoveDirectory   (KERNEL.145)
517  */
518 BOOL16 WINAPI RemoveDirectory16( LPCSTR path )
519 {
520     return RemoveDirectoryA( path );
521 }
522
523
524 /***********************************************************************
525  *           DeleteFile   (KERNEL.146)
526  */
527 BOOL16 WINAPI DeleteFile16( LPCSTR path )
528 {
529     return DeleteFileA( path );
530 }
531
532
533 /***********************************************************************
534  *           SetHandleCount   (KERNEL.199)
535  */
536 UINT16 WINAPI SetHandleCount16( UINT16 count )
537 {
538     return SetHandleCount( count );
539 }
540
541
542 /***********************************************************************
543  *           WritePrivateProfileStruct (KERNEL.406)
544  */
545 BOOL16 WINAPI WritePrivateProfileStruct16 (LPCSTR section, LPCSTR key,
546                                            LPVOID buf, UINT16 bufsize, LPCSTR filename)
547 {
548     return WritePrivateProfileStructA( section, key, buf, bufsize, filename );
549 }
550
551
552 /***********************************************************************
553  *           GetPrivateProfileStruct (KERNEL.407)
554  */
555 BOOL16 WINAPI GetPrivateProfileStruct16(LPCSTR section, LPCSTR key,
556                                         LPVOID buf, UINT16 len, LPCSTR filename)
557 {
558     return GetPrivateProfileStructA( section, key, buf, len, filename );
559 }
560
561
562 /***********************************************************************
563  *           GetCurrentDirectory   (KERNEL.411)
564  */
565 UINT16 WINAPI GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
566 {
567     return GetCurrentDirectoryA( buflen, buf );
568 }
569
570
571 /***********************************************************************
572  *           SetCurrentDirectory   (KERNEL.412)
573  */
574 BOOL16 WINAPI SetCurrentDirectory16( LPCSTR dir )
575 {
576     char fulldir[MAX_PATH];
577
578     if (!GetFullPathNameA( dir, MAX_PATH, fulldir, NULL )) return FALSE;
579
580     if (!SetCurrentDirectoryA( dir )) return FALSE;
581
582     if (fulldir[0] && fulldir[1] == ':')
583     {
584         TDB *pTask = GlobalLock16( GetCurrentTask() );
585         char env_var[4] = "=A:";
586
587         env_var[1] = fulldir[0];
588         SetEnvironmentVariableA( env_var, fulldir );
589
590         /* update the directory in the TDB */
591         if (pTask)
592         {
593             pTask->curdrive = 0x80 | (fulldir[0] - 'A');
594             GetShortPathNameA( fulldir + 2, pTask->curdir, sizeof(pTask->curdir) );
595         }
596     }
597     return TRUE;
598 }
599
600
601 /*************************************************************************
602  *           FindFirstFile   (KERNEL.413)
603  */
604 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATAA *data )
605 {
606     HGLOBAL16 h16;
607     HANDLE handle, *ptr;
608
609     if (!(h16 = GlobalAlloc16( GMEM_MOVEABLE, sizeof(handle) ))) return INVALID_HANDLE_VALUE16;
610     ptr = GlobalLock16( h16 );
611     *ptr = handle = FindFirstFileA( path, data );
612     GlobalUnlock16( h16 );
613
614     if (handle == INVALID_HANDLE_VALUE)
615     {
616         GlobalFree16( h16 );
617         h16 = INVALID_HANDLE_VALUE16;
618     }
619     return h16;
620 }
621
622
623 /*************************************************************************
624  *           FindNextFile   (KERNEL.414)
625  */
626 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATAA *data )
627 {
628     HANDLE *ptr;
629     BOOL ret = FALSE;
630
631     if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))
632     {
633         SetLastError( ERROR_INVALID_HANDLE );
634         return ret;
635     }
636     ret = FindNextFileA( *ptr, data );
637     GlobalUnlock16( handle );
638     return ret;
639 }
640
641
642 /*************************************************************************
643  *           FindClose   (KERNEL.415)
644  */
645 BOOL16 WINAPI FindClose16( HANDLE16 handle )
646 {
647     HANDLE *ptr;
648
649     if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))
650     {
651         SetLastError( ERROR_INVALID_HANDLE );
652         return FALSE;
653     }
654     FindClose( *ptr );
655     GlobalUnlock16( handle );
656     GlobalFree16( handle );
657     return TRUE;
658 }
659
660
661 /***********************************************************************
662  *           WritePrivateProfileSection   (KERNEL.416)
663  */
664 BOOL16 WINAPI WritePrivateProfileSection16( LPCSTR section,
665                                             LPCSTR string, LPCSTR filename )
666 {
667     return WritePrivateProfileSectionA( section, string, filename );
668 }
669
670
671 /***********************************************************************
672  *           WriteProfileSection   (KERNEL.417)
673  */
674 BOOL16 WINAPI WriteProfileSection16( LPCSTR section, LPCSTR keys_n_values)
675 {
676     return WritePrivateProfileSection16( section, keys_n_values, "win.ini");
677 }
678
679
680 /***********************************************************************
681  *           GetPrivateProfileSection   (KERNEL.418)
682  */
683 INT16 WINAPI GetPrivateProfileSection16( LPCSTR section, LPSTR buffer,
684                                          UINT16 len, LPCSTR filename )
685 {
686     return GetPrivateProfileSectionA( section, buffer, len, filename );
687 }
688
689
690 /***********************************************************************
691  *           GetProfileSection   (KERNEL.419)
692  */
693 INT16 WINAPI GetProfileSection16( LPCSTR section, LPSTR buffer, UINT16 len )
694 {
695     return GetPrivateProfileSection16( section, buffer, len, "win.ini" );
696 }
697
698
699 /**************************************************************************
700  *           GetFileAttributes   (KERNEL.420)
701  */
702 DWORD WINAPI GetFileAttributes16( LPCSTR name )
703 {
704     return GetFileAttributesA( name );
705 }
706
707
708 /**************************************************************************
709  *              SetFileAttributes       (KERNEL.421)
710  */
711 BOOL16 WINAPI SetFileAttributes16( LPCSTR lpFileName, DWORD attributes )
712 {
713     return SetFileAttributesA( lpFileName, attributes );
714 }
715
716
717 /***********************************************************************
718  *           GetDiskFreeSpace   (KERNEL.422)
719  */
720 BOOL16 WINAPI GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
721                                   LPDWORD sector_bytes, LPDWORD free_clusters,
722                                   LPDWORD total_clusters )
723 {
724     return GetDiskFreeSpaceA( root, cluster_sectors, sector_bytes,
725                                 free_clusters, total_clusters );
726 }
727
728 /***********************************************************************
729  *      FileCDR (KERNEL.130)
730  */
731 FARPROC16 WINAPI FileCDR16(FARPROC16 x)
732 {
733     FIXME("(%p): stub\n", x);
734     return (FARPROC16)TRUE;
735 }