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
35 #define WIN32_NO_STATUS
36 #include "wine/debug.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
)
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;
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
);
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
;
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
);
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
;
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
;
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
);
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
);
177 FIXME("Unsupported information class %u\n", info_class
);
178 status
= STATUS_NOT_IMPLEMENTED
;
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
)
195 TRACE("(%p,0x%08x,%p,0x%08x): stub\n",
196 handle
, info_class
, ptr
, len
);
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
);
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
);
219 FIXME("Unsupported information class %u\n", info_class
);
220 status
= STATUS_NOT_IMPLEMENTED
;
226 /******************************************************************************
227 * NtQuerySecurityObject [NTDLL.@]
229 * An ntdll analogue to GetKernelObjectSecurity().
233 NtQuerySecurityObject(
235 IN SECURITY_INFORMATION RequestedInformation
,
236 OUT PSECURITY_DESCRIPTOR pSecurityDescriptor
,
238 OUT PULONG ResultLength
)
240 PISECURITY_DESCRIPTOR_RELATIVE psd
= pSecurityDescriptor
;
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
);
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
;
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
;
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
);
285 status
= STATUS_BUFFER_TOO_SMALL
;
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
;
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
;
307 RtlFreeHeap(GetProcessHeap(), 0, buffer
);
308 } while (need_more_memory
);
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
)
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
);
346 /* Everquest 2 / Pirates of the Burning Sea hooks NtClose, so we need a wrapper */
347 NTSTATUS
close_handle( HANDLE handle
)
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
);
358 if (fd
!= -1) close( fd
);
362 /**************************************************************************
365 * Close a handle reference to an object.
368 * Handle [I] handle to close
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.
390 * DirectoryHandle [O] Destination for the new directory handle
391 * DesiredAccess [I] Desired access to the directory
392 * ObjectAttributes [I] Structure describing the directory
395 * Success: ERROR_SUCCESS.
396 * Failure: An NTSTATUS error code.
398 NTSTATUS WINAPI
NtOpenDirectoryObject(PHANDLE DirectoryHandle
, ACCESS_MASK DesiredAccess
,
399 POBJECT_ATTRIBUTES ObjectAttributes
)
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
;
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
);
431 /******************************************************************************
432 * NtCreateDirectoryObject [NTDLL.@]
433 * ZwCreateDirectoryObject [NTDLL.@]
435 * Create a namespace directory object.
438 * DirectoryHandle [O] Destination for the new directory handle
439 * DesiredAccess [I] Desired access to the directory
440 * ObjectAttributes [I] Structure describing the directory
443 * Success: ERROR_SUCCESS.
444 * Failure: An NTSTATUS error code.
446 NTSTATUS WINAPI
NtCreateDirectoryObject(PHANDLE DirectoryHandle
, ACCESS_MASK DesiredAccess
,
447 POBJECT_ATTRIBUTES ObjectAttributes
)
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
);
469 /******************************************************************************
470 * NtQueryDirectoryObject [NTDLL.@]
471 * ZwQueryDirectoryObject [NTDLL.@]
473 * Read information from a namespace directory.
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)
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
)
494 if (restart
) *context
= 0;
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;
523 *ret_size
= buffer
->ObjectName
.MaximumLength
+ buffer
->ObjectTypeName
.MaximumLength
+ sizeof(*buffer
);
527 FIXME("multiple entries not implemented\n");
528 ret
= STATUS_NOT_IMPLEMENTED
;
538 /******************************************************************************
539 * NtOpenSymbolicLinkObject [NTDLL.@]
540 * ZwOpenSymbolicLinkObject [NTDLL.@]
542 * Open a namespace symbolic link object.
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
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
)
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
;
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
);
586 /******************************************************************************
587 * NtCreateSymbolicLinkObject [NTDLL.@]
588 * ZwCreateSymbolicLinkObject [NTDLL.@]
590 * Open a namespace symbolic link object.
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
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
)
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
);
627 wine_server_add_data(req
, TargetName
->Buffer
, TargetName
->Length
);
628 ret
= wine_server_call( req
);
629 *SymbolicLinkHandle
= wine_server_ptr_handle( reply
->handle
);
635 /******************************************************************************
636 * NtQuerySymbolicLinkObject [NTDLL.@]
637 * ZwQuerySymbolicLinkObject [NTDLL.@]
639 * Query a namespace symbolic link object target name.
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
647 * Success: ERROR_SUCCESS.
648 * Failure: An NTSTATUS error code.
650 NTSTATUS WINAPI
NtQuerySymbolicLinkObject( HANDLE handle
, PUNICODE_STRING target
, PULONG length
)
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
);
675 /******************************************************************************
676 * NtAllocateUuids [NTDLL.@]
678 NTSTATUS WINAPI
NtAllocateUuids(
679 PULARGE_INTEGER Time
,
683 FIXME("(%p,%p,%p), stub.\n", Time
, Range
, Sequence
);
687 /**************************************************************************
688 * NtMakeTemporaryObject [NTDLL.@]
689 * ZwMakeTemporaryObject [NTDLL.@]
691 * Make a permanent object temporary.
694 * Handle [I] handle to permanent object
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
;