dwrite: Stub for CreateMonitorRenderingParams().
[wine] / dlls / ntdll / om.c
1 /*
2  *      Object management functions
3  *
4  * Copyright 1999, 2000 Juergen Schmied
5  * Copyright 2005 Vitaliy Margolen
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
22 #include "config.h"
23
24 #include <stdarg.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #ifdef HAVE_IO_H
28 # include <io.h>
29 #endif
30 #ifdef HAVE_UNISTD_H
31 # include <unistd.h>
32 #endif
33
34 #include "ntstatus.h"
35 #define WIN32_NO_STATUS
36 #include "wine/debug.h"
37 #include "windef.h"
38 #include "winternl.h"
39 #include "ntdll_misc.h"
40 #include "wine/server.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
43
44
45 /*
46  *      Generic object functions
47  */
48
49 /******************************************************************************
50  * NtQueryObject [NTDLL.@]
51  * ZwQueryObject [NTDLL.@]
52  */
53 NTSTATUS WINAPI NtQueryObject(IN HANDLE handle,
54                               IN OBJECT_INFORMATION_CLASS info_class,
55                               OUT PVOID ptr, IN ULONG len, OUT PULONG used_len)
56 {
57     NTSTATUS status;
58
59     TRACE("(%p,0x%08x,%p,0x%08x,%p): stub\n",
60           handle, info_class, ptr, len, used_len);
61
62     if (used_len) *used_len = 0;
63
64     switch (info_class)
65     {
66     case ObjectBasicInformation:
67         {
68             POBJECT_BASIC_INFORMATION p = ptr;
69
70             if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
71
72             SERVER_START_REQ( get_object_info )
73             {
74                 req->handle = wine_server_obj_handle( handle );
75                 status = wine_server_call( req );
76                 if (status == STATUS_SUCCESS)
77                 {
78                     memset( p, 0, sizeof(*p) );
79                     p->GrantedAccess = reply->access;
80                     p->PointerCount = reply->ref_count;
81                     p->HandleCount = 1; /* at least one */
82                     if (used_len) *used_len = sizeof(*p);
83                 }
84             }
85             SERVER_END_REQ;
86         }
87         break;
88     case ObjectNameInformation:
89         {
90             OBJECT_NAME_INFORMATION* p = ptr;
91             ANSI_STRING unix_name;
92
93             /* first try as a file object */
94
95             if (!(status = server_get_unix_name( handle, &unix_name )))
96             {
97                 UNICODE_STRING nt_name;
98
99                 if (!(status = wine_unix_to_nt_file_name( &unix_name, &nt_name )))
100                 {
101                     if (len < sizeof(*p))
102                         status = STATUS_INFO_LENGTH_MISMATCH;
103                     else if (len < sizeof(*p) + nt_name.MaximumLength)
104                         status = STATUS_BUFFER_OVERFLOW;
105                     else
106                     {
107                         p->Name.Buffer = (WCHAR *)(p + 1);
108                         p->Name.Length = nt_name.Length;
109                         p->Name.MaximumLength = nt_name.MaximumLength;
110                         memcpy( p->Name.Buffer, nt_name.Buffer, nt_name.MaximumLength );
111                     }
112                     if (used_len) *used_len = sizeof(*p) + nt_name.MaximumLength;
113                     RtlFreeUnicodeString( &nt_name );
114                 }
115                 RtlFreeAnsiString( &unix_name );
116                 break;
117             }
118             else if (status != STATUS_OBJECT_TYPE_MISMATCH) break;
119
120             /* not a file, treat as a generic object */
121
122             SERVER_START_REQ( get_object_info )
123             {
124                 req->handle = wine_server_obj_handle( handle );
125                 if (len > sizeof(*p)) wine_server_set_reply( req, p + 1, len - sizeof(*p) );
126                 status = wine_server_call( req );
127                 if (status == STATUS_SUCCESS)
128                 {
129                     if (!reply->total)  /* no name */
130                     {
131                         if (sizeof(*p) > len) status = STATUS_INFO_LENGTH_MISMATCH;
132                         else memset( p, 0, sizeof(*p) );
133                         if (used_len) *used_len = sizeof(*p);
134                     }
135                     else if (sizeof(*p) + reply->total + sizeof(WCHAR) > len)
136                     {
137                         if (used_len) *used_len = sizeof(*p) + reply->total + sizeof(WCHAR);
138                         status = STATUS_INFO_LENGTH_MISMATCH;
139                     }
140                     else
141                     {
142                         ULONG res = wine_server_reply_size( reply );
143                         p->Name.Buffer = (WCHAR *)(p + 1);
144                         p->Name.Length = res;
145                         p->Name.MaximumLength = res + sizeof(WCHAR);
146                         p->Name.Buffer[res / sizeof(WCHAR)] = 0;
147                         if (used_len) *used_len = sizeof(*p) + p->Name.MaximumLength;
148                     }
149                 }
150             }
151             SERVER_END_REQ;
152         }
153         break;
154     case ObjectDataInformation:
155         {
156             OBJECT_DATA_INFORMATION* p = ptr;
157
158             if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
159
160             SERVER_START_REQ( set_handle_info )
161             {
162                 req->handle = wine_server_obj_handle( handle );
163                 req->flags  = 0;
164                 req->mask   = 0;
165                 status = wine_server_call( req );
166                 if (status == STATUS_SUCCESS)
167                 {
168                     p->InheritHandle = (reply->old_flags & HANDLE_FLAG_INHERIT) ? TRUE : FALSE;
169                     p->ProtectFromClose = (reply->old_flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) ? TRUE : FALSE;
170                     if (used_len) *used_len = sizeof(*p);
171                 }
172             }
173             SERVER_END_REQ;
174         }
175         break;
176     default:
177         FIXME("Unsupported information class %u\n", info_class);
178         status = STATUS_NOT_IMPLEMENTED;
179         break;
180     }
181     return status;
182 }
183
184 /******************************************************************
185  *              NtSetInformationObject [NTDLL.@]
186  *              ZwSetInformationObject [NTDLL.@]
187  *
188  */
189 NTSTATUS WINAPI NtSetInformationObject(IN HANDLE handle,
190                                        IN OBJECT_INFORMATION_CLASS info_class,
191                                        IN PVOID ptr, IN ULONG len)
192 {
193     NTSTATUS status;
194
195     TRACE("(%p,0x%08x,%p,0x%08x): stub\n",
196           handle, info_class, ptr, len);
197
198     switch (info_class)
199     {
200     case ObjectDataInformation:
201         {
202             OBJECT_DATA_INFORMATION* p = ptr;
203
204             if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
205
206             SERVER_START_REQ( set_handle_info )
207             {
208                 req->handle = wine_server_obj_handle( handle );
209                 req->flags  = 0;
210                 req->mask   = HANDLE_FLAG_INHERIT | HANDLE_FLAG_PROTECT_FROM_CLOSE;
211                 if (p->InheritHandle)    req->flags |= HANDLE_FLAG_INHERIT;
212                 if (p->ProtectFromClose) req->flags |= HANDLE_FLAG_PROTECT_FROM_CLOSE;
213                 status = wine_server_call( req );
214             }
215             SERVER_END_REQ;
216         }
217         break;
218     default:
219         FIXME("Unsupported information class %u\n", info_class);
220         status = STATUS_NOT_IMPLEMENTED;
221         break;
222     }
223     return status;
224 }
225
226 /******************************************************************************
227  *  NtQuerySecurityObject       [NTDLL.@]
228  *
229  * An ntdll analogue to GetKernelObjectSecurity().
230  *
231  */
232 NTSTATUS WINAPI
233 NtQuerySecurityObject(
234         IN HANDLE Object,
235         IN SECURITY_INFORMATION RequestedInformation,
236         OUT PSECURITY_DESCRIPTOR pSecurityDescriptor,
237         IN ULONG Length,
238         OUT PULONG ResultLength)
239 {
240     PISECURITY_DESCRIPTOR_RELATIVE psd = pSecurityDescriptor;
241     NTSTATUS status;
242     unsigned int buffer_size = 512;
243     BOOLEAN need_more_memory;
244
245     TRACE("(%p,0x%08x,%p,0x%08x,%p)\n",
246         Object, RequestedInformation, pSecurityDescriptor, Length, ResultLength);
247
248     do
249     {
250         char *buffer = RtlAllocateHeap(GetProcessHeap(), 0, buffer_size);
251         if (!buffer)
252             return STATUS_NO_MEMORY;
253
254         need_more_memory = FALSE;
255
256         SERVER_START_REQ( get_security_object )
257         {
258             req->handle = wine_server_obj_handle( Object );
259             req->security_info = RequestedInformation;
260             wine_server_set_reply( req, buffer, buffer_size );
261             status = wine_server_call( req );
262             if (status == STATUS_SUCCESS)
263             {
264                 struct security_descriptor *sd = (struct security_descriptor *)buffer;
265                 if (reply->sd_len)
266                 {
267                     *ResultLength = sizeof(SECURITY_DESCRIPTOR_RELATIVE) +
268                         sd->owner_len + sd->group_len + sd->sacl_len + sd->dacl_len;
269                     if (Length >= *ResultLength)
270                     {
271                         psd->Revision = SECURITY_DESCRIPTOR_REVISION;
272                         psd->Sbz1 = 0;
273                         psd->Control = sd->control | SE_SELF_RELATIVE;
274                         psd->Owner = sd->owner_len ? sizeof(SECURITY_DESCRIPTOR_RELATIVE) : 0;
275                         psd->Group = sd->group_len ? sizeof(SECURITY_DESCRIPTOR_RELATIVE) + sd->owner_len : 0;
276                         psd->Sacl = sd->sacl_len ? sizeof(SECURITY_DESCRIPTOR_RELATIVE) + sd->owner_len + sd->group_len : 0;
277                         psd->Dacl = sd->dacl_len ? sizeof(SECURITY_DESCRIPTOR_RELATIVE) + sd->owner_len + sd->group_len + sd->sacl_len : 0;
278                         /* owner, group, sacl and dacl are the same type as in the server
279                          * and in the same order so we copy the memory in one block */
280                         memcpy((char *)pSecurityDescriptor + sizeof(SECURITY_DESCRIPTOR_RELATIVE),
281                                buffer + sizeof(struct security_descriptor),
282                                sd->owner_len + sd->group_len + sd->sacl_len + sd->dacl_len);
283                     }
284                     else
285                         status = STATUS_BUFFER_TOO_SMALL;
286                 }
287                 else
288                 {
289                     *ResultLength = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
290                     if (Length >= *ResultLength)
291                     {
292                         memset(psd, 0, sizeof(*psd));
293                         psd->Revision = SECURITY_DESCRIPTOR_REVISION;
294                         psd->Control = SE_SELF_RELATIVE;
295                     }
296                     else
297                         status = STATUS_BUFFER_TOO_SMALL;
298                 }
299             }
300             else if (status == STATUS_BUFFER_TOO_SMALL)
301             {
302                 buffer_size = reply->sd_len;
303                 need_more_memory = TRUE;
304             }
305         }
306         SERVER_END_REQ;
307         RtlFreeHeap(GetProcessHeap(), 0, buffer);
308     } while (need_more_memory);
309
310     return status;
311 }
312
313
314 /******************************************************************************
315  *  NtDuplicateObject           [NTDLL.@]
316  *  ZwDuplicateObject           [NTDLL.@]
317  */
318 NTSTATUS WINAPI NtDuplicateObject( HANDLE source_process, HANDLE source,
319                                    HANDLE dest_process, PHANDLE dest,
320                                    ACCESS_MASK access, ULONG attributes, ULONG options )
321 {
322     NTSTATUS ret;
323     SERVER_START_REQ( dup_handle )
324     {
325         req->src_process = wine_server_obj_handle( source_process );
326         req->src_handle  = wine_server_obj_handle( source );
327         req->dst_process = wine_server_obj_handle( dest_process );
328         req->access      = access;
329         req->attributes  = attributes;
330         req->options     = options;
331
332         if (!(ret = wine_server_call( req )))
333         {
334             if (dest) *dest = wine_server_ptr_handle( reply->handle );
335             if (reply->closed)
336             {
337                 if (reply->self)
338                 {
339                     int fd = server_remove_fd_from_cache( source );
340                     if (fd != -1) close( fd );
341                 }
342             }
343             else if (options & DUPLICATE_CLOSE_SOURCE)
344                 WARN( "failed to close handle %p in process %p\n", source, source_process );
345         }
346     }
347     SERVER_END_REQ;
348     return ret;
349 }
350
351 /* Everquest 2 / Pirates of the Burning Sea hooks NtClose, so we need a wrapper */
352 NTSTATUS close_handle( HANDLE handle )
353 {
354     NTSTATUS ret;
355     int fd = server_remove_fd_from_cache( handle );
356
357     SERVER_START_REQ( close_handle )
358     {
359         req->handle = wine_server_obj_handle( handle );
360         ret = wine_server_call( req );
361     }
362     SERVER_END_REQ;
363     if (fd != -1) close( fd );
364     return ret;
365 }
366
367 /**************************************************************************
368  *                 NtClose                              [NTDLL.@]
369  *
370  * Close a handle reference to an object.
371  * 
372  * PARAMS
373  *  Handle [I] handle to close
374  *
375  * RETURNS
376  *  Success: ERROR_SUCCESS.
377  *  Failure: An NTSTATUS error code.
378  */
379 NTSTATUS WINAPI NtClose( HANDLE Handle )
380 {
381     return close_handle( Handle );
382 }
383
384 /*
385  *      Directory functions
386  */
387
388 /**************************************************************************
389  * NtOpenDirectoryObject [NTDLL.@]
390  * ZwOpenDirectoryObject [NTDLL.@]
391  *
392  * Open a namespace directory object.
393  * 
394  * PARAMS
395  *  DirectoryHandle  [O] Destination for the new directory handle
396  *  DesiredAccess    [I] Desired access to the directory
397  *  ObjectAttributes [I] Structure describing the directory
398  *
399  * RETURNS
400  *  Success: ERROR_SUCCESS.
401  *  Failure: An NTSTATUS error code.
402  */
403 NTSTATUS WINAPI NtOpenDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess,
404                                       POBJECT_ATTRIBUTES ObjectAttributes)
405 {
406     NTSTATUS ret;
407
408     if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
409     if (!ObjectAttributes) return STATUS_INVALID_PARAMETER;
410     TRACE("(%p,0x%08x,%s)\n", DirectoryHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
411     /* Have to test it here because server won't know difference between
412      * ObjectName == NULL and ObjectName == "" */
413     if (!ObjectAttributes->ObjectName)
414     {
415         if (ObjectAttributes->RootDirectory)
416             return STATUS_OBJECT_NAME_INVALID;
417         else
418             return STATUS_OBJECT_PATH_SYNTAX_BAD;
419     }
420
421     SERVER_START_REQ(open_directory)
422     {
423         req->access = DesiredAccess;
424         req->attributes = ObjectAttributes->Attributes;
425         req->rootdir = wine_server_obj_handle( ObjectAttributes->RootDirectory );
426         if (ObjectAttributes->ObjectName)
427             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
428                                  ObjectAttributes->ObjectName->Length);
429         ret = wine_server_call( req );
430         *DirectoryHandle = wine_server_ptr_handle( reply->handle );
431     }
432     SERVER_END_REQ;
433     return ret;
434 }
435
436 /******************************************************************************
437  *  NtCreateDirectoryObject     [NTDLL.@]
438  *  ZwCreateDirectoryObject     [NTDLL.@]
439  *
440  * Create a namespace directory object.
441  * 
442  * PARAMS
443  *  DirectoryHandle  [O] Destination for the new directory handle
444  *  DesiredAccess    [I] Desired access to the directory
445  *  ObjectAttributes [I] Structure describing the directory
446  *
447  * RETURNS
448  *  Success: ERROR_SUCCESS.
449  *  Failure: An NTSTATUS error code.
450  */
451 NTSTATUS WINAPI NtCreateDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess,
452                                         POBJECT_ATTRIBUTES ObjectAttributes)
453 {
454     NTSTATUS ret;
455
456     if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
457     TRACE("(%p,0x%08x,%s)\n", DirectoryHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
458
459     SERVER_START_REQ(create_directory)
460     {
461         req->access = DesiredAccess;
462         req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
463         req->rootdir = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
464         if (ObjectAttributes && ObjectAttributes->ObjectName)
465             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
466                                  ObjectAttributes->ObjectName->Length);
467         ret = wine_server_call( req );
468         *DirectoryHandle = wine_server_ptr_handle( reply->handle );
469     }
470     SERVER_END_REQ;
471     return ret;
472 }
473
474 /******************************************************************************
475  * NtQueryDirectoryObject [NTDLL.@]
476  * ZwQueryDirectoryObject [NTDLL.@]
477  *
478  * Read information from a namespace directory.
479  * 
480  * PARAMS
481  *  handle        [I]   Handle to a directory object
482  *  buffer        [O]   Buffer to hold the read data
483  *  size          [I]   Size of the buffer in bytes
484  *  single_entry  [I]   If TRUE, return a single entry, if FALSE, return as many as fit in the buffer
485  *  restart       [I]   If TRUE, start scanning from the start, if FALSE, scan from Context
486  *  context       [I/O] Indicates what point of the directory the scan is at
487  *  ret_size      [O]   Caller supplied storage for the number of bytes written (or NULL)
488  *
489  * RETURNS
490  *  Success: ERROR_SUCCESS.
491  *  Failure: An NTSTATUS error code.
492  */
493 NTSTATUS WINAPI NtQueryDirectoryObject(HANDLE handle, PDIRECTORY_BASIC_INFORMATION buffer,
494                                        ULONG size, BOOLEAN single_entry, BOOLEAN restart,
495                                        PULONG context, PULONG ret_size)
496 {
497     NTSTATUS ret;
498
499     if (restart) *context = 0;
500
501     if (single_entry)
502     {
503         if (size <= sizeof(*buffer) + 2*sizeof(WCHAR)) return STATUS_BUFFER_OVERFLOW;
504
505         SERVER_START_REQ( get_directory_entry )
506         {
507             req->handle = wine_server_obj_handle( handle );
508             req->index = *context;
509             wine_server_set_reply( req, buffer + 1, size - sizeof(*buffer) - 2*sizeof(WCHAR) );
510             if (!(ret = wine_server_call( req )))
511             {
512                 buffer->ObjectName.Buffer = (WCHAR *)(buffer + 1);
513                 buffer->ObjectName.Length = reply->name_len;
514                 buffer->ObjectName.MaximumLength = reply->name_len + sizeof(WCHAR);
515                 buffer->ObjectTypeName.Buffer = (WCHAR *)(buffer + 1) + reply->name_len/sizeof(WCHAR) + 1;
516                 buffer->ObjectTypeName.Length = wine_server_reply_size( reply ) - reply->name_len;
517                 buffer->ObjectTypeName.MaximumLength = buffer->ObjectTypeName.Length + sizeof(WCHAR);
518                 /* make room for the terminating null */
519                 memmove( buffer->ObjectTypeName.Buffer, buffer->ObjectTypeName.Buffer - 1,
520                          buffer->ObjectTypeName.Length );
521                 buffer->ObjectName.Buffer[buffer->ObjectName.Length/sizeof(WCHAR)] = 0;
522                 buffer->ObjectTypeName.Buffer[buffer->ObjectTypeName.Length/sizeof(WCHAR)] = 0;
523                 (*context)++;
524             }
525         }
526         SERVER_END_REQ;
527         if (ret_size)
528             *ret_size = buffer->ObjectName.MaximumLength + buffer->ObjectTypeName.MaximumLength + sizeof(*buffer);
529     }
530     else
531     {
532         FIXME("multiple entries not implemented\n");
533         ret = STATUS_NOT_IMPLEMENTED;
534     }
535
536     return ret;
537 }
538
539 /*
540  *      Link objects
541  */
542
543 /******************************************************************************
544  *  NtOpenSymbolicLinkObject    [NTDLL.@]
545  *  ZwOpenSymbolicLinkObject    [NTDLL.@]
546  *
547  * Open a namespace symbolic link object.
548  * 
549  * PARAMS
550  *  LinkHandle       [O] Destination for the new symbolic link handle
551  *  DesiredAccess    [I] Desired access to the symbolic link
552  *  ObjectAttributes [I] Structure describing the symbolic link
553  *
554  * RETURNS
555  *  Success: ERROR_SUCCESS.
556  *  Failure: An NTSTATUS error code.
557  */
558 NTSTATUS WINAPI NtOpenSymbolicLinkObject(OUT PHANDLE LinkHandle, IN ACCESS_MASK DesiredAccess,
559                                          IN POBJECT_ATTRIBUTES ObjectAttributes)
560 {
561     NTSTATUS ret;
562     TRACE("(%p,0x%08x,%s)\n",LinkHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
563
564     if (!LinkHandle) return STATUS_ACCESS_VIOLATION;
565     if (!ObjectAttributes) return STATUS_INVALID_PARAMETER;
566     /* Have to test it here because server won't know difference between
567      * ObjectName == NULL and ObjectName == "" */
568     if (!ObjectAttributes->ObjectName)
569     {
570         if (ObjectAttributes->RootDirectory)
571             return STATUS_OBJECT_NAME_INVALID;
572         else
573             return STATUS_OBJECT_PATH_SYNTAX_BAD;
574     }
575
576     SERVER_START_REQ(open_symlink)
577     {
578         req->access = DesiredAccess;
579         req->attributes = ObjectAttributes->Attributes;
580         req->rootdir = wine_server_obj_handle( ObjectAttributes->RootDirectory );
581         if (ObjectAttributes->ObjectName)
582             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
583                                  ObjectAttributes->ObjectName->Length);
584         ret = wine_server_call( req );
585         *LinkHandle = wine_server_ptr_handle( reply->handle );
586     }
587     SERVER_END_REQ;
588     return ret;
589 }
590
591 /******************************************************************************
592  *  NtCreateSymbolicLinkObject  [NTDLL.@]
593  *  ZwCreateSymbolicLinkObject  [NTDLL.@]
594  *
595  * Open a namespace symbolic link object.
596  * 
597  * PARAMS
598  *  SymbolicLinkHandle [O] Destination for the new symbolic link handle
599  *  DesiredAccess      [I] Desired access to the symbolic link
600  *  ObjectAttributes   [I] Structure describing the symbolic link
601  *  TargetName         [I] Name of the target symbolic link points to
602  *
603  * RETURNS
604  *  Success: ERROR_SUCCESS.
605  *  Failure: An NTSTATUS error code.
606  */
607 NTSTATUS WINAPI NtCreateSymbolicLinkObject(OUT PHANDLE SymbolicLinkHandle,IN ACCESS_MASK DesiredAccess,
608                                            IN POBJECT_ATTRIBUTES ObjectAttributes,
609                                            IN PUNICODE_STRING TargetName)
610 {
611     NTSTATUS ret;
612
613     if (!SymbolicLinkHandle || !TargetName) return STATUS_ACCESS_VIOLATION;
614     if (!TargetName->Buffer) return STATUS_INVALID_PARAMETER;
615
616     TRACE("(%p,0x%08x,%s -> %s)\n", SymbolicLinkHandle, DesiredAccess,
617           debugstr_ObjectAttributes(ObjectAttributes), debugstr_us(TargetName));
618
619     SERVER_START_REQ(create_symlink)
620     {
621         req->access = DesiredAccess;
622         req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
623         req->rootdir = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
624         if (ObjectAttributes && ObjectAttributes->ObjectName)
625         {
626             req->name_len = ObjectAttributes->ObjectName->Length;
627             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
628                                  ObjectAttributes->ObjectName->Length);
629         }
630         else
631             req->name_len = 0;
632         wine_server_add_data(req, TargetName->Buffer, TargetName->Length);
633         ret = wine_server_call( req );
634         *SymbolicLinkHandle = wine_server_ptr_handle( reply->handle );
635     }
636     SERVER_END_REQ;
637     return ret;
638 }
639
640 /******************************************************************************
641  *  NtQuerySymbolicLinkObject   [NTDLL.@]
642  *  ZwQuerySymbolicLinkObject   [NTDLL.@]
643  *
644  * Query a namespace symbolic link object target name.
645  *
646  * PARAMS
647  *  handle     [I] Handle to a symbolic link object
648  *  target     [O] Destination for the symbolic link target
649  *  length     [O] Size of returned data
650  *
651  * RETURNS
652  *  Success: ERROR_SUCCESS.
653  *  Failure: An NTSTATUS error code.
654  */
655 NTSTATUS WINAPI NtQuerySymbolicLinkObject( HANDLE handle, PUNICODE_STRING target, PULONG length )
656 {
657     NTSTATUS ret;
658
659     TRACE("(%p,%p,%p)\n", handle, target, length );
660
661     if (!target) return STATUS_ACCESS_VIOLATION;
662
663     SERVER_START_REQ(query_symlink)
664     {
665         req->handle = wine_server_obj_handle( handle );
666         if (target->MaximumLength >= sizeof(WCHAR))
667             wine_server_set_reply( req, target->Buffer, target->MaximumLength - sizeof(WCHAR) );
668         if (!(ret = wine_server_call( req )))
669         {
670             target->Length = wine_server_reply_size(reply);
671             target->Buffer[target->Length / sizeof(WCHAR)] = 0;
672             if (length) *length = reply->total + sizeof(WCHAR);
673         }
674         else if (length && ret == STATUS_BUFFER_TOO_SMALL) *length = reply->total + sizeof(WCHAR);
675     }
676     SERVER_END_REQ;
677     return ret;
678 }
679
680 /******************************************************************************
681  *  NtAllocateUuids   [NTDLL.@]
682  */
683 NTSTATUS WINAPI NtAllocateUuids(
684         PULARGE_INTEGER Time,
685         PULONG Range,
686         PULONG Sequence)
687 {
688         FIXME("(%p,%p,%p), stub.\n", Time, Range, Sequence);
689         return 0;
690 }
691
692 /**************************************************************************
693  *  NtMakeTemporaryObject       [NTDLL.@]
694  *  ZwMakeTemporaryObject       [NTDLL.@]
695  *
696  * Make a permanent object temporary.
697  *
698  * PARAMS
699  *  Handle [I] handle to permanent object
700  *
701  * RETURNS
702  *  Success: STATUS_SUCCESS.
703  *  Failure: An NTSTATUS error code.
704  */
705 NTSTATUS WINAPI NtMakeTemporaryObject( HANDLE Handle )
706 {
707     FIXME("(%p), stub.\n", Handle);
708     return STATUS_SUCCESS;
709 }