?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32: Implement SetDefaultDllDirectories.
[wine.git] / dlls / kernel32 / path.c
blobec7c53b34cc2e8015a3ee1865826e2eb63077c42
1 /*
2 * File handling functions
3 *
4 * Copyright 1993 Erik Bos
5 * Copyright 1996, 2004 Alexandre Julliard
6 * Copyright 2003 Eric Pouech
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <errno.h>
28 #include <stdio.h>
29 #include <stdarg.h>
30
31 #include "winerror.h"
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winternl.h"
37
38 #include "kernel_private.h"
39 #include "wine/unicode.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(file);
43
44 #define MAX_PATHNAME_LEN 1024
45
46
47 /* check if a file name is for an executable file (.exe or .com) */
48 static inline BOOL is_executable( const WCHAR *name )
49 {
50 static const WCHAR exeW[] = {'.','e','x','e',0};
51 static const WCHAR comW[] = {'.','c','o','m',0};
52 int len = strlenW(name);
53
54 if (len < 4) return FALSE;
55 return (!strcmpiW( name + len - 4, exeW ) || !strcmpiW( name + len - 4, comW ));
56 }
57
58 /***********************************************************************
59 * copy_filename_WtoA
60 *
61 * copy a file name back to OEM/Ansi, but only if the buffer is large enough
62 */
63 static DWORD copy_filename_WtoA( LPCWSTR nameW, LPSTR buffer, DWORD len )
64 {
65 UNICODE_STRING strW;
66 DWORD ret;
67 BOOL is_ansi = AreFileApisANSI();
68
69 RtlInitUnicodeString( &strW, nameW );
70
71 ret = is_ansi ? RtlUnicodeStringToAnsiSize(&strW) : RtlUnicodeStringToOemSize(&strW);
72 if (buffer && ret <= len)
73 {
74 ANSI_STRING str;
75
76 str.Buffer = buffer;
77 str.MaximumLength = min( len, UNICODE_STRING_MAX_CHARS );
78 if (is_ansi)
79 RtlUnicodeStringToAnsiString( &str, &strW, FALSE );
80 else
81 RtlUnicodeStringToOemString( &str, &strW, FALSE );
82 ret = str.Length; /* length without terminating 0 */
83 }
84 return ret;
85 }
86
87 /***********************************************************************
88 * add_boot_rename_entry
89 *
90 * Adds an entry to the registry that is loaded when windows boots and
91 * checks if there are some files to be removed or renamed/moved.
92 * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
93 * non-NULL then the file is moved, otherwise it is deleted. The
94 * entry of the registry key is always appended with two zero
95 * terminated strings. If <fn2> is NULL then the second entry is
96 * simply a single 0-byte. Otherwise the second filename goes
97 * there. The entries are prepended with \??\ before the path and the
98 * second filename gets also a '!' as the first character if
99 * MOVEFILE_REPLACE_EXISTING is set. After the final string another
100 * 0-byte follows to indicate the end of the strings.
101 * i.e.:
102 * \??\D:\test\file1[0]
103 * !\??\D:\test\file1_renamed[0]
104 * \??\D:\Test|delete[0]
105 * [0] <- file is to be deleted, second string empty
106 * \??\D:\test\file2[0]
107 * !\??\D:\test\file2_renamed[0]
108 * [0] <- indicates end of strings
109 *
110 * or:
111 * \??\D:\test\file1[0]
112 * !\??\D:\test\file1_renamed[0]
113 * \??\D:\Test|delete[0]
114 * [0] <- file is to be deleted, second string empty
115 * [0] <- indicates end of strings
116 *
117 */
118 static BOOL add_boot_rename_entry( LPCWSTR source, LPCWSTR dest, DWORD flags )
119 {
120 static const WCHAR ValueName[] = {'P','e','n','d','i','n','g',
121 'F','i','l','e','R','e','n','a','m','e',
122 'O','p','e','r','a','t','i','o','n','s',0};
123 static const WCHAR SessionW[] = {'\\','R','e','g','i','s','t','r','y','\\',
124 'M','a','c','h','i','n','e','\\',
125 'S','y','s','t','e','m','\\',
126 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
127 'C','o','n','t','r','o','l','\\',
128 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0};
129 static const int info_size = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data );
130
131 OBJECT_ATTRIBUTES attr;
132 UNICODE_STRING nameW, source_name, dest_name;
133 KEY_VALUE_PARTIAL_INFORMATION *info;
134 BOOL rc = FALSE;
135 HANDLE Reboot = 0;
136 DWORD len1, len2;
137 DWORD DataSize = 0;
138 BYTE *Buffer = NULL;
139 WCHAR *p;
140
141 if (!RtlDosPathNameToNtPathName_U( source, &source_name, NULL, NULL ))
142 {
143 SetLastError( ERROR_PATH_NOT_FOUND );
144 return FALSE;
145 }
146 dest_name.Buffer = NULL;
147 if (dest && !RtlDosPathNameToNtPathName_U( dest, &dest_name, NULL, NULL ))
148 {
149 RtlFreeUnicodeString( &source_name );
150 SetLastError( ERROR_PATH_NOT_FOUND );
151 return FALSE;
152 }
153
154 attr.Length = sizeof(attr);
155 attr.RootDirectory = 0;
156 attr.ObjectName = &nameW;
157 attr.Attributes = 0;
158 attr.SecurityDescriptor = NULL;
159 attr.SecurityQualityOfService = NULL;
160 RtlInitUnicodeString( &nameW, SessionW );
161
162 if (NtCreateKey( &Reboot, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS)
163 {
164 WARN("Error creating key for reboot management [%s]\n",
165 "SYSTEM\\CurrentControlSet\\Control\\Session Manager");
166 RtlFreeUnicodeString( &source_name );
167 RtlFreeUnicodeString( &dest_name );
168 return FALSE;
169 }
170
171 len1 = source_name.Length + sizeof(WCHAR);
172 if (dest)
173 {
174 len2 = dest_name.Length + sizeof(WCHAR);
175 if (flags & MOVEFILE_REPLACE_EXISTING)
176 len2 += sizeof(WCHAR); /* Plus 1 because of the leading '!' */
177 }
178 else len2 = sizeof(WCHAR); /* minimum is the 0 characters for the empty second string */
179
180 RtlInitUnicodeString( &nameW, ValueName );
181
182 /* First we check if the key exists and if so how many bytes it already contains. */
183 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
184 NULL, 0, &DataSize ) == STATUS_BUFFER_TOO_SMALL)
185 {
186 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
187 goto Quit;
188 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
189 Buffer, DataSize, &DataSize )) goto Quit;
190 info = (KEY_VALUE_PARTIAL_INFORMATION *)Buffer;
191 if (info->Type != REG_MULTI_SZ) goto Quit;
192 if (DataSize > sizeof(info)) DataSize -= sizeof(WCHAR); /* remove terminating null (will be added back later) */
193 }
194 else
195 {
196 DataSize = info_size;
197 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
198 goto Quit;
199 }
200
201 memcpy( Buffer + DataSize, source_name.Buffer, len1 );
202 DataSize += len1;
203 p = (WCHAR *)(Buffer + DataSize);
204 if (dest)
205 {
206 if (flags & MOVEFILE_REPLACE_EXISTING)
207 *p++ = '!';
208 memcpy( p, dest_name.Buffer, len2 );
209 DataSize += len2;
210 }
211 else
212 {
213 *p = 0;
214 DataSize += sizeof(WCHAR);
215 }
216
217 /* add final null */
218 p = (WCHAR *)(Buffer + DataSize);
219 *p = 0;
220 DataSize += sizeof(WCHAR);
221
222 rc = !NtSetValueKey(Reboot, &nameW, 0, REG_MULTI_SZ, Buffer + info_size, DataSize - info_size);
223
224 Quit:
225 RtlFreeUnicodeString( &source_name );
226 RtlFreeUnicodeString( &dest_name );
227 if (Reboot) NtClose(Reboot);
228 HeapFree( GetProcessHeap(), 0, Buffer );
229 return(rc);
230 }
231
232
233 /***********************************************************************
234 * GetFullPathNameW (KERNEL32.@)
235 * NOTES
236 * if the path closed with '\', *lastpart is 0
237 */
238 DWORD WINAPI GetFullPathNameW( LPCWSTR name, DWORD len, LPWSTR buffer,
239 LPWSTR *lastpart )
240 {
241 return RtlGetFullPathName_U(name, len * sizeof(WCHAR), buffer, lastpart) / sizeof(WCHAR);
242 }
243
244 /***********************************************************************
245 * GetFullPathNameA (KERNEL32.@)
246 * NOTES
247 * if the path closed with '\', *lastpart is 0
248 */
249 DWORD WINAPI GetFullPathNameA( LPCSTR name, DWORD len, LPSTR buffer,
250 LPSTR *lastpart )
251 {
252 WCHAR *nameW;
253 WCHAR bufferW[MAX_PATH], *lastpartW = NULL;
254 DWORD ret;
255
256 if (!(nameW = FILE_name_AtoW( name, FALSE ))) return 0;
257
258 ret = GetFullPathNameW( nameW, MAX_PATH, bufferW, &lastpartW);
259
260 if (!ret) return 0;
261 if (ret > MAX_PATH)
262 {
263 SetLastError(ERROR_FILENAME_EXCED_RANGE);
264 return 0;
265 }
266 ret = copy_filename_WtoA( bufferW, buffer, len );
267 if (ret < len && lastpart)
268 {
269 if (lastpartW)
270 *lastpart = buffer + FILE_name_WtoA( bufferW, lastpartW - bufferW, NULL, 0 );
271 else
272 *lastpart = NULL;
273 }
274 return ret;
275 }
276
277
278 /***********************************************************************
279 * GetLongPathNameW (KERNEL32.@)
280 *
281 * NOTES
282 * observed (Win2000):
283 * shortpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
284 * shortpath="": LastError=ERROR_PATH_NOT_FOUND, ret=0
285 */
286 DWORD WINAPI GetLongPathNameW( LPCWSTR shortpath, LPWSTR longpath, DWORD longlen )
287 {
288 WCHAR tmplongpath[MAX_PATHNAME_LEN];
289 LPCWSTR p;
290 DWORD sp = 0, lp = 0;
291 DWORD tmplen;
292 BOOL unixabsolute;
293 WIN32_FIND_DATAW wfd;
294 HANDLE goit;
295 BOOL is_legal_8dot3;
296
297 if (!shortpath)
298 {
299 SetLastError(ERROR_INVALID_PARAMETER);
300 return 0;
301 }
302 if (!shortpath[0])
303 {
304 SetLastError(ERROR_PATH_NOT_FOUND);
305 return 0;
306 }
307
308 TRACE("%s,%p,%d\n", debugstr_w(shortpath), longpath, longlen);
309
310 if (shortpath[0] == '\\' && shortpath[1] == '\\')
311 {
312 FIXME("UNC pathname %s\n", debugstr_w(shortpath));
313
314 tmplen = strlenW(shortpath);
315 if (tmplen < longlen)
316 {
317 if (longpath != shortpath) strcpyW( longpath, shortpath );
318 return tmplen;
319 }
320 return tmplen + 1;
321 }
322
323 unixabsolute = (shortpath[0] == '/');
324
325 /* check for drive letter */
326 if (!unixabsolute && shortpath[1] == ':' )
327 {
328 tmplongpath[0] = shortpath[0];
329 tmplongpath[1] = ':';
330 lp = sp = 2;
331 }
332
333 while (shortpath[sp])
334 {
335 /* check for path delimiters and reproduce them */
336 if (shortpath[sp] == '\\' || shortpath[sp] == '/')
337 {
338 tmplongpath[lp++] = shortpath[sp++];
339 tmplongpath[lp] = 0; /* terminate string */
340 continue;
341 }
342
343 p = shortpath + sp;
344 for (; *p && *p != '/' && *p != '\\'; p++);
345 tmplen = p - (shortpath + sp);
346 lstrcpynW(tmplongpath + lp, shortpath + sp, tmplen + 1);
347
348 if (tmplongpath[lp] == '.')
349 {
350 if (tmplen == 1 || (tmplen == 2 && tmplongpath[lp + 1] == '.'))
351 {
352 lp += tmplen;
353 sp += tmplen;
354 continue;
355 }
356 }
357
358 /* Check if the file exists */
359 goit = FindFirstFileW(tmplongpath, &wfd);
360 if (goit == INVALID_HANDLE_VALUE)
361 {
362 TRACE("not found %s!\n", debugstr_w(tmplongpath));
363 SetLastError ( ERROR_FILE_NOT_FOUND );
364 return 0;
365 }
366 FindClose(goit);
367
368 is_legal_8dot3 = FALSE;
369 CheckNameLegalDOS8Dot3W(tmplongpath + lp, NULL, 0, NULL, &is_legal_8dot3);
370 /* Use the existing file name if it's a short name */
371 if (is_legal_8dot3)
372 strcpyW(tmplongpath + lp, wfd.cFileName);
373 lp += strlenW(tmplongpath + lp);
374 sp += tmplen;
375 }
376 tmplen = strlenW(shortpath) - 1;
377 if ((shortpath[tmplen] == '/' || shortpath[tmplen] == '\\') &&
378 (tmplongpath[lp - 1] != '/' && tmplongpath[lp - 1] != '\\'))
379 tmplongpath[lp++] = shortpath[tmplen];
380 tmplongpath[lp] = 0;
381
382 tmplen = strlenW(tmplongpath) + 1;
383 if (tmplen <= longlen)
384 {
385 strcpyW(longpath, tmplongpath);
386 TRACE("returning %s\n", debugstr_w(longpath));
387 tmplen--; /* length without 0 */
388 }
389
390 return tmplen;
391 }
392
393 /***********************************************************************
394 * GetLongPathNameA (KERNEL32.@)
395 */
396 DWORD WINAPI GetLongPathNameA( LPCSTR shortpath, LPSTR longpath, DWORD longlen )
397 {
398 WCHAR *shortpathW;
399 WCHAR longpathW[MAX_PATH];
400 DWORD ret;
401
402 TRACE("%s\n", debugstr_a(shortpath));
403
404 if (!(shortpathW = FILE_name_AtoW( shortpath, FALSE ))) return 0;
405
406 ret = GetLongPathNameW(shortpathW, longpathW, MAX_PATH);
407
408 if (!ret) return 0;
409 if (ret > MAX_PATH)
410 {
411 SetLastError(ERROR_FILENAME_EXCED_RANGE);
412 return 0;
413 }
414 return copy_filename_WtoA( longpathW, longpath, longlen );
415 }
416
417
418 /***********************************************************************
419 * GetShortPathNameW (KERNEL32.@)
420 *
421 * NOTES
422 * observed:
423 * longpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
424 * longpath="" or invalid: LastError=ERROR_BAD_PATHNAME, ret=0
425 *
426 * more observations ( with NT 3.51 (WinDD) ):
427 * longpath <= 8.3 -> just copy longpath to shortpath
428 * longpath > 8.3 ->
429 * a) file does not exist -> return 0, LastError = ERROR_FILE_NOT_FOUND
430 * b) file does exist -> set the short filename.
431 * - trailing slashes are reproduced in the short name, even if the
432 * file is not a directory
433 * - the absolute/relative path of the short name is reproduced like found
434 * in the long name
435 * - longpath and shortpath may have the same address
436 * Peter Ganten, 1999
437 */
438 DWORD WINAPI GetShortPathNameW( LPCWSTR longpath, LPWSTR shortpath, DWORD shortlen )
439 {
440 WCHAR *tmpshortpath;
441 LPCWSTR p;
442 DWORD sp = 0, lp = 0;
443 DWORD tmplen, buf_len;
444 WIN32_FIND_DATAW wfd;
445 HANDLE goit;
446
447 TRACE("%s\n", debugstr_w(longpath));
448
449 if (!longpath)
450 {
451 SetLastError(ERROR_INVALID_PARAMETER);
452 return 0;
453 }
454 if (!longpath[0])
455 {
456 SetLastError(ERROR_BAD_PATHNAME);
457 return 0;
458 }
459
460 /* code below only removes characters from string, never adds, so this is
461 * the largest buffer that tmpshortpath will need to have */
462 buf_len = strlenW(longpath) + 1;
463 tmpshortpath = HeapAlloc(GetProcessHeap(), 0, buf_len * sizeof(WCHAR));
464 if (!tmpshortpath)
465 {
466 SetLastError(ERROR_OUTOFMEMORY);
467 return 0;
468 }
469
470 if (longpath[0] == '\\' && longpath[1] == '\\' && longpath[2] == '?' && longpath[3] == '\\')
471 {
472 memcpy(tmpshortpath, longpath, 4 * sizeof(WCHAR));
473 sp = lp = 4;
474 }
475
476 /* check for drive letter */
477 if (longpath[lp] != '/' && longpath[lp + 1] == ':' )
478 {
479 tmpshortpath[sp] = longpath[lp];
480 tmpshortpath[sp + 1] = ':';
481 sp += 2;
482 lp += 2;
483 }
484
485 while (longpath[lp])
486 {
487 /* check for path delimiters and reproduce them */
488 if (longpath[lp] == '\\' || longpath[lp] == '/')
489 {
490 tmpshortpath[sp++] = longpath[lp++];
491 tmpshortpath[sp] = 0; /* terminate string */
492 continue;
493 }
494
495 p = longpath + lp;
496 for (; *p && *p != '/' && *p != '\\'; p++);
497 tmplen = p - (longpath + lp);
498 lstrcpynW(tmpshortpath + sp, longpath + lp, tmplen + 1);
499
500 if (tmpshortpath[sp] == '.')
501 {
502 if (tmplen == 1 || (tmplen == 2 && tmpshortpath[sp + 1] == '.'))
503 {
504 sp += tmplen;
505 lp += tmplen;
506 continue;
507 }
508 }
509
510 /* Check if the file exists and use the existing short file name */
511 goit = FindFirstFileW(tmpshortpath, &wfd);
512 if (goit == INVALID_HANDLE_VALUE) goto notfound;
513 FindClose(goit);
514
515 /* In rare cases (like "a.abcd") short path may be longer than original path.
516 * Make sure we have enough space in temp buffer. */
517 if (wfd.cAlternateFileName[0] && tmplen < strlenW(wfd.cAlternateFileName))
518 {
519 WCHAR *new_buf;
520 buf_len += strlenW(wfd.cAlternateFileName) - tmplen;
521 new_buf = HeapReAlloc(GetProcessHeap(), 0, tmpshortpath, buf_len * sizeof(WCHAR));
522 if(!new_buf)
523 {
524 HeapFree(GetProcessHeap(), 0, tmpshortpath);
525 SetLastError(ERROR_OUTOFMEMORY);
526 return 0;
527 }
528 tmpshortpath = new_buf;
529 }
530
531 strcpyW(tmpshortpath + sp, wfd.cAlternateFileName[0] ? wfd.cAlternateFileName : wfd.cFileName);
532 sp += strlenW(tmpshortpath + sp);
533 lp += tmplen;
534 }
535 tmpshortpath[sp] = 0;
536
537 tmplen = strlenW(tmpshortpath) + 1;
538 if (tmplen <= shortlen)
539 {
540 strcpyW(shortpath, tmpshortpath);
541 TRACE("returning %s\n", debugstr_w(shortpath));
542 tmplen--; /* length without 0 */
543 }
544
545 HeapFree(GetProcessHeap(), 0, tmpshortpath);
546 return tmplen;
547
548 notfound:
549 HeapFree(GetProcessHeap(), 0, tmpshortpath);
550 TRACE("not found!\n" );
551 SetLastError ( ERROR_FILE_NOT_FOUND );
552 return 0;
553 }
554
555 /***********************************************************************
556 * GetShortPathNameA (KERNEL32.@)
557 */
558 DWORD WINAPI GetShortPathNameA( LPCSTR longpath, LPSTR shortpath, DWORD shortlen )
559 {
560 WCHAR *longpathW;
561 WCHAR shortpathW[MAX_PATH];
562 DWORD ret;
563
564 TRACE("%s\n", debugstr_a(longpath));
565
566 if (!(longpathW = FILE_name_AtoW( longpath, FALSE ))) return 0;
567
568 ret = GetShortPathNameW(longpathW, shortpathW, MAX_PATH);
569
570 if (!ret) return 0;
571 if (ret > MAX_PATH)
572 {
573 SetLastError(ERROR_FILENAME_EXCED_RANGE);
574 return 0;
575 }
576 return copy_filename_WtoA( shortpathW, shortpath, shortlen );
577 }
578
579
580 /***********************************************************************
581 * GetTempPathA (KERNEL32.@)
582 */
583 DWORD WINAPI GetTempPathA( DWORD count, LPSTR path )
584 {
585 WCHAR pathW[MAX_PATH];
586 UINT ret;
587
588 ret = GetTempPathW(MAX_PATH, pathW);
589
590 if (!ret)
591 return 0;
592
593 if (ret > MAX_PATH)
594 {
595 SetLastError(ERROR_FILENAME_EXCED_RANGE);
596 return 0;
597 }
598 return copy_filename_WtoA( pathW, path, count );
599 }
600
601
602 /***********************************************************************
603 * GetTempPathW (KERNEL32.@)
604 */
605 DWORD WINAPI GetTempPathW( DWORD count, LPWSTR path )
606 {
607 static const WCHAR tmp[] = { 'T', 'M', 'P', 0 };
608 static const WCHAR temp[] = { 'T', 'E', 'M', 'P', 0 };
609 static const WCHAR userprofile[] = { 'U','S','E','R','P','R','O','F','I','L','E',0 };
610 WCHAR tmp_path[MAX_PATH];
611 UINT ret;
612
613 TRACE("%u,%p\n", count, path);
614
615 if (!(ret = GetEnvironmentVariableW( tmp, tmp_path, MAX_PATH )) &&
616 !(ret = GetEnvironmentVariableW( temp, tmp_path, MAX_PATH )) &&
617 !(ret = GetEnvironmentVariableW( userprofile, tmp_path, MAX_PATH )) &&
618 !(ret = GetWindowsDirectoryW( tmp_path, MAX_PATH )))
619 return 0;
620
621 if (ret > MAX_PATH)
622 {
623 SetLastError(ERROR_FILENAME_EXCED_RANGE);
624 return 0;
625 }
626
627 ret = GetFullPathNameW(tmp_path, MAX_PATH, tmp_path, NULL);
628 if (!ret) return 0;
629
630 if (ret > MAX_PATH - 2)
631 {
632 SetLastError(ERROR_FILENAME_EXCED_RANGE);
633 return 0;
634 }
635
636 if (tmp_path[ret-1] != '\\')
637 {
638 tmp_path[ret++] = '\\';
639 tmp_path[ret] = '\0';
640 }
641
642 ret++; /* add space for terminating 0 */
643
644 if (count >= ret)
645 {
646 lstrcpynW(path, tmp_path, count);
647 /* the remaining buffer must be zeroed up to 32766 bytes in XP or 32767
648 * bytes after it, we will assume the > XP behavior for now */
649 memset(path + ret, 0, (min(count, 32767) - ret) * sizeof(WCHAR));
650 ret--; /* return length without 0 */
651 }
652 else if (count)
653 {
654 /* the buffer must be cleared if contents will not fit */
655 memset(path, 0, count * sizeof(WCHAR));
656 }
657
658 TRACE("returning %u, %s\n", ret, debugstr_w(path));
659 return ret;
660 }
661
662
663 /***********************************************************************
664 * GetTempFileNameA (KERNEL32.@)
665 */
666 UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique, LPSTR buffer)
667 {
668 WCHAR *pathW, *prefixW = NULL;
669 WCHAR bufferW[MAX_PATH];
670 UINT ret;
671
672 if (!(pathW = FILE_name_AtoW( path, FALSE ))) return 0;
673 if (prefix && !(prefixW = FILE_name_AtoW( prefix, TRUE ))) return 0;
674
675 ret = GetTempFileNameW(pathW, prefixW, unique, bufferW);
676 if (ret) FILE_name_WtoA( bufferW, -1, buffer, MAX_PATH );
677
678 HeapFree( GetProcessHeap(), 0, prefixW );
679 return ret;
680 }
681
682 /***********************************************************************
683 * GetTempFileNameW (KERNEL32.@)
684 */
685 UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique, LPWSTR buffer )
686 {
687 static const WCHAR formatW[] = {'%','x','.','t','m','p',0};
688
689 int i;
690 LPWSTR p;
691 DWORD attr;
692
693 if ( !path || !buffer )
694 {
695 SetLastError( ERROR_INVALID_PARAMETER );
696 return 0;
697 }
698
699 /* ensure that the provided directory exists */
700 attr = GetFileAttributesW(path);
701 if (attr == INVALID_FILE_ATTRIBUTES || !(attr & FILE_ATTRIBUTE_DIRECTORY))
702 {
703 TRACE("path not found %s\n", debugstr_w(path));
704 SetLastError( ERROR_DIRECTORY );
705 return 0;
706 }
707
708 strcpyW( buffer, path );
709 p = buffer + strlenW(buffer);
710
711 /* add a \, if there isn't one */
712 if ((p == buffer) || (p[-1] != '\\')) *p++ = '\\';
713
714 if (prefix)
715 for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
716
717 unique &= 0xffff;
718
719 if (unique) sprintfW( p, formatW, unique );
720 else
721 {
722 /* get a "random" unique number and try to create the file */
723 HANDLE handle;
724 UINT num = GetTickCount() & 0xffff;
725 static UINT last;
726
727 /* avoid using the same name twice in a short interval */
728 if (last - num < 10) num = last + 1;
729 if (!num) num = 1;
730 unique = num;
731 do
732 {
733 sprintfW( p, formatW, unique );
734 handle = CreateFileW( buffer, GENERIC_WRITE, 0, NULL,
735 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
736 if (handle != INVALID_HANDLE_VALUE)
737 { /* We created it */
738 TRACE("created %s\n", debugstr_w(buffer) );
739 CloseHandle( handle );
740 last = unique;
741 break;
742 }
743 if (GetLastError() != ERROR_FILE_EXISTS &&
744 GetLastError() != ERROR_SHARING_VIOLATION)
745 break; /* No need to go on */
746 if (!(++unique & 0xffff)) unique = 1;
747 } while (unique != num);
748 }
749
750 TRACE("returning %s\n", debugstr_w(buffer) );
751 return unique;
752 }
753
754
755 /***********************************************************************
756 * contains_pathW
757 *
758 * Check if the file name contains a path; helper for SearchPathW.
759 * A relative path is not considered a path unless it starts with ./ or ../
760 */
761 static inline BOOL contains_pathW (LPCWSTR name)
762 {
763 if (RtlDetermineDosPathNameType_U( name ) != RELATIVE_PATH) return TRUE;
764 if (name[0] != '.') return FALSE;
765 if (name[1] == '/' || name[1] == '\\') return TRUE;
766 return (name[1] == '.' && (name[2] == '/' || name[2] == '\\'));
767 }
768
769 /***********************************************************************
770 * find_actctx_dllpath
771 *
772 * Find the path (if any) of the dll from the activation context.
773 * Returned path doesn't include a name.
774 */
775 static NTSTATUS find_actctx_dllpath(const WCHAR *libname, WCHAR **path)
776 {
777 static const WCHAR winsxsW[] = {'\\','w','i','n','s','x','s','\\'};
778 static const WCHAR dotManifestW[] = {'.','m','a','n','i','f','e','s','t',0};
779
780 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *info;
781 ACTCTX_SECTION_KEYED_DATA data;
782 UNICODE_STRING nameW;
783 NTSTATUS status;
784 SIZE_T needed, size = 1024;
785 WCHAR *p;
786
787 RtlInitUnicodeString( &nameW, libname );
788 data.cbSize = sizeof(data);
789 status = RtlFindActivationContextSectionString( FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
790 ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
791 &nameW, &data );
792 if (status != STATUS_SUCCESS) return status;
793
794 for (;;)
795 {
796 if (!(info = HeapAlloc( GetProcessHeap(), 0, size )))
797 {
798 status = STATUS_NO_MEMORY;
799 goto done;
800 }
801 status = RtlQueryInformationActivationContext( 0, data.hActCtx, &data.ulAssemblyRosterIndex,
802 AssemblyDetailedInformationInActivationContext,
803 info, size, &needed );
804 if (status == STATUS_SUCCESS) break;
805 if (status != STATUS_BUFFER_TOO_SMALL) goto done;
806 HeapFree( GetProcessHeap(), 0, info );
807 size = needed;
808 /* restart with larger buffer */
809 }
810
811 if (!info->lpAssemblyManifestPath || !info->lpAssemblyDirectoryName)
812 {
813 status = STATUS_SXS_KEY_NOT_FOUND;
814 goto done;
815 }
816
817 if ((p = strrchrW( info->lpAssemblyManifestPath, '\\' )))
818 {
819 DWORD dirlen = info->ulAssemblyDirectoryNameLength / sizeof(WCHAR);
820
821 p++;
822 if (strncmpiW( p, info->lpAssemblyDirectoryName, dirlen ) || strcmpiW( p + dirlen, dotManifestW ))
823 {
824 /* manifest name does not match directory name, so it's not a global
825 * windows/winsxs manifest; use the manifest directory name instead */
826 dirlen = p - info->lpAssemblyManifestPath;
827 needed = (dirlen + 1) * sizeof(WCHAR);
828 if (!(*path = p = HeapAlloc( GetProcessHeap(), 0, needed )))
829 {
830 status = STATUS_NO_MEMORY;
831 goto done;
832 }
833 memcpy( p, info->lpAssemblyManifestPath, dirlen * sizeof(WCHAR) );
834 *(p + dirlen) = 0;
835 goto done;
836 }
837 }
838
839 needed = (strlenW( DIR_Windows ) * sizeof(WCHAR) +
840 sizeof(winsxsW) + info->ulAssemblyDirectoryNameLength + 2*sizeof(WCHAR));
841
842 if (!(*path = p = HeapAlloc( GetProcessHeap(), 0, needed )))
843 {
844 status = STATUS_NO_MEMORY;
845 goto done;
846 }
847 strcpyW( p, DIR_Windows );
848 p += strlenW(p);
849 memcpy( p, winsxsW, sizeof(winsxsW) );
850 p += sizeof(winsxsW) / sizeof(WCHAR);
851 memcpy( p, info->lpAssemblyDirectoryName, info->ulAssemblyDirectoryNameLength );
852 p += info->ulAssemblyDirectoryNameLength / sizeof(WCHAR);
853 *p++ = '\\';
854 *p = 0;
855 done:
856 HeapFree( GetProcessHeap(), 0, info );
857 RtlReleaseActivationContext( data.hActCtx );
858 return status;
859 }
860
861 /***********************************************************************
862 * SearchPathW [KERNEL32.@]
863 *
864 * Searches for a specified file in the search path.
865 *
866 * PARAMS
867 * path [I] Path to search (NULL means default)
868 * name [I] Filename to search for.
869 * ext [I] File extension to append to file name. The first
870 * character must be a period. This parameter is
871 * specified only if the filename given does not
872 * contain an extension.
873 * buflen [I] size of buffer, in characters
874 * buffer [O] buffer for found filename
875 * lastpart [O] address of pointer to last used character in
876 * buffer (the final '\')
877 *
878 * RETURNS
879 * Success: length of string copied into buffer, not including
880 * terminating null character. If the filename found is
881 * longer than the length of the buffer, the length of the
882 * filename is returned.
883 * Failure: Zero
884 *
885 * NOTES
886 * If the file is not found, calls SetLastError(ERROR_FILE_NOT_FOUND)
887 * (tested on NT 4.0)
888 */
889 DWORD WINAPI SearchPathW( LPCWSTR path, LPCWSTR name, LPCWSTR ext, DWORD buflen,
890 LPWSTR buffer, LPWSTR *lastpart )
891 {
892 DWORD ret = 0;
893
894 if (!name || !name[0])
895 {
896 SetLastError(ERROR_INVALID_PARAMETER);
897 return 0;
898 }
899
900 /* If the name contains an explicit path, ignore the path */
901
902 if (contains_pathW(name))
903 {
904 /* try first without extension */
905 if (RtlDoesFileExists_U( name ))
906 return GetFullPathNameW( name, buflen, buffer, lastpart );
907
908 if (ext)
909 {
910 LPCWSTR p = strrchrW( name, '.' );
911 if (p && !strchrW( p, '/' ) && !strchrW( p, '\\' ))
912 ext = NULL; /* Ignore the specified extension */
913 }
914
915 /* Allocate a buffer for the file name and extension */
916 if (ext)
917 {
918 LPWSTR tmp;
919 DWORD len = strlenW(name) + strlenW(ext);
920
921 if (!(tmp = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
922 {
923 SetLastError( ERROR_OUTOFMEMORY );
924 return 0;
925 }
926 strcpyW( tmp, name );
927 strcatW( tmp, ext );
928 if (RtlDoesFileExists_U( tmp ))
929 ret = GetFullPathNameW( tmp, buflen, buffer, lastpart );
930 HeapFree( GetProcessHeap(), 0, tmp );
931 }
932 }
933 else if (path && path[0]) /* search in the specified path */
934 {
935 ret = RtlDosSearchPath_U( path, name, ext, buflen * sizeof(WCHAR),
936 buffer, lastpart ) / sizeof(WCHAR);
937 }
938 else /* search in active context and default path */
939 {
940 WCHAR *dll_path = NULL, *search = NULL;
941 DWORD req_len, name_len;
942
943 req_len = name_len = strlenW(name);
944
945 if (strchrW( name, '.' )) ext = NULL;
946 if (ext)
947 {
948 DWORD ext_len = strlenW(ext);
949
950 req_len += ext_len;
951 name_len += ext_len;
952
953 search = HeapAlloc( GetProcessHeap(), 0, (name_len + ext_len + 1) * sizeof(WCHAR) );
954 if (!search)
955 {
956 SetLastError( ERROR_OUTOFMEMORY );
957 return 0;
958 }
959 strcpyW( search, name );
960 strcatW( search, ext );
961 name = search;
962
963 /* now that we have combined name we don't need extension any more */
964 }
965
966 /* When file is found with activation context no attempt is made
967 to check if it's really exist, path is returned only basing on context info. */
968 if (find_actctx_dllpath( name, &dll_path ) == STATUS_SUCCESS)
969 {
970 DWORD path_len;
971
972 path_len = strlenW(dll_path);
973 req_len += path_len;
974
975 if (lastpart) *lastpart = NULL;
976
977 /* count null termination char too */
978 if (req_len + 1 <= buflen)
979 {
980 memcpy( buffer, dll_path, path_len * sizeof(WCHAR) );
981 memcpy( &buffer[path_len], name, name_len * sizeof(WCHAR) );
982 buffer[req_len] = 0;
983 if (lastpart) *lastpart = buffer + path_len;
984 ret = req_len;
985 }
986 else
987 ret = req_len + 1;
988
989 HeapFree( GetProcessHeap(), 0, dll_path );
990 HeapFree( GetProcessHeap(), 0, search );
991 }
992 else
993 {
994 if ((dll_path = MODULE_get_dll_load_path( NULL )))
995 {
996 ret = RtlDosSearchPath_U( dll_path, name, NULL, buflen * sizeof(WCHAR),
997 buffer, lastpart ) / sizeof(WCHAR);
998 HeapFree( GetProcessHeap(), 0, dll_path );
999 HeapFree( GetProcessHeap(), 0, search );
1000 }
1001 else
1002 {
1003 SetLastError( ERROR_OUTOFMEMORY );
1004 return 0;
1005 }
1006 }
1007 }
1008
1009 if (!ret) SetLastError( ERROR_FILE_NOT_FOUND );
1010 else TRACE( "found %s\n", debugstr_w(buffer) );
1011 return ret;
1012 }
1013
1014
1015 /***********************************************************************
1016 * SearchPathA (KERNEL32.@)
1017 *
1018 * See SearchPathW.
1019 */
1020 DWORD WINAPI SearchPathA( LPCSTR path, LPCSTR name, LPCSTR ext,
1021 DWORD buflen, LPSTR buffer, LPSTR *lastpart )
1022 {
1023 WCHAR *pathW = NULL, *nameW, *extW = NULL;
1024 WCHAR bufferW[MAX_PATH];
1025 DWORD ret;
1026
1027 if (!name)
1028 {
1029 SetLastError(ERROR_INVALID_PARAMETER);
1030 return 0;
1031 }
1032
1033 if (!(nameW = FILE_name_AtoW( name, FALSE ))) return 0;
1034 if (path && !(pathW = FILE_name_AtoW( path, TRUE ))) return 0;
1035
1036 if (ext && !(extW = FILE_name_AtoW( ext, TRUE )))
1037 {
1038 HeapFree( GetProcessHeap(), 0, pathW );
1039 return 0;
1040 }
1041
1042 ret = SearchPathW(pathW, nameW, extW, MAX_PATH, bufferW, NULL);
1043
1044 HeapFree( GetProcessHeap(), 0, pathW );
1045 HeapFree( GetProcessHeap(), 0, extW );
1046
1047 if (!ret) return 0;
1048 if (ret > MAX_PATH)
1049 {
1050 SetLastError(ERROR_FILENAME_EXCED_RANGE);
1051 return 0;
1052 }
1053 ret = copy_filename_WtoA( bufferW, buffer, buflen );
1054 if (buflen > ret && lastpart)
1055 *lastpart = strrchr(buffer, '\\') + 1;
1056 return ret;
1057 }
1058
1059 static BOOL is_same_file(HANDLE h1, HANDLE h2)
1060 {
1061 int fd1;
1062 BOOL ret = FALSE;
1063 if (wine_server_handle_to_fd(h1, 0, &fd1, NULL) == STATUS_SUCCESS)
1064 {
1065 int fd2;
1066 if (wine_server_handle_to_fd(h2, 0, &fd2, NULL) == STATUS_SUCCESS)
1067 {
1068 struct stat stat1, stat2;
1069 if (fstat(fd1, &stat1) == 0 && fstat(fd2, &stat2) == 0)
1070 ret = (stat1.st_dev == stat2.st_dev && stat1.st_ino == stat2.st_ino);
1071 wine_server_release_fd(h2, fd2);
1072 }
1073 wine_server_release_fd(h1, fd1);
1074 }
1075 return ret;
1076 }
1077
1078 /**************************************************************************
1079 * CopyFileW (KERNEL32.@)
1080 */
1081 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists )
1082 {
1083 return CopyFileExW( source, dest, NULL, NULL, NULL,
1084 fail_if_exists ? COPY_FILE_FAIL_IF_EXISTS : 0 );
1085 }
1086
1087
1088 /**************************************************************************
1089 * CopyFileA (KERNEL32.@)
1090 */
1091 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists)
1092 {
1093 WCHAR *sourceW, *destW;
1094 BOOL ret;
1095
1096 if (!(sourceW = FILE_name_AtoW( source, FALSE ))) return FALSE;
1097 if (!(destW = FILE_name_AtoW( dest, TRUE ))) return FALSE;
1098
1099 ret = CopyFileW( sourceW, destW, fail_if_exists );
1100
1101 HeapFree( GetProcessHeap(), 0, destW );
1102 return ret;
1103 }
1104
1105
1106 /**************************************************************************
1107 * CopyFileExW (KERNEL32.@)
1108 */
1109 BOOL WINAPI CopyFileExW(LPCWSTR source, LPCWSTR dest,
1110 LPPROGRESS_ROUTINE progress, LPVOID param,
1111 LPBOOL cancel_ptr, DWORD flags)
1112 {
1113 static const int buffer_size = 65536;
1114 HANDLE h1, h2;
1115 BY_HANDLE_FILE_INFORMATION info;
1116 DWORD count;
1117 BOOL ret = FALSE;
1118 char *buffer;
1119
1120 if (!source || !dest)
1121 {
1122 SetLastError(ERROR_INVALID_PARAMETER);
1123 return FALSE;
1124 }
1125 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, buffer_size )))
1126 {
1127 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1128 return FALSE;
1129 }
1130
1131 TRACE("%s -> %s, %x\n", debugstr_w(source), debugstr_w(dest), flags);
1132
1133 if ((h1 = CreateFileW(source, GENERIC_READ,
1134 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1135 NULL, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
1136 {
1137 WARN("Unable to open source %s\n", debugstr_w(source));
1138 HeapFree( GetProcessHeap(), 0, buffer );
1139 return FALSE;
1140 }
1141
1142 if (!GetFileInformationByHandle( h1, &info ))
1143 {
1144 WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source));
1145 HeapFree( GetProcessHeap(), 0, buffer );
1146 CloseHandle( h1 );
1147 return FALSE;
1148 }
1149
1150 if (!(flags & COPY_FILE_FAIL_IF_EXISTS))
1151 {
1152 BOOL same_file = FALSE;
1153 h2 = CreateFileW( dest, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1154 OPEN_EXISTING, 0, 0);
1155 if (h2 != INVALID_HANDLE_VALUE)
1156 {
1157 same_file = is_same_file( h1, h2 );
1158 CloseHandle( h2 );
1159 }
1160 if (same_file)
1161 {
1162 HeapFree( GetProcessHeap(), 0, buffer );
1163 CloseHandle( h1 );
1164 SetLastError( ERROR_SHARING_VIOLATION );
1165 return FALSE;
1166 }
1167 }
1168
1169 if ((h2 = CreateFileW( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1170 (flags & COPY_FILE_FAIL_IF_EXISTS) ? CREATE_NEW : CREATE_ALWAYS,
1171 info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
1172 {
1173 WARN("Unable to open dest %s\n", debugstr_w(dest));
1174 HeapFree( GetProcessHeap(), 0, buffer );
1175 CloseHandle( h1 );
1176 return FALSE;
1177 }
1178
1179 while (ReadFile( h1, buffer, buffer_size, &count, NULL ) && count)
1180 {
1181 char *p = buffer;
1182 while (count != 0)
1183 {
1184 DWORD res;
1185 if (!WriteFile( h2, p, count, &res, NULL ) || !res) goto done;
1186 p += res;
1187 count -= res;
1188 }
1189 }
1190 ret = TRUE;
1191 done:
1192 /* Maintain the timestamp of source file to destination file */
1193 SetFileTime(h2, NULL, NULL, &info.ftLastWriteTime);
1194 HeapFree( GetProcessHeap(), 0, buffer );
1195 CloseHandle( h1 );
1196 CloseHandle( h2 );
1197 return ret;
1198 }
1199
1200
1201 /**************************************************************************
1202 * CopyFileExA (KERNEL32.@)
1203 */
1204 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename, LPCSTR destFilename,
1205 LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
1206 LPBOOL cancelFlagPointer, DWORD copyFlags)
1207 {
1208 WCHAR *sourceW, *destW;
1209 BOOL ret;
1210
1211 /* can't use the TEB buffer since we may have a callback routine */
1212 if (!(sourceW = FILE_name_AtoW( sourceFilename, TRUE ))) return FALSE;
1213 if (!(destW = FILE_name_AtoW( destFilename, TRUE )))
1214 {
1215 HeapFree( GetProcessHeap(), 0, sourceW );
1216 return FALSE;
1217 }
1218 ret = CopyFileExW(sourceW, destW, progressRoutine, appData,
1219 cancelFlagPointer, copyFlags);
1220 HeapFree( GetProcessHeap(), 0, sourceW );
1221 HeapFree( GetProcessHeap(), 0, destW );
1222 return ret;
1223 }
1224
1225
1226 /**************************************************************************
1227 * MoveFileWithProgressW (KERNEL32.@)
1228 */
1229 BOOL WINAPI MoveFileWithProgressW( LPCWSTR source, LPCWSTR dest,
1230 LPPROGRESS_ROUTINE fnProgress,
1231 LPVOID param, DWORD flag )
1232 {
1233 FILE_BASIC_INFORMATION info;
1234 UNICODE_STRING nt_name;
1235 OBJECT_ATTRIBUTES attr;
1236 IO_STATUS_BLOCK io;
1237 NTSTATUS status;
1238 HANDLE source_handle = 0, dest_handle;
1239 ANSI_STRING source_unix, dest_unix;
1240
1241 TRACE("(%s,%s,%p,%p,%04x)\n",
1242 debugstr_w(source), debugstr_w(dest), fnProgress, param, flag );
1243
1244 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
1245 return add_boot_rename_entry( source, dest, flag );
1246
1247 if (!dest)
1248 return DeleteFileW( source );
1249
1250 if (flag & MOVEFILE_WRITE_THROUGH)
1251 FIXME("MOVEFILE_WRITE_THROUGH unimplemented\n");
1252
1253 /* check if we are allowed to rename the source */
1254
1255 if (!RtlDosPathNameToNtPathName_U( source, &nt_name, NULL, NULL ))
1256 {
1257 SetLastError( ERROR_PATH_NOT_FOUND );
1258 return FALSE;
1259 }
1260 source_unix.Buffer = NULL;
1261 dest_unix.Buffer = NULL;
1262 attr.Length = sizeof(attr);
1263 attr.RootDirectory = 0;
1264 attr.Attributes = OBJ_CASE_INSENSITIVE;
1265 attr.ObjectName = &nt_name;
1266 attr.SecurityDescriptor = NULL;
1267 attr.SecurityQualityOfService = NULL;
1268
1269 status = NtOpenFile( &source_handle, SYNCHRONIZE, &attr, &io, 0, FILE_SYNCHRONOUS_IO_NONALERT );
1270 if (status == STATUS_SUCCESS)
1271 status = wine_nt_to_unix_file_name( &nt_name, &source_unix, FILE_OPEN, FALSE );
1272 RtlFreeUnicodeString( &nt_name );
1273 if (status != STATUS_SUCCESS)
1274 {
1275 SetLastError( RtlNtStatusToDosError(status) );
1276 goto error;
1277 }
1278 status = NtQueryInformationFile( source_handle, &io, &info, sizeof(info), FileBasicInformation );
1279 if (status != STATUS_SUCCESS)
1280 {
1281 SetLastError( RtlNtStatusToDosError(status) );
1282 goto error;
1283 }
1284
1285 /* we must have write access to the destination, and it must */
1286 /* not exist except if MOVEFILE_REPLACE_EXISTING is set */
1287
1288 if (!RtlDosPathNameToNtPathName_U( dest, &nt_name, NULL, NULL ))
1289 {
1290 SetLastError( ERROR_PATH_NOT_FOUND );
1291 goto error;
1292 }
1293 status = NtOpenFile( &dest_handle, GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, &attr, &io, 0,
1294 FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT );
1295 if (status == STATUS_SUCCESS) /* destination exists */
1296 {
1297 NtClose( dest_handle );
1298 if (!(flag & MOVEFILE_REPLACE_EXISTING))
1299 {
1300 SetLastError( ERROR_ALREADY_EXISTS );
1301 RtlFreeUnicodeString( &nt_name );
1302 goto error;
1303 }
1304 else if (info.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) /* cannot replace directory */
1305 {
1306 SetLastError( ERROR_ACCESS_DENIED );
1307 goto error;
1308 }
1309 }
1310 else if (status != STATUS_OBJECT_NAME_NOT_FOUND)
1311 {
1312 SetLastError( RtlNtStatusToDosError(status) );
1313 RtlFreeUnicodeString( &nt_name );
1314 goto error;
1315 }
1316
1317 status = wine_nt_to_unix_file_name( &nt_name, &dest_unix, FILE_OPEN_IF, FALSE );
1318 RtlFreeUnicodeString( &nt_name );
1319 if (status != STATUS_SUCCESS && status != STATUS_NO_SUCH_FILE)
1320 {
1321 SetLastError( RtlNtStatusToDosError(status) );
1322 goto error;
1323 }
1324
1325 /* now perform the rename */
1326
1327 if (rename( source_unix.Buffer, dest_unix.Buffer ) == -1)
1328 {
1329 if (errno == EXDEV && (flag & MOVEFILE_COPY_ALLOWED))
1330 {
1331 NtClose( source_handle );
1332 RtlFreeAnsiString( &source_unix );
1333 RtlFreeAnsiString( &dest_unix );
1334 if (!CopyFileExW( source, dest, fnProgress,
1335 param, NULL, COPY_FILE_FAIL_IF_EXISTS ))
1336 return FALSE;
1337 return DeleteFileW( source );
1338 }
1339 FILE_SetDosError();
1340 /* if we created the destination, remove it */
1341 if (io.Information == FILE_CREATED) unlink( dest_unix.Buffer );
1342 goto error;
1343 }
1344
1345 /* fixup executable permissions */
1346
1347 if (is_executable( source ) != is_executable( dest ))
1348 {
1349 struct stat fstat;
1350 if (stat( dest_unix.Buffer, &fstat ) != -1)
1351 {
1352 if (is_executable( dest ))
1353 /* set executable bit where read bit is set */
1354 fstat.st_mode |= (fstat.st_mode & 0444) >> 2;
1355 else
1356 fstat.st_mode &= ~0111;
1357 chmod( dest_unix.Buffer, fstat.st_mode );
1358 }
1359 }
1360
1361 NtClose( source_handle );
1362 RtlFreeAnsiString( &source_unix );
1363 RtlFreeAnsiString( &dest_unix );
1364 return TRUE;
1365
1366 error:
1367 if (source_handle) NtClose( source_handle );
1368 RtlFreeAnsiString( &source_unix );
1369 RtlFreeAnsiString( &dest_unix );
1370 return FALSE;
1371 }
1372
1373 /**************************************************************************
1374 * MoveFileWithProgressA (KERNEL32.@)
1375 */
1376 BOOL WINAPI MoveFileWithProgressA( LPCSTR source, LPCSTR dest,
1377 LPPROGRESS_ROUTINE fnProgress,
1378 LPVOID param, DWORD flag )
1379 {
1380 WCHAR *sourceW, *destW;
1381 BOOL ret;
1382
1383 if (!(sourceW = FILE_name_AtoW( source, FALSE ))) return FALSE;
1384 if (dest)
1385 {
1386 if (!(destW = FILE_name_AtoW( dest, TRUE ))) return FALSE;
1387 }
1388 else
1389 destW = NULL;
1390
1391 ret = MoveFileWithProgressW( sourceW, destW, fnProgress, param, flag );
1392 HeapFree( GetProcessHeap(), 0, destW );
1393 return ret;
1394 }
1395
1396 /**************************************************************************
1397 * MoveFileExW (KERNEL32.@)
1398 */
1399 BOOL WINAPI MoveFileExW( LPCWSTR source, LPCWSTR dest, DWORD flag )
1400 {
1401 return MoveFileWithProgressW( source, dest, NULL, NULL, flag );
1402 }
1403
1404 /**************************************************************************
1405 * MoveFileExA (KERNEL32.@)
1406 */
1407 BOOL WINAPI MoveFileExA( LPCSTR source, LPCSTR dest, DWORD flag )
1408 {
1409 return MoveFileWithProgressA( source, dest, NULL, NULL, flag );
1410 }
1411
1412
1413 /**************************************************************************
1414 * MoveFileW (KERNEL32.@)
1415 *
1416 * Move file or directory
1417 */
1418 BOOL WINAPI MoveFileW( LPCWSTR source, LPCWSTR dest )
1419 {
1420 return MoveFileExW( source, dest, MOVEFILE_COPY_ALLOWED );
1421 }
1422
1423
1424 /**************************************************************************
1425 * MoveFileA (KERNEL32.@)
1426 */
1427 BOOL WINAPI MoveFileA( LPCSTR source, LPCSTR dest )
1428 {
1429 return MoveFileExA( source, dest, MOVEFILE_COPY_ALLOWED );
1430 }
1431
1432
1433 /*************************************************************************
1434 * CreateHardLinkW (KERNEL32.@)
1435 */
1436 BOOL WINAPI CreateHardLinkW(LPCWSTR lpFileName, LPCWSTR lpExistingFileName,
1437 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1438 {
1439 NTSTATUS status;
1440 UNICODE_STRING ntDest, ntSource;
1441 ANSI_STRING unixDest, unixSource;
1442 BOOL ret = FALSE;
1443
1444 TRACE("(%s, %s, %p)\n", debugstr_w(lpFileName),
1445 debugstr_w(lpExistingFileName), lpSecurityAttributes);
1446
1447 ntDest.Buffer = ntSource.Buffer = NULL;
1448 if (!RtlDosPathNameToNtPathName_U( lpFileName, &ntDest, NULL, NULL ) ||
1449 !RtlDosPathNameToNtPathName_U( lpExistingFileName, &ntSource, NULL, NULL ))
1450 {
1451 SetLastError( ERROR_PATH_NOT_FOUND );
1452 goto err;
1453 }
1454
1455 unixSource.Buffer = unixDest.Buffer = NULL;
1456 status = wine_nt_to_unix_file_name( &ntSource, &unixSource, FILE_OPEN, FALSE );
1457 if (!status)
1458 {
1459 status = wine_nt_to_unix_file_name( &ntDest, &unixDest, FILE_CREATE, FALSE );
1460 if (!status) /* destination must not exist */
1461 {
1462 status = STATUS_OBJECT_NAME_EXISTS;
1463 } else if (status == STATUS_NO_SUCH_FILE)
1464 {
1465 status = STATUS_SUCCESS;
1466 }
1467 }
1468
1469 if (status)
1470 SetLastError( RtlNtStatusToDosError(status) );
1471 else if (!link( unixSource.Buffer, unixDest.Buffer ))
1472 {
1473 TRACE("Hardlinked '%s' to '%s'\n", debugstr_a( unixDest.Buffer ),
1474 debugstr_a( unixSource.Buffer ));
1475 ret = TRUE;
1476 }
1477 else
1478 FILE_SetDosError();
1479
1480 RtlFreeAnsiString( &unixSource );
1481 RtlFreeAnsiString( &unixDest );
1482
1483 err:
1484 RtlFreeUnicodeString( &ntSource );
1485 RtlFreeUnicodeString( &ntDest );
1486 return ret;
1487 }
1488
1489
1490 /*************************************************************************
1491 * CreateHardLinkA (KERNEL32.@)
1492 */
1493 BOOL WINAPI CreateHardLinkA(LPCSTR lpFileName, LPCSTR lpExistingFileName,
1494 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1495 {
1496 WCHAR *sourceW, *destW;
1497 BOOL res;
1498
1499 if (!(sourceW = FILE_name_AtoW( lpExistingFileName, TRUE )))
1500 {
1501 return FALSE;
1502 }
1503 if (!(destW = FILE_name_AtoW( lpFileName, TRUE )))
1504 {
1505 HeapFree( GetProcessHeap(), 0, sourceW );
1506 return FALSE;
1507 }
1508
1509 res = CreateHardLinkW( destW, sourceW, lpSecurityAttributes );
1510
1511 HeapFree( GetProcessHeap(), 0, sourceW );
1512 HeapFree( GetProcessHeap(), 0, destW );
1513
1514 return res;
1515 }
1516
1517
1518 /***********************************************************************
1519 * CreateDirectoryW (KERNEL32.@)
1520 * RETURNS:
1521 * TRUE : success
1522 * FALSE : failure
1523 * ERROR_DISK_FULL: on full disk
1524 * ERROR_ALREADY_EXISTS: if directory name exists (even as file)
1525 * ERROR_ACCESS_DENIED: on permission problems
1526 * ERROR_FILENAME_EXCED_RANGE: too long filename(s)
1527 */
1528 BOOL WINAPI CreateDirectoryW( LPCWSTR path, LPSECURITY_ATTRIBUTES sa )
1529 {
1530 OBJECT_ATTRIBUTES attr;
1531 UNICODE_STRING nt_name;
1532 IO_STATUS_BLOCK io;
1533 NTSTATUS status;
1534 HANDLE handle;
1535 BOOL ret = FALSE;
1536
1537 TRACE( "%s\n", debugstr_w(path) );
1538
1539 if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
1540 {
1541 SetLastError( ERROR_PATH_NOT_FOUND );
1542 return FALSE;
1543 }
1544 attr.Length = sizeof(attr);
1545 attr.RootDirectory = 0;
1546 attr.Attributes = OBJ_CASE_INSENSITIVE;
1547 attr.ObjectName = &nt_name;
1548 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1549 attr.SecurityQualityOfService = NULL;
1550
1551 status = NtCreateFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr, &io, NULL,
1552 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_CREATE,
1553 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 );
1554
1555 if (status == STATUS_SUCCESS)
1556 {
1557 NtClose( handle );
1558 ret = TRUE;
1559 }
1560 else SetLastError( RtlNtStatusToDosError(status) );
1561
1562 RtlFreeUnicodeString( &nt_name );
1563 return ret;
1564 }
1565
1566
1567 /***********************************************************************
1568 * CreateDirectoryA (KERNEL32.@)
1569 */
1570 BOOL WINAPI CreateDirectoryA( LPCSTR path, LPSECURITY_ATTRIBUTES sa )
1571 {
1572 WCHAR *pathW;
1573
1574 if (!(pathW = FILE_name_AtoW( path, FALSE ))) return FALSE;
1575 return CreateDirectoryW( pathW, sa );
1576 }
1577
1578
1579 /***********************************************************************
1580 * CreateDirectoryExA (KERNEL32.@)
1581 */
1582 BOOL WINAPI CreateDirectoryExA( LPCSTR template, LPCSTR path, LPSECURITY_ATTRIBUTES sa )
1583 {
1584 WCHAR *pathW, *templateW = NULL;
1585 BOOL ret;
1586
1587 if (!(pathW = FILE_name_AtoW( path, FALSE ))) return FALSE;
1588 if (template && !(templateW = FILE_name_AtoW( template, TRUE ))) return FALSE;
1589
1590 ret = CreateDirectoryExW( templateW, pathW, sa );
1591 HeapFree( GetProcessHeap(), 0, templateW );
1592 return ret;
1593 }
1594
1595
1596 /***********************************************************************
1597 * CreateDirectoryExW (KERNEL32.@)
1598 */
1599 BOOL WINAPI CreateDirectoryExW( LPCWSTR template, LPCWSTR path, LPSECURITY_ATTRIBUTES sa )
1600 {
1601 return CreateDirectoryW( path, sa );
1602 }
1603
1604
1605 /***********************************************************************
1606 * RemoveDirectoryW (KERNEL32.@)
1607 */
1608 BOOL WINAPI RemoveDirectoryW( LPCWSTR path )
1609 {
1610 OBJECT_ATTRIBUTES attr;
1611 UNICODE_STRING nt_name;
1612 ANSI_STRING unix_name;
1613 IO_STATUS_BLOCK io;
1614 NTSTATUS status;
1615 HANDLE handle;
1616 BOOL ret = FALSE;
1617
1618 TRACE( "%s\n", debugstr_w(path) );
1619
1620 if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
1621 {
1622 SetLastError( ERROR_PATH_NOT_FOUND );
1623 return FALSE;
1624 }
1625 attr.Length = sizeof(attr);
1626 attr.RootDirectory = 0;
1627 attr.Attributes = OBJ_CASE_INSENSITIVE;
1628 attr.ObjectName = &nt_name;
1629 attr.SecurityDescriptor = NULL;
1630 attr.SecurityQualityOfService = NULL;
1631
1632 status = NtOpenFile( &handle, DELETE | SYNCHRONIZE, &attr, &io,
1633 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1634 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT );
1635 if (status != STATUS_SUCCESS)
1636 {
1637 SetLastError( RtlNtStatusToDosError(status) );
1638 RtlFreeUnicodeString( &nt_name );
1639 return FALSE;
1640 }
1641
1642 status = wine_nt_to_unix_file_name( &nt_name, &unix_name, FILE_OPEN, FALSE );
1643 RtlFreeUnicodeString( &nt_name );
1644 if (status != STATUS_SUCCESS)
1645 {
1646 SetLastError( RtlNtStatusToDosError(status) );
1647 NtClose( handle );
1648 return FALSE;
1649 }
1650
1651 if (!(ret = (rmdir( unix_name.Buffer ) != -1))) FILE_SetDosError();
1652 RtlFreeAnsiString( &unix_name );
1653 NtClose( handle );
1654 return ret;
1655 }
1656
1657
1658 /***********************************************************************
1659 * RemoveDirectoryA (KERNEL32.@)
1660 */
1661 BOOL WINAPI RemoveDirectoryA( LPCSTR path )
1662 {
1663 WCHAR *pathW;
1664
1665 if (!(pathW = FILE_name_AtoW( path, FALSE ))) return FALSE;
1666 return RemoveDirectoryW( pathW );
1667 }
1668
1669
1670 /***********************************************************************
1671 * GetCurrentDirectoryW (KERNEL32.@)
1672 */
1673 UINT WINAPI GetCurrentDirectoryW( UINT buflen, LPWSTR buf )
1674 {
1675 return RtlGetCurrentDirectory_U( buflen * sizeof(WCHAR), buf ) / sizeof(WCHAR);
1676 }
1677
1678
1679 /***********************************************************************
1680 * GetCurrentDirectoryA (KERNEL32.@)
1681 */
1682 UINT WINAPI GetCurrentDirectoryA( UINT buflen, LPSTR buf )
1683 {
1684 WCHAR bufferW[MAX_PATH];
1685 DWORD ret;
1686
1687 if (buflen && buf && ((ULONG_PTR)buf >> 16) == 0)
1688 {
1689 /* Win9x catches access violations here, returning zero.
1690 * This behaviour resulted in some people not noticing
1691 * that they got the argument order wrong. So let's be
1692 * nice and fail gracefully if buf is invalid and looks
1693 * more like a buflen. */
1694 SetLastError(ERROR_INVALID_PARAMETER);
1695 return 0;
1696 }
1697
1698 ret = RtlGetCurrentDirectory_U( sizeof(bufferW), bufferW );
1699 if (!ret) return 0;
1700 if (ret > sizeof(bufferW))
1701 {
1702 SetLastError(ERROR_FILENAME_EXCED_RANGE);
1703 return 0;
1704 }
1705 return copy_filename_WtoA( bufferW, buf, buflen );
1706 }
1707
1708
1709 /***********************************************************************
1710 * SetCurrentDirectoryW (KERNEL32.@)
1711 */
1712 BOOL WINAPI SetCurrentDirectoryW( LPCWSTR dir )
1713 {
1714 UNICODE_STRING dirW;
1715 NTSTATUS status;
1716
1717 RtlInitUnicodeString( &dirW, dir );
1718 status = RtlSetCurrentDirectory_U( &dirW );
1719 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
1720 return !status;
1721 }
1722
1723
1724 /***********************************************************************
1725 * SetCurrentDirectoryA (KERNEL32.@)
1726 */
1727 BOOL WINAPI SetCurrentDirectoryA( LPCSTR dir )
1728 {
1729 WCHAR *dirW;
1730 UNICODE_STRING strW;
1731 NTSTATUS status;
1732
1733 if (!(dirW = FILE_name_AtoW( dir, FALSE ))) return FALSE;
1734 RtlInitUnicodeString( &strW, dirW );
1735 status = RtlSetCurrentDirectory_U( &strW );
1736 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
1737 return !status;
1738 }
1739
1740
1741 /***********************************************************************
1742 * GetWindowsDirectoryW (KERNEL32.@)
1743 *
1744 * See comment for GetWindowsDirectoryA.
1745 */
1746 UINT WINAPI GetWindowsDirectoryW( LPWSTR path, UINT count )
1747 {
1748 UINT len = strlenW( DIR_Windows ) + 1;
1749 if (path && count >= len)
1750 {
1751 strcpyW( path, DIR_Windows );
1752 len--;
1753 }
1754 return len;
1755 }
1756
1757
1758 /***********************************************************************
1759 * GetWindowsDirectoryA (KERNEL32.@)
1760 *
1761 * Return value:
1762 * If buffer is large enough to hold full path and terminating '\0' character
1763 * function copies path to buffer and returns length of the path without '\0'.
1764 * Otherwise function returns required size including '\0' character and
1765 * does not touch the buffer.
1766 */
1767 UINT WINAPI GetWindowsDirectoryA( LPSTR path, UINT count )
1768 {
1769 return copy_filename_WtoA( DIR_Windows, path, count );
1770 }
1771
1772
1773 /***********************************************************************
1774 * GetSystemWindowsDirectoryA (KERNEL32.@) W2K, TS4.0SP4
1775 */
1776 UINT WINAPI GetSystemWindowsDirectoryA( LPSTR path, UINT count )
1777 {
1778 return GetWindowsDirectoryA( path, count );
1779 }
1780
1781
1782 /***********************************************************************
1783 * GetSystemWindowsDirectoryW (KERNEL32.@) W2K, TS4.0SP4
1784 */
1785 UINT WINAPI GetSystemWindowsDirectoryW( LPWSTR path, UINT count )
1786 {
1787 return GetWindowsDirectoryW( path, count );
1788 }
1789
1790
1791 /***********************************************************************
1792 * GetSystemDirectoryW (KERNEL32.@)
1793 *
1794 * See comment for GetWindowsDirectoryA.
1795 */
1796 UINT WINAPI GetSystemDirectoryW( LPWSTR path, UINT count )
1797 {
1798 UINT len = strlenW( DIR_System ) + 1;
1799 if (path && count >= len)
1800 {
1801 strcpyW( path, DIR_System );
1802 len--;
1803 }
1804 return len;
1805 }
1806
1807
1808 /***********************************************************************
1809 * GetSystemDirectoryA (KERNEL32.@)
1810 *
1811 * See comment for GetWindowsDirectoryA.
1812 */
1813 UINT WINAPI GetSystemDirectoryA( LPSTR path, UINT count )
1814 {
1815 return copy_filename_WtoA( DIR_System, path, count );
1816 }
1817
1818
1819 /***********************************************************************
1820 * GetSystemWow64DirectoryW (KERNEL32.@)
1821 *
1822 * As seen on MSDN
1823 * - On Win32 we should return ERROR_CALL_NOT_IMPLEMENTED
1824 * - On Win64 we should return the SysWow64 (system64) directory
1825 */
1826 UINT WINAPI GetSystemWow64DirectoryW( LPWSTR path, UINT count )
1827 {
1828 UINT len;
1829
1830 if (!DIR_SysWow64)
1831 {
1832 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1833 return 0;
1834 }
1835 len = strlenW( DIR_SysWow64 ) + 1;
1836 if (path && count >= len)
1837 {
1838 strcpyW( path, DIR_SysWow64 );
1839 len--;
1840 }
1841 return len;
1842 }
1843
1844
1845 /***********************************************************************
1846 * GetSystemWow64DirectoryA (KERNEL32.@)
1847 *
1848 * See comment for GetWindowsWow64DirectoryW.
1849 */
1850 UINT WINAPI GetSystemWow64DirectoryA( LPSTR path, UINT count )
1851 {
1852 if (!DIR_SysWow64)
1853 {
1854 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1855 return 0;
1856 }
1857 return copy_filename_WtoA( DIR_SysWow64, path, count );
1858 }
1859
1860
1861 /***********************************************************************
1862 * Wow64EnableWow64FsRedirection (KERNEL32.@)
1863 */
1864 BOOLEAN WINAPI Wow64EnableWow64FsRedirection( BOOLEAN enable )
1865 {
1866 NTSTATUS status = RtlWow64EnableFsRedirection( enable );
1867 if (status) SetLastError( RtlNtStatusToDosError(status) );
1868 return !status;
1869 }
1870
1871
1872 /***********************************************************************
1873 * Wow64DisableWow64FsRedirection (KERNEL32.@)
1874 */
1875 BOOL WINAPI Wow64DisableWow64FsRedirection( PVOID *old_value )
1876 {
1877 NTSTATUS status = RtlWow64EnableFsRedirectionEx( TRUE, (ULONG *)old_value );
1878 if (status) SetLastError( RtlNtStatusToDosError(status) );
1879 return !status;
1880 }
1881
1882
1883 /***********************************************************************
1884 * Wow64RevertWow64FsRedirection (KERNEL32.@)
1885 */
1886 BOOL WINAPI Wow64RevertWow64FsRedirection( PVOID old_value )
1887 {
1888 NTSTATUS status = RtlWow64EnableFsRedirection( !old_value );
1889 if (status) SetLastError( RtlNtStatusToDosError(status) );
1890 return !status;
1891 }
1892
1893
1894 /***********************************************************************
1895 * NeedCurrentDirectoryForExePathW (KERNEL32.@)
1896 */
1897 BOOL WINAPI NeedCurrentDirectoryForExePathW( LPCWSTR name )
1898 {
1899 static const WCHAR env_name[] = {'N','o','D','e','f','a','u','l','t',
1900 'C','u','r','r','e','n','t',
1901 'D','i','r','e','c','t','o','r','y',
1902 'I','n','E','x','e','P','a','t','h',0};
1903 WCHAR env_val;
1904
1905 /* MSDN mentions some 'registry location'. We do not use registry. */
1906 FIXME("(%s): partial stub\n", debugstr_w(name));
1907
1908 if (strchrW(name, '\\'))
1909 return TRUE;
1910
1911 /* Check the existence of the variable, not value */
1912 if (!GetEnvironmentVariableW( env_name, &env_val, 1 ))
1913 return TRUE;
1914
1915 return FALSE;
1916 }
1917
1918
1919 /***********************************************************************
1920 * NeedCurrentDirectoryForExePathA (KERNEL32.@)
1921 */
1922 BOOL WINAPI NeedCurrentDirectoryForExePathA( LPCSTR name )
1923 {
1924 WCHAR *nameW;
1925
1926 if (!(nameW = FILE_name_AtoW( name, FALSE ))) return TRUE;
1927 return NeedCurrentDirectoryForExePathW( nameW );
1928 }
1929
1930
1931 /***********************************************************************
1932 * wine_get_unix_file_name (KERNEL32.@) Not a Windows API
1933 *
1934 * Return the full Unix file name for a given path.
1935 * Returned buffer must be freed by caller.
1936 */
1937 char * CDECL wine_get_unix_file_name( LPCWSTR dosW )
1938 {
1939 UNICODE_STRING nt_name;
1940 ANSI_STRING unix_name;
1941 NTSTATUS status;
1942
1943 if (!RtlDosPathNameToNtPathName_U( dosW, &nt_name, NULL, NULL )) return NULL;
1944 status = wine_nt_to_unix_file_name( &nt_name, &unix_name, FILE_OPEN_IF, FALSE );
1945 RtlFreeUnicodeString( &nt_name );
1946 if (status && status != STATUS_NO_SUCH_FILE)
1947 {
1948 SetLastError( RtlNtStatusToDosError( status ) );
1949 return NULL;
1950 }
1951 return unix_name.Buffer;
1952 }
1953
1954
1955 /***********************************************************************
1956 * wine_get_dos_file_name (KERNEL32.@) Not a Windows API
1957 *
1958 * Return the full DOS file name for a given Unix path.
1959 * Returned buffer must be freed by caller.
1960 */
1961 WCHAR * CDECL wine_get_dos_file_name( LPCSTR str )
1962 {
1963 UNICODE_STRING nt_name;
1964 ANSI_STRING unix_name;
1965 NTSTATUS status;
1966 DWORD len;
1967
1968 RtlInitAnsiString( &unix_name, str );
1969 status = wine_unix_to_nt_file_name( &unix_name, &nt_name );
1970 if (status)
1971 {
1972 SetLastError( RtlNtStatusToDosError( status ) );
1973 return NULL;
1974 }
1975 if (nt_name.Buffer[5] == ':')
1976 {
1977 /* get rid of the \??\ prefix */
1978 /* FIXME: should implement RtlNtPathNameToDosPathName and use that instead */
1979 len = nt_name.Length - 4 * sizeof(WCHAR);
1980 memmove( nt_name.Buffer, nt_name.Buffer + 4, len );
1981 nt_name.Buffer[len / sizeof(WCHAR)] = 0;
1982 }
1983 else
1984 nt_name.Buffer[1] = '\\';
1985 return nt_name.Buffer;
1986 }
1987
1988 /*************************************************************************
1989 * CreateSymbolicLinkW (KERNEL32.@)
1990 */
1991 BOOLEAN WINAPI CreateSymbolicLinkW(LPCWSTR link, LPCWSTR target, DWORD flags)
1992 {
1993 FIXME("(%s %s %d): stub\n", debugstr_w(link), debugstr_w(target), flags);
1994 return TRUE;
1995 }
1996
1997 /*************************************************************************
1998 * CreateSymbolicLinkA (KERNEL32.@)
1999 */
2000 BOOLEAN WINAPI CreateSymbolicLinkA(LPCSTR link, LPCSTR target, DWORD flags)
2001 {
2002 FIXME("(%s %s %d): stub\n", debugstr_a(link), debugstr_a(target), flags);
2003 return TRUE;
2004 }
2005
2006 /*************************************************************************
2007 * CreateHardLinkTransactedA (KERNEL32.@)
2008 */
2009 BOOL WINAPI CreateHardLinkTransactedA(LPCSTR link, LPCSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
2010 {
2011 FIXME("(%s %s %p %p): stub\n", debugstr_a(link), debugstr_a(target), sa, transaction);
2012 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2013 return FALSE;
2014 }
2015
2016 /*************************************************************************
2017 * CreateHardLinkTransactedW (KERNEL32.@)
2018 */
2019 BOOL WINAPI CreateHardLinkTransactedW(LPCWSTR link, LPCWSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
2020 {
2021 FIXME("(%s %s %p %p): stub\n", debugstr_w(link), debugstr_w(target), sa, transaction);
2022 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2023 return FALSE;
2024 }
2025
2026 /*************************************************************************
2027 * CheckNameLegalDOS8Dot3A (KERNEL32.@)
2028 */
2029 BOOL WINAPI CheckNameLegalDOS8Dot3A(const char *name, char *oemname, DWORD oemname_len,
2030 BOOL *contains_spaces, BOOL *is_legal)
2031 {
2032 WCHAR *nameW;
2033
2034 TRACE("(%s %p %u %p %p)\n", name, oemname,
2035 oemname_len, contains_spaces, is_legal);
2036
2037 if (!name || !is_legal)
2038 return FALSE;
2039
2040 if (!(nameW = FILE_name_AtoW( name, FALSE ))) return FALSE;
2041
2042 return CheckNameLegalDOS8Dot3W( nameW, oemname, oemname_len, contains_spaces, is_legal );
2043 }
2044
2045 /*************************************************************************
2046 * CheckNameLegalDOS8Dot3W (KERNEL32.@)
2047 */
2048 BOOL WINAPI CheckNameLegalDOS8Dot3W(const WCHAR *name, char *oemname, DWORD oemname_len,
2049 BOOL *contains_spaces_ret, BOOL *is_legal)
2050 {
2051 OEM_STRING oem_str;
2052 UNICODE_STRING nameW;
2053 BOOLEAN contains_spaces;
2054
2055 TRACE("(%s %p %u %p %p)\n", wine_dbgstr_w(name), oemname,
2056 oemname_len, contains_spaces_ret, is_legal);
2057
2058 if (!name || !is_legal)
2059 return FALSE;
2060
2061 RtlInitUnicodeString( &nameW, name );
2062
2063 if (oemname) {
2064 oem_str.Length = oemname_len;
2065 oem_str.MaximumLength = oemname_len;
2066 oem_str.Buffer = oemname;
2067 }
2068
2069 *is_legal = RtlIsNameLegalDOS8Dot3( &nameW, oemname ? &oem_str : NULL, &contains_spaces );
2070 if (contains_spaces_ret) *contains_spaces_ret = contains_spaces;
2071
2072 return TRUE;
2073 }
2074
2075 /*************************************************************************
2076 * SetSearchPathMode (KERNEL32.@)
2077 */
2078 BOOL WINAPI SetSearchPathMode(DWORD flags)
2079 {
2080 FIXME("(%x): stub\n", flags);
2081 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
2082 return FALSE;
2083 }
Windows API implementation