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 * GetTempDrive (KERNEL.92)
340 * A closer look at krnl386.exe shows what the SDK doesn't mention:
341 *
342 * returns:
343 * AL: driveletter
344 * AH: ':' - yes, some kernel code even does stosw with
345 * the returned AX.
346 * DX: 1 for success
347 */
348 UINT WINAPI GetTempDrive( BYTE ignored )
349 {
350 WCHAR buffer[8];
351 BYTE ret;
352
353 if (GetTempPathW( 8, buffer )) ret = (BYTE)toupperW(buffer[0]);
354 else ret = 'C';
355 return MAKELONG( ret | (':' << 8), 1 );
356 }
357
358
359 /***********************************************************************
360 * GetTempFileName (KERNEL.97)
361 */
362 UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
363 LPSTR buffer )
364 {
365 char temppath[MAX_PATH];
366 char *prefix16 = NULL;
367 UINT16 ret;
368
369 if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */
370 {
371 GetCurrentDirectoryA(sizeof(temppath), temppath);
372 drive |= temppath[0];
373 }
374
375 if (drive & TF_FORCEDRIVE)
376 {
377 char d[3];
378
379 d[0] = drive & ~TF_FORCEDRIVE;
380 d[1] = ':';
381 d[2] = '\0';
382 if (GetDriveTypeA(d) == DRIVE_NO_ROOT_DIR)
383 {
384 drive &= ~TF_FORCEDRIVE;
385 WARN("invalid drive %d specified\n", drive );
386 }
387 }
388
389 if (drive & TF_FORCEDRIVE)
390 sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
391 else
392 GetTempPathA( MAX_PATH, temppath );
393
394 if (prefix)
395 {
396 prefix16 = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + 2);
397 *prefix16 = '~';
398 strcpy(prefix16 + 1, prefix);
399 }
400
401 ret = GetTempFileNameA( temppath, prefix16, unique, buffer );
402
403 HeapFree(GetProcessHeap(), 0, prefix16);
404 return ret;
405 }
406
407
408 /***********************************************************************
409 * GetPrivateProfileInt (KERNEL.127)
410 */
411 UINT16 WINAPI GetPrivateProfileInt16( LPCSTR section, LPCSTR entry,
412 INT16 def_val, LPCSTR filename )
413 {
414 /* we used to have some elaborate return value limitation (<= -32768 etc.)
415 * here, but Win98SE doesn't care about this at all, so I deleted it.
416 * AFAIR versions prior to Win9x had these limits, though. */
417 return (INT16)GetPrivateProfileIntA(section,entry,def_val,filename);
418 }
419
420
421 /***********************************************************************
422 * WritePrivateProfileString (KERNEL.129)
423 */
424 BOOL16 WINAPI WritePrivateProfileString16( LPCSTR section, LPCSTR entry,
425 LPCSTR string, LPCSTR filename )
426 {
427 return WritePrivateProfileStringA(section,entry,string,filename);
428 }
429
430
431 /***********************************************************************
432 * GetWindowsDirectory (KERNEL.134)
433 */
434 UINT16 WINAPI GetWindowsDirectory16( LPSTR path, UINT16 count )
435 {
436 return GetWindowsDirectoryA( path, count );
437 }
438
439
440 /***********************************************************************
441 * GetSystemDirectory (KERNEL.135)
442 */
443 UINT16 WINAPI GetSystemDirectory16( LPSTR path, UINT16 count )
444 {
445 return GetSystemDirectoryA( path, count );
446 }
447
448
449 /***********************************************************************
450 * GetDriveType (KERNEL.136)
451 * Get the type of a drive in Win16.
452 *
453 * RETURNS
454 * The type of the Drive. For a list see GetDriveTypeW from kernel32.
455 *
456 * NOTES
457 * Note that it returns DRIVE_REMOTE for CD-ROMs, since MSCDEX uses the
458 * remote drive API. The return value DRIVE_REMOTE for CD-ROMs has been
459 * verified on Win 3.11 and Windows 95. Some programs rely on it, so don't
460 * do any pseudo-clever changes.
461 */
462 UINT16 WINAPI GetDriveType16( UINT16 drive ) /* [in] number (NOT letter) of drive */
463 {
464 UINT type;
465 WCHAR root[3];
466
467 root[0] = 'A' + drive;
468 root[1] = ':';
469 root[2] = 0;
470 type = GetDriveTypeW( root );
471 if (type == DRIVE_CDROM) type = DRIVE_REMOTE;
472 else if (type == DRIVE_NO_ROOT_DIR) type = DRIVE_UNKNOWN;
473 return type;
474 }
475
476
477 /***********************************************************************
478 * GetProfileSectionNames (KERNEL.142)
479 */
480 WORD WINAPI GetProfileSectionNames16(LPSTR buffer, WORD size)
481
482 {
483 return GetPrivateProfileSectionNamesA(buffer,size,"win.ini");
484 }
485
486
487 /***********************************************************************
488 * GetPrivateProfileSectionNames (KERNEL.143)
489 */
490 WORD WINAPI GetPrivateProfileSectionNames16( LPSTR buffer, WORD size,
491 LPCSTR filename )
492 {
493 return GetPrivateProfileSectionNamesA(buffer,size,filename);
494 }
495
496
497 /***********************************************************************
498 * CreateDirectory (KERNEL.144)
499 */
500 BOOL16 WINAPI CreateDirectory16( LPCSTR path, LPVOID dummy )
501 {
502 return CreateDirectoryA( path, NULL );
503 }
504
505
506 /***********************************************************************
507 * RemoveDirectory (KERNEL.145)
508 */
509 BOOL16 WINAPI RemoveDirectory16( LPCSTR path )
510 {
511 return RemoveDirectoryA( path );
512 }
513
514
515 /***********************************************************************
516 * DeleteFile (KERNEL.146)
517 */
518 BOOL16 WINAPI DeleteFile16( LPCSTR path )
519 {
520 return DeleteFileA( path );
521 }
522
523
524 /***********************************************************************
525 * SetHandleCount (KERNEL.199)
526 */
527 UINT16 WINAPI SetHandleCount16( UINT16 count )
528 {
529 return SetHandleCount( count );
530 }
531
532
533 /***********************************************************************
534 * _hread16 (KERNEL.349)
535 */
536 LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
537 {
538 return _lread( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
539 }
540
541
542 /***********************************************************************
543 * _hwrite (KERNEL.350)
544 */
545 LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
546 {
547 return _hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
548 }
549
550
551 /***********************************************************************
552 * WritePrivateProfileStruct (KERNEL.406)
553 */
554 BOOL16 WINAPI WritePrivateProfileStruct16 (LPCSTR section, LPCSTR key,
555 LPVOID buf, UINT16 bufsize, LPCSTR filename)
556 {
557 return WritePrivateProfileStructA( section, key, buf, bufsize, filename );
558 }
559
560
561 /***********************************************************************
562 * GetPrivateProfileStruct (KERNEL.407)
563 */
564 BOOL16 WINAPI GetPrivateProfileStruct16(LPCSTR section, LPCSTR key,
565 LPVOID buf, UINT16 len, LPCSTR filename)
566 {
567 return GetPrivateProfileStructA( section, key, buf, len, filename );
568 }
569
570
571 /***********************************************************************
572 * GetCurrentDirectory (KERNEL.411)
573 */
574 UINT16 WINAPI GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
575 {
576 return GetCurrentDirectoryA( buflen, buf );
577 }
578
579
580 /***********************************************************************
581 * SetCurrentDirectory (KERNEL.412)
582 */
583 BOOL16 WINAPI SetCurrentDirectory16( LPCSTR dir )
584 {
585 char fulldir[MAX_PATH];
586
587 if (!GetFullPathNameA( dir, MAX_PATH, fulldir, NULL )) return FALSE;
588
589 if (!SetCurrentDirectoryA( dir )) return FALSE;
590
591 if (fulldir[0] && fulldir[1] == ':')
592 {
593 TDB *pTask = GlobalLock16( GetCurrentTask() );
594 char env_var[4] = "=A:";
595
596 env_var[1] = fulldir[0];
597 SetEnvironmentVariableA( env_var, fulldir );
598
599 /* update the directory in the TDB */
600 if (pTask)
601 {
602 pTask->curdrive = 0x80 | (fulldir[0] - 'A');
603 GetShortPathNameA( fulldir + 2, pTask->curdir, sizeof(pTask->curdir) );
604 }
605 }
606 return TRUE;
607 }
608
609
610 /*************************************************************************
611 * FindFirstFile (KERNEL.413)
612 */
613 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATAA *data )
614 {
615 HGLOBAL16 h16;
616 HANDLE handle, *ptr;
617
618 if (!(h16 = GlobalAlloc16( GMEM_MOVEABLE, sizeof(handle) ))) return INVALID_HANDLE_VALUE16;
619 ptr = GlobalLock16( h16 );
620 *ptr = handle = FindFirstFileA( path, data );
621 GlobalUnlock16( h16 );
622
623 if (handle == INVALID_HANDLE_VALUE)
624 {
625 GlobalFree16( h16 );
626 h16 = INVALID_HANDLE_VALUE16;
627 }
628 return h16;
629 }
630
631
632 /*************************************************************************
633 * FindNextFile (KERNEL.414)
634 */
635 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATAA *data )
636 {
637 HANDLE *ptr;
638 BOOL ret = FALSE;
639
640 if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))
641 {
642 SetLastError( ERROR_INVALID_HANDLE );
643 return ret;
644 }
645 ret = FindNextFileA( *ptr, data );
646 GlobalUnlock16( handle );
647 return ret;
648 }
649
650
651 /*************************************************************************
652 * FindClose (KERNEL.415)
653 */
654 BOOL16 WINAPI FindClose16( HANDLE16 handle )
655 {
656 HANDLE *ptr;
657
658 if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))
659 {
660 SetLastError( ERROR_INVALID_HANDLE );
661 return FALSE;
662 }
663 FindClose( *ptr );
664 GlobalUnlock16( handle );
665 GlobalFree16( handle );
666 return TRUE;
667 }
668
669
670 /***********************************************************************
671 * WritePrivateProfileSection (KERNEL.416)
672 */
673 BOOL16 WINAPI WritePrivateProfileSection16( LPCSTR section,
674 LPCSTR string, LPCSTR filename )
675 {
676 return WritePrivateProfileSectionA( section, string, filename );
677 }
678
679
680 /***********************************************************************
681 * WriteProfileSection (KERNEL.417)
682 */
683 BOOL16 WINAPI WriteProfileSection16( LPCSTR section, LPCSTR keys_n_values)
684 {
685 return WritePrivateProfileSection16( section, keys_n_values, "win.ini");
686 }
687
688
689 /***********************************************************************
690 * GetPrivateProfileSection (KERNEL.418)
691 */
692 INT16 WINAPI GetPrivateProfileSection16( LPCSTR section, LPSTR buffer,
693 UINT16 len, LPCSTR filename )
694 {
695 return GetPrivateProfileSectionA( section, buffer, len, filename );
696 }
697
698
699 /***********************************************************************
700 * GetProfileSection (KERNEL.419)
701 */
702 INT16 WINAPI GetProfileSection16( LPCSTR section, LPSTR buffer, UINT16 len )
703 {
704 return GetPrivateProfileSection16( section, buffer, len, "win.ini" );
705 }
706
707
708 /**************************************************************************
709 * GetFileAttributes (KERNEL.420)
710 */
711 DWORD WINAPI GetFileAttributes16( LPCSTR name )
712 {
713 return GetFileAttributesA( name );
714 }
715
716
717 /**************************************************************************
718 * SetFileAttributes (KERNEL.421)
719 */
720 BOOL16 WINAPI SetFileAttributes16( LPCSTR lpFileName, DWORD attributes )
721 {
722 return SetFileAttributesA( lpFileName, attributes );
723 }
724
725
726 /***********************************************************************
727 * GetDiskFreeSpace (KERNEL.422)
728 */
729 BOOL16 WINAPI GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
730 LPDWORD sector_bytes, LPDWORD free_clusters,
731 LPDWORD total_clusters )
732 {
733 return GetDiskFreeSpaceA( root, cluster_sectors, sector_bytes,
734 free_clusters, total_clusters );
735 }
736
737 /***********************************************************************
738 * FileCDR (KERNEL.130)
739 */
740 FARPROC16 WINAPI FileCDR16(FARPROC16 x)
741 {
742 FIXME("(%p): stub\n", x);
743 return (FARPROC16)TRUE;
744 }
745
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.