winemac: Add the ability to disable high-resolution scrolling.
[wine/multimedia.git] / dlls / ntdll / om.c
blob47a2614dd127ee46a6b5817120a07637c9340bd2
1 /*
2 * Object management functions
4 * Copyright 1999, 2000 Juergen Schmied
5 * Copyright 2005 Vitaliy Margolen
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.
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.
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
22 #include "config.h"
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
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"
42 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
46 * Generic object functions
49 /******************************************************************************
50 * NtQueryObject [NTDLL.@]
51 * ZwQueryObject [NTDLL.@]
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)
57 NTSTATUS status;
59 TRACE("(%p,0x%08x,%p,0x%08x,%p): stub\n",
60 handle, info_class, ptr, len, used_len);
62 if (used_len) *used_len = 0;
64 switch (info_class)
66 case ObjectBasicInformation:
68 POBJECT_BASIC_INFORMATION p = ptr;
70 if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
72 SERVER_START_REQ( get_object_info )
74 req->handle = wine_server_obj_handle( handle );
75 status = wine_server_call( req );
76 if (status == STATUS_SUCCESS)
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);
85 SERVER_END_REQ;
87 break;
88 case ObjectNameInformation:
90 OBJECT_NAME_INFORMATION* p = ptr;
91 ANSI_STRING unix_name;
93 /* first try as a file object */
95 if (!(status = server_get_unix_name( handle, &unix_name )))
97 UNICODE_STRING nt_name;
99 if (!(status = wine_unix_to_nt_file_name( &unix_name, &nt_name )))
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
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 );
112 if (used_len) *used_len = sizeof(*p) + nt_name.MaximumLength;
113 RtlFreeUnicodeString( &nt_name );
115 RtlFreeAnsiString( &unix_name );
116 break;
118 else if (status != STATUS_OBJECT_TYPE_MISMATCH) break;
120 /* not a file, treat as a generic object */
122 SERVER_START_REQ( get_object_info )
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)
129 if (!reply->total) /* no name */
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);
135 else if (sizeof(*p) + reply->total + sizeof(WCHAR) > len)
137 if (used_len) *used_len = sizeof(*p) + reply->total + sizeof(WCHAR);
138 status = STATUS_INFO_LENGTH_MISMATCH;
140 else
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;
151 SERVER_END_REQ;
153 break;
154 case ObjectDataInformation:
156 OBJECT_DATA_INFORMATION* p = ptr;
158 if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
160 SERVER_START_REQ( set_handle_info )
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)
168 p->InheritHandle = (reply->old_flags & HANDLE_FLAG_INHERIT) != 0;
169 p->ProtectFromClose = (reply->old_flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) != 0;
170 if (used_len) *used_len = sizeof(*p);
173 SERVER_END_REQ;
175 break;
176 default:
177 FIXME("Unsupported information class %u\n", info_class);
178 status = STATUS_NOT_IMPLEMENTED;
179 break;
181 return status;
184 /******************************************************************
185 * NtSetInformationObject [NTDLL.@]
186 * ZwSetInformationObject [NTDLL.@]
189 NTSTATUS WINAPI NtSetInformationObject(IN HANDLE handle,
190 IN OBJECT_INFORMATION_CLASS info_class,
191 IN PVOID ptr, IN ULONG len)
193 NTSTATUS status;
195 TRACE("(%p,0x%08x,%p,0x%08x): stub\n",
196 handle, info_class, ptr, len);
198 switch (info_class)
200 case ObjectDataInformation:
202 OBJECT_DATA_INFORMATION* p = ptr;
204 if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
206 SERVER_START_REQ( set_handle_info )
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 );
215 SERVER_END_REQ;
217 break;
218 default:
219 FIXME("Unsupported information class %u\n", info_class);
220 status = STATUS_NOT_IMPLEMENTED;
221 break;
223 return status;
226 /******************************************************************************
227 * NtQuerySecurityObject [NTDLL.@]
229 * An ntdll analogue to GetKernelObjectSecurity().
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)
240 PISECURITY_DESCRIPTOR_RELATIVE psd = pSecurityDescriptor;
241 NTSTATUS status;
242 unsigned int buffer_size = 512;
243 BOOLEAN need_more_memory;
245 TRACE("(%p,0x%08x,%p,0x%08x,%p)\n",
246 Object, RequestedInformation, pSecurityDescriptor, Length, ResultLength);
250 char *buffer = RtlAllocateHeap(GetProcessHeap(), 0, buffer_size);
251 if (!buffer)
252 return STATUS_NO_MEMORY;
254 need_more_memory = FALSE;
256 SERVER_START_REQ( get_security_object )
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)
264 struct security_descriptor *sd = (struct security_descriptor *)buffer;
265 if (reply->sd_len)
267 *ResultLength = sizeof(SECURITY_DESCRIPTOR_RELATIVE) +
268 sd->owner_len + sd->group_len + sd->sacl_len + sd->dacl_len;
269 if (Length >= *ResultLength)
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);
284 else
285 status = STATUS_BUFFER_TOO_SMALL;
287 else
289 *ResultLength = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
290 if (Length >= *ResultLength)
292 memset(psd, 0, sizeof(*psd));
293 psd->Revision = SECURITY_DESCRIPTOR_REVISION;
294 psd->Control = SE_SELF_RELATIVE;
296 else
297 status = STATUS_BUFFER_TOO_SMALL;
300 else if (status == STATUS_BUFFER_TOO_SMALL)
302 buffer_size = reply->sd_len;
303 need_more_memory = TRUE;
306 SERVER_END_REQ;
307 RtlFreeHeap(GetProcessHeap(), 0, buffer);
308 } while (need_more_memory);
310 return status;
314 /******************************************************************************
315 * NtDuplicateObject [NTDLL.@]
316 * ZwDuplicateObject [NTDLL.@]
318 NTSTATUS WINAPI NtDuplicateObject( HANDLE source_process, HANDLE source,
319 HANDLE dest_process, PHANDLE dest,
320 ACCESS_MASK access, ULONG attributes, ULONG options )
322 NTSTATUS ret;
323 SERVER_START_REQ( dup_handle )
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;
332 if (!(ret = wine_server_call( req )))
334 if (dest) *dest = wine_server_ptr_handle( reply->handle );
335 if (reply->closed && reply->self)
337 int fd = server_remove_fd_from_cache( source );
338 if (fd != -1) close( fd );
342 SERVER_END_REQ;
343 return ret;
346 /* Everquest 2 / Pirates of the Burning Sea hooks NtClose, so we need a wrapper */
347 NTSTATUS close_handle( HANDLE handle )
349 NTSTATUS ret;
350 int fd = server_remove_fd_from_cache( handle );
352 SERVER_START_REQ( close_handle )
354 req->handle = wine_server_obj_handle( handle );
355 ret = wine_server_call( req );
357 SERVER_END_REQ;
358 if (fd != -1) close( fd );
359 return ret;
362 /**************************************************************************
363 * NtClose [NTDLL.@]
365 * Close a handle reference to an object.
367 * PARAMS
368 * Handle [I] handle to close
370 * RETURNS
371 * Success: ERROR_SUCCESS.
372 * Failure: An NTSTATUS error code.
374 NTSTATUS WINAPI NtClose( HANDLE Handle )
376 return close_handle( Handle );
380 * Directory functions
383 /**************************************************************************
384 * NtOpenDirectoryObject [NTDLL.@]
385 * ZwOpenDirectoryObject [NTDLL.@]
387 * Open a namespace directory object.
389 * PARAMS
390 * DirectoryHandle [O] Destination for the new directory handle
391 * DesiredAccess [I] Desired access to the directory
392 * ObjectAttributes [I] Structure describing the directory
394 * RETURNS
395 * Success: ERROR_SUCCESS.
396 * Failure: An NTSTATUS error code.
398 NTSTATUS WINAPI NtOpenDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess,
399 POBJECT_ATTRIBUTES ObjectAttributes)
401 NTSTATUS ret;
403 if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
404 if (!ObjectAttributes) return STATUS_INVALID_PARAMETER;
405 TRACE("(%p,0x%08x,%s)\n", DirectoryHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
406 /* Have to test it here because server won't know difference between
407 * ObjectName == NULL and ObjectName == "" */
408 if (!ObjectAttributes->ObjectName)
410 if (ObjectAttributes->RootDirectory)
411 return STATUS_OBJECT_NAME_INVALID;
412 else
413 return STATUS_OBJECT_PATH_SYNTAX_BAD;
416 SERVER_START_REQ(open_directory)
418 req->access = DesiredAccess;
419 req->attributes = ObjectAttributes->Attributes;
420 req->rootdir = wine_server_obj_handle( ObjectAttributes->RootDirectory );
421 if (ObjectAttributes->ObjectName)
422 wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
423 ObjectAttributes->ObjectName->Length);
424 ret = wine_server_call( req );
425 *DirectoryHandle = wine_server_ptr_handle( reply->handle );
427 SERVER_END_REQ;
428 return ret;
431 /******************************************************************************
432 * NtCreateDirectoryObject [NTDLL.@]
433 * ZwCreateDirectoryObject [NTDLL.@]
435 * Create a namespace directory object.
437 * PARAMS
438 * DirectoryHandle [O] Destination for the new directory handle
439 * DesiredAccess [I] Desired access to the directory
440 * ObjectAttributes [I] Structure describing the directory
442 * RETURNS
443 * Success: ERROR_SUCCESS.
444 * Failure: An NTSTATUS error code.
446 NTSTATUS WINAPI NtCreateDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess,
447 POBJECT_ATTRIBUTES ObjectAttributes)
449 NTSTATUS ret;
451 if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
452 TRACE("(%p,0x%08x,%s)\n", DirectoryHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
454 SERVER_START_REQ(create_directory)
456 req->access = DesiredAccess;
457 req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
458 req->rootdir = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
459 if (ObjectAttributes && ObjectAttributes->ObjectName)
460 wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
461 ObjectAttributes->ObjectName->Length);
462 ret = wine_server_call( req );
463 *DirectoryHandle = wine_server_ptr_handle( reply->handle );
465 SERVER_END_REQ;
466 return ret;
469 /******************************************************************************
470 * NtQueryDirectoryObject [NTDLL.@]
471 * ZwQueryDirectoryObject [NTDLL.@]
473 * Read information from a namespace directory.
475 * PARAMS
476 * handle [I] Handle to a directory object
477 * buffer [O] Buffer to hold the read data
478 * size [I] Size of the buffer in bytes
479 * single_entry [I] If TRUE, return a single entry, if FALSE, return as many as fit in the buffer
480 * restart [I] If TRUE, start scanning from the start, if FALSE, scan from Context
481 * context [I/O] Indicates what point of the directory the scan is at
482 * ret_size [O] Caller supplied storage for the number of bytes written (or NULL)
484 * RETURNS
485 * Success: ERROR_SUCCESS.
486 * Failure: An NTSTATUS error code.
488 NTSTATUS WINAPI NtQueryDirectoryObject(HANDLE handle, PDIRECTORY_BASIC_INFORMATION buffer,
489 ULONG size, BOOLEAN single_entry, BOOLEAN restart,
490 PULONG context, PULONG ret_size)
492 NTSTATUS ret;
494 if (restart) *context = 0;
496 if (single_entry)
498 if (size <= sizeof(*buffer) + 2*sizeof(WCHAR)) return STATUS_BUFFER_OVERFLOW;
500 SERVER_START_REQ( get_directory_entry )
502 req->handle = wine_server_obj_handle( handle );
503 req->index = *context;
504 wine_server_set_reply( req, buffer + 1, size - sizeof(*buffer) - 2*sizeof(WCHAR) );
505 if (!(ret = wine_server_call( req )))
507 buffer->ObjectName.Buffer = (WCHAR *)(buffer + 1);
508 buffer->ObjectName.Length = reply->name_len;
509 buffer->ObjectName.MaximumLength = reply->name_len + sizeof(WCHAR);
510 buffer->ObjectTypeName.Buffer = (WCHAR *)(buffer + 1) + reply->name_len/sizeof(WCHAR) + 1;
511 buffer->ObjectTypeName.Length = wine_server_reply_size( reply ) - reply->name_len;
512 buffer->ObjectTypeName.MaximumLength = buffer->ObjectTypeName.Length + sizeof(WCHAR);
513 /* make room for the terminating null */
514 memmove( buffer->ObjectTypeName.Buffer, buffer->ObjectTypeName.Buffer - 1,
515 buffer->ObjectTypeName.Length );
516 buffer->ObjectName.Buffer[buffer->ObjectName.Length/sizeof(WCHAR)] = 0;
517 buffer->ObjectTypeName.Buffer[buffer->ObjectTypeName.Length/sizeof(WCHAR)] = 0;
518 (*context)++;
521 SERVER_END_REQ;
522 if (ret_size)
523 *ret_size = buffer->ObjectName.MaximumLength + buffer->ObjectTypeName.MaximumLength + sizeof(*buffer);
525 else
527 FIXME("multiple entries not implemented\n");
528 ret = STATUS_NOT_IMPLEMENTED;
531 return ret;
535 * Link objects
538 /******************************************************************************
539 * NtOpenSymbolicLinkObject [NTDLL.@]
540 * ZwOpenSymbolicLinkObject [NTDLL.@]
542 * Open a namespace symbolic link object.
544 * PARAMS
545 * LinkHandle [O] Destination for the new symbolic link handle
546 * DesiredAccess [I] Desired access to the symbolic link
547 * ObjectAttributes [I] Structure describing the symbolic link
549 * RETURNS
550 * Success: ERROR_SUCCESS.
551 * Failure: An NTSTATUS error code.
553 NTSTATUS WINAPI NtOpenSymbolicLinkObject(OUT PHANDLE LinkHandle, IN ACCESS_MASK DesiredAccess,
554 IN POBJECT_ATTRIBUTES ObjectAttributes)
556 NTSTATUS ret;
557 TRACE("(%p,0x%08x,%s)\n",LinkHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
559 if (!LinkHandle) return STATUS_ACCESS_VIOLATION;
560 if (!ObjectAttributes) return STATUS_INVALID_PARAMETER;
561 /* Have to test it here because server won't know difference between
562 * ObjectName == NULL and ObjectName == "" */
563 if (!ObjectAttributes->ObjectName)
565 if (ObjectAttributes->RootDirectory)
566 return STATUS_OBJECT_NAME_INVALID;
567 else
568 return STATUS_OBJECT_PATH_SYNTAX_BAD;
571 SERVER_START_REQ(open_symlink)
573 req->access = DesiredAccess;
574 req->attributes = ObjectAttributes->Attributes;
575 req->rootdir = wine_server_obj_handle( ObjectAttributes->RootDirectory );
576 if (ObjectAttributes->ObjectName)
577 wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
578 ObjectAttributes->ObjectName->Length);
579 ret = wine_server_call( req );
580 *LinkHandle = wine_server_ptr_handle( reply->handle );
582 SERVER_END_REQ;
583 return ret;
586 /******************************************************************************
587 * NtCreateSymbolicLinkObject [NTDLL.@]
588 * ZwCreateSymbolicLinkObject [NTDLL.@]
590 * Open a namespace symbolic link object.
592 * PARAMS
593 * SymbolicLinkHandle [O] Destination for the new symbolic link handle
594 * DesiredAccess [I] Desired access to the symbolic link
595 * ObjectAttributes [I] Structure describing the symbolic link
596 * TargetName [I] Name of the target symbolic link points to
598 * RETURNS
599 * Success: ERROR_SUCCESS.
600 * Failure: An NTSTATUS error code.
602 NTSTATUS WINAPI NtCreateSymbolicLinkObject(OUT PHANDLE SymbolicLinkHandle,IN ACCESS_MASK DesiredAccess,
603 IN POBJECT_ATTRIBUTES ObjectAttributes,
604 IN PUNICODE_STRING TargetName)
606 NTSTATUS ret;
608 if (!SymbolicLinkHandle || !TargetName) return STATUS_ACCESS_VIOLATION;
609 if (!TargetName->Buffer) return STATUS_INVALID_PARAMETER;
611 TRACE("(%p,0x%08x,%s -> %s)\n", SymbolicLinkHandle, DesiredAccess,
612 debugstr_ObjectAttributes(ObjectAttributes), debugstr_us(TargetName));
614 SERVER_START_REQ(create_symlink)
616 req->access = DesiredAccess;
617 req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
618 req->rootdir = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
619 if (ObjectAttributes && ObjectAttributes->ObjectName)
621 req->name_len = ObjectAttributes->ObjectName->Length;
622 wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
623 ObjectAttributes->ObjectName->Length);
625 else
626 req->name_len = 0;
627 wine_server_add_data(req, TargetName->Buffer, TargetName->Length);
628 ret = wine_server_call( req );
629 *SymbolicLinkHandle = wine_server_ptr_handle( reply->handle );
631 SERVER_END_REQ;
632 return ret;
635 /******************************************************************************
636 * NtQuerySymbolicLinkObject [NTDLL.@]
637 * ZwQuerySymbolicLinkObject [NTDLL.@]
639 * Query a namespace symbolic link object target name.
641 * PARAMS
642 * handle [I] Handle to a symbolic link object
643 * target [O] Destination for the symbolic link target
644 * length [O] Size of returned data
646 * RETURNS
647 * Success: ERROR_SUCCESS.
648 * Failure: An NTSTATUS error code.
650 NTSTATUS WINAPI NtQuerySymbolicLinkObject( HANDLE handle, PUNICODE_STRING target, PULONG length )
652 NTSTATUS ret;
654 TRACE("(%p,%p,%p)\n", handle, target, length );
656 if (!target) return STATUS_ACCESS_VIOLATION;
658 SERVER_START_REQ(query_symlink)
660 req->handle = wine_server_obj_handle( handle );
661 if (target->MaximumLength >= sizeof(WCHAR))
662 wine_server_set_reply( req, target->Buffer, target->MaximumLength - sizeof(WCHAR) );
663 if (!(ret = wine_server_call( req )))
665 target->Length = wine_server_reply_size(reply);
666 target->Buffer[target->Length / sizeof(WCHAR)] = 0;
667 if (length) *length = reply->total + sizeof(WCHAR);
669 else if (length && ret == STATUS_BUFFER_TOO_SMALL) *length = reply->total + sizeof(WCHAR);
671 SERVER_END_REQ;
672 return ret;
675 /******************************************************************************
676 * NtAllocateUuids [NTDLL.@]
678 NTSTATUS WINAPI NtAllocateUuids(
679 PULARGE_INTEGER Time,
680 PULONG Range,
681 PULONG Sequence)
683 FIXME("(%p,%p,%p), stub.\n", Time, Range, Sequence);
684 return 0;
687 /**************************************************************************
688 * NtMakeTemporaryObject [NTDLL.@]
689 * ZwMakeTemporaryObject [NTDLL.@]
691 * Make a permanent object temporary.
693 * PARAMS
694 * Handle [I] handle to permanent object
696 * RETURNS
697 * Success: STATUS_SUCCESS.
698 * Failure: An NTSTATUS error code.
700 NTSTATUS WINAPI NtMakeTemporaryObject( HANDLE Handle )
702 FIXME("(%p), stub.\n", Handle);
703 return STATUS_SUCCESS;