crypt32: Partially implement checking name constraints with directory names.
[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 ObjectDataInformation:
89         {
90             OBJECT_DATA_INFORMATION* p = ptr;
91
92             if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
93
94             SERVER_START_REQ( set_handle_info )
95             {
96                 req->handle = wine_server_obj_handle( handle );
97                 req->flags  = 0;
98                 req->mask   = 0;
99                 status = wine_server_call( req );
100                 if (status == STATUS_SUCCESS)
101                 {
102                     p->InheritHandle = (reply->old_flags & HANDLE_FLAG_INHERIT) ? TRUE : FALSE;
103                     p->ProtectFromClose = (reply->old_flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) ? TRUE : FALSE;
104                     if (used_len) *used_len = sizeof(*p);
105                 }
106             }
107             SERVER_END_REQ;
108         }
109         break;
110     default:
111         FIXME("Unsupported information class %u\n", info_class);
112         status = STATUS_NOT_IMPLEMENTED;
113         break;
114     }
115     return status;
116 }
117
118 /******************************************************************
119  *              NtSetInformationObject [NTDLL.@]
120  *              ZwSetInformationObject [NTDLL.@]
121  *
122  */
123 NTSTATUS WINAPI NtSetInformationObject(IN HANDLE handle,
124                                        IN OBJECT_INFORMATION_CLASS info_class,
125                                        IN PVOID ptr, IN ULONG len)
126 {
127     NTSTATUS status;
128
129     TRACE("(%p,0x%08x,%p,0x%08x): stub\n",
130           handle, info_class, ptr, len);
131
132     switch (info_class)
133     {
134     case ObjectDataInformation:
135         {
136             OBJECT_DATA_INFORMATION* p = ptr;
137
138             if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
139
140             SERVER_START_REQ( set_handle_info )
141             {
142                 req->handle = wine_server_obj_handle( handle );
143                 req->flags  = 0;
144                 req->mask   = HANDLE_FLAG_INHERIT | HANDLE_FLAG_PROTECT_FROM_CLOSE;
145                 if (p->InheritHandle)    req->flags |= HANDLE_FLAG_INHERIT;
146                 if (p->ProtectFromClose) req->flags |= HANDLE_FLAG_PROTECT_FROM_CLOSE;
147                 status = wine_server_call( req );
148             }
149             SERVER_END_REQ;
150         }
151         break;
152     default:
153         FIXME("Unsupported information class %u\n", info_class);
154         status = STATUS_NOT_IMPLEMENTED;
155         break;
156     }
157     return status;
158 }
159
160 /******************************************************************************
161  *  NtQuerySecurityObject       [NTDLL.@]
162  *
163  * An ntdll analogue to GetKernelObjectSecurity().
164  *
165  */
166 NTSTATUS WINAPI
167 NtQuerySecurityObject(
168         IN HANDLE Object,
169         IN SECURITY_INFORMATION RequestedInformation,
170         OUT PSECURITY_DESCRIPTOR pSecurityDescriptor,
171         IN ULONG Length,
172         OUT PULONG ResultLength)
173 {
174     PISECURITY_DESCRIPTOR_RELATIVE psd = pSecurityDescriptor;
175     NTSTATUS status;
176     unsigned int buffer_size = 512;
177     BOOLEAN need_more_memory;
178
179     TRACE("(%p,0x%08x,%p,0x%08x,%p)\n",
180         Object, RequestedInformation, pSecurityDescriptor, Length, ResultLength);
181
182     do
183     {
184         char *buffer = RtlAllocateHeap(GetProcessHeap(), 0, buffer_size);
185         if (!buffer)
186             return STATUS_NO_MEMORY;
187
188         need_more_memory = FALSE;
189
190         SERVER_START_REQ( get_security_object )
191         {
192             req->handle = wine_server_obj_handle( Object );
193             req->security_info = RequestedInformation;
194             wine_server_set_reply( req, buffer, buffer_size );
195             status = wine_server_call( req );
196             if (status == STATUS_SUCCESS)
197             {
198                 struct security_descriptor *sd = (struct security_descriptor *)buffer;
199                 if (reply->sd_len)
200                 {
201                     *ResultLength = sizeof(SECURITY_DESCRIPTOR_RELATIVE) +
202                         sd->owner_len + sd->group_len + sd->sacl_len + sd->dacl_len;
203                     if (Length >= *ResultLength)
204                     {
205                         psd->Revision = SECURITY_DESCRIPTOR_REVISION;
206                         psd->Sbz1 = 0;
207                         psd->Control = sd->control | SE_SELF_RELATIVE;
208                         psd->Owner = sd->owner_len ? sizeof(SECURITY_DESCRIPTOR_RELATIVE) : 0;
209                         psd->Group = sd->group_len ? sizeof(SECURITY_DESCRIPTOR_RELATIVE) + sd->owner_len : 0;
210                         psd->Sacl = sd->sacl_len ? sizeof(SECURITY_DESCRIPTOR_RELATIVE) + sd->owner_len + sd->group_len : 0;
211                         psd->Dacl = sd->dacl_len ? sizeof(SECURITY_DESCRIPTOR_RELATIVE) + sd->owner_len + sd->group_len + sd->sacl_len : 0;
212                         /* owner, group, sacl and dacl are the same type as in the server
213                          * and in the same order so we copy the memory in one block */
214                         memcpy((char *)pSecurityDescriptor + sizeof(SECURITY_DESCRIPTOR_RELATIVE),
215                                buffer + sizeof(struct security_descriptor),
216                                sd->owner_len + sd->group_len + sd->sacl_len + sd->dacl_len);
217                     }
218                     else
219                         status = STATUS_BUFFER_TOO_SMALL;
220                 }
221                 else
222                 {
223                     *ResultLength = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
224                     if (Length >= *ResultLength)
225                     {
226                         memset(psd, 0, sizeof(*psd));
227                         psd->Revision = SECURITY_DESCRIPTOR_REVISION;
228                         psd->Control = SE_SELF_RELATIVE;
229                     }
230                     else
231                         status = STATUS_BUFFER_TOO_SMALL;
232                 }
233             }
234             else if (status == STATUS_BUFFER_TOO_SMALL)
235             {
236                 buffer_size = reply->sd_len;
237                 need_more_memory = TRUE;
238             }
239         }
240         SERVER_END_REQ;
241         RtlFreeHeap(GetProcessHeap(), 0, buffer);
242     } while (need_more_memory);
243
244     return status;
245 }
246
247
248 /******************************************************************************
249  *  NtDuplicateObject           [NTDLL.@]
250  *  ZwDuplicateObject           [NTDLL.@]
251  */
252 NTSTATUS WINAPI NtDuplicateObject( HANDLE source_process, HANDLE source,
253                                    HANDLE dest_process, PHANDLE dest,
254                                    ACCESS_MASK access, ULONG attributes, ULONG options )
255 {
256     NTSTATUS ret;
257     SERVER_START_REQ( dup_handle )
258     {
259         req->src_process = wine_server_obj_handle( source_process );
260         req->src_handle  = wine_server_obj_handle( source );
261         req->dst_process = wine_server_obj_handle( dest_process );
262         req->access      = access;
263         req->attributes  = attributes;
264         req->options     = options;
265
266         if (!(ret = wine_server_call( req )))
267         {
268             if (dest) *dest = wine_server_ptr_handle( reply->handle );
269             if (reply->closed)
270             {
271                 if (reply->self)
272                 {
273                     int fd = server_remove_fd_from_cache( source );
274                     if (fd != -1) close( fd );
275                 }
276             }
277             else if (options & DUPLICATE_CLOSE_SOURCE)
278                 WARN( "failed to close handle %p in process %p\n", source, source_process );
279         }
280     }
281     SERVER_END_REQ;
282     return ret;
283 }
284
285 /**************************************************************************
286  *                 NtClose                              [NTDLL.@]
287  *
288  * Close a handle reference to an object.
289  * 
290  * PARAMS
291  *  Handle [I] handle to close
292  *
293  * RETURNS
294  *  Success: ERROR_SUCCESS.
295  *  Failure: An NTSTATUS error code.
296  */
297 NTSTATUS WINAPI NtClose( HANDLE Handle )
298 {
299     NTSTATUS ret;
300     int fd = server_remove_fd_from_cache( Handle );
301
302     SERVER_START_REQ( close_handle )
303     {
304         req->handle = wine_server_obj_handle( Handle );
305         ret = wine_server_call( req );
306     }
307     SERVER_END_REQ;
308     if (fd != -1) close( fd );
309     return ret;
310 }
311
312 /*
313  *      Directory functions
314  */
315
316 /**************************************************************************
317  * NtOpenDirectoryObject [NTDLL.@]
318  * ZwOpenDirectoryObject [NTDLL.@]
319  *
320  * Open a namespace directory object.
321  * 
322  * PARAMS
323  *  DirectoryHandle  [O] Destination for the new directory handle
324  *  DesiredAccess    [I] Desired access to the directory
325  *  ObjectAttributes [I] Structure describing the directory
326  *
327  * RETURNS
328  *  Success: ERROR_SUCCESS.
329  *  Failure: An NTSTATUS error code.
330  */
331 NTSTATUS WINAPI NtOpenDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess,
332                                       POBJECT_ATTRIBUTES ObjectAttributes)
333 {
334     NTSTATUS ret;
335     TRACE("(%p,0x%08x,%s)\n", DirectoryHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
336
337     if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
338     if (!ObjectAttributes) return STATUS_INVALID_PARAMETER;
339     /* Have to test it here because server won't know difference between
340      * ObjectName == NULL and ObjectName == "" */
341     if (!ObjectAttributes->ObjectName)
342     {
343         if (ObjectAttributes->RootDirectory)
344             return STATUS_OBJECT_NAME_INVALID;
345         else
346             return STATUS_OBJECT_PATH_SYNTAX_BAD;
347     }
348
349     SERVER_START_REQ(open_directory)
350     {
351         req->access = DesiredAccess;
352         req->attributes = ObjectAttributes->Attributes;
353         req->rootdir = wine_server_obj_handle( ObjectAttributes->RootDirectory );
354         if (ObjectAttributes->ObjectName)
355             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
356                                  ObjectAttributes->ObjectName->Length);
357         ret = wine_server_call( req );
358         *DirectoryHandle = wine_server_ptr_handle( reply->handle );
359     }
360     SERVER_END_REQ;
361     return ret;
362 }
363
364 /******************************************************************************
365  *  NtCreateDirectoryObject     [NTDLL.@]
366  *  ZwCreateDirectoryObject     [NTDLL.@]
367  *
368  * Create a namespace directory object.
369  * 
370  * PARAMS
371  *  DirectoryHandle  [O] Destination for the new directory handle
372  *  DesiredAccess    [I] Desired access to the directory
373  *  ObjectAttributes [I] Structure describing the directory
374  *
375  * RETURNS
376  *  Success: ERROR_SUCCESS.
377  *  Failure: An NTSTATUS error code.
378  */
379 NTSTATUS WINAPI NtCreateDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess,
380                                         POBJECT_ATTRIBUTES ObjectAttributes)
381 {
382     NTSTATUS ret;
383     TRACE("(%p,0x%08x,%s)\n", DirectoryHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
384
385     if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
386
387     SERVER_START_REQ(create_directory)
388     {
389         req->access = DesiredAccess;
390         req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
391         req->rootdir = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
392         if (ObjectAttributes && ObjectAttributes->ObjectName)
393             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
394                                  ObjectAttributes->ObjectName->Length);
395         ret = wine_server_call( req );
396         *DirectoryHandle = wine_server_ptr_handle( reply->handle );
397     }
398     SERVER_END_REQ;
399     return ret;
400 }
401
402 /******************************************************************************
403  * NtQueryDirectoryObject [NTDLL.@]
404  * ZwQueryDirectoryObject [NTDLL.@]
405  *
406  * Read information from a namespace directory.
407  * 
408  * PARAMS
409  *  handle        [I]   Handle to a directory object
410  *  buffer        [O]   Buffer to hold the read data
411  *  size          [I]   Size of the buffer in bytes
412  *  single_entry  [I]   If TRUE, return a single entry, if FALSE, return as many as fit in the buffer
413  *  restart       [I]   If TRUE, start scanning from the start, if FALSE, scan from Context
414  *  context       [I/O] Indicates what point of the directory the scan is at
415  *  ret_size      [O]   Caller supplied storage for the number of bytes written (or NULL)
416  *
417  * RETURNS
418  *  Success: ERROR_SUCCESS.
419  *  Failure: An NTSTATUS error code.
420  */
421 NTSTATUS WINAPI NtQueryDirectoryObject(HANDLE handle, PDIRECTORY_BASIC_INFORMATION buffer,
422                                        ULONG size, BOOLEAN single_entry, BOOLEAN restart,
423                                        PULONG context, PULONG ret_size)
424 {
425     NTSTATUS ret;
426
427     if (restart) *context = 0;
428
429     if (single_entry)
430     {
431         if (size <= sizeof(*buffer) + 2*sizeof(WCHAR)) return STATUS_BUFFER_OVERFLOW;
432
433         SERVER_START_REQ( get_directory_entry )
434         {
435             req->handle = wine_server_obj_handle( handle );
436             req->index = *context;
437             wine_server_set_reply( req, buffer + 1, size - sizeof(*buffer) - 2*sizeof(WCHAR) );
438             if (!(ret = wine_server_call( req )))
439             {
440                 buffer->ObjectName.Buffer = (WCHAR *)(buffer + 1);
441                 buffer->ObjectName.Length = reply->name_len;
442                 buffer->ObjectName.MaximumLength = reply->name_len + sizeof(WCHAR);
443                 buffer->ObjectTypeName.Buffer = (WCHAR *)(buffer + 1) + reply->name_len/sizeof(WCHAR) + 1;
444                 buffer->ObjectTypeName.Length = wine_server_reply_size( reply ) - reply->name_len;
445                 buffer->ObjectTypeName.MaximumLength = buffer->ObjectTypeName.Length + sizeof(WCHAR);
446                 /* make room for the terminating null */
447                 memmove( buffer->ObjectTypeName.Buffer, buffer->ObjectTypeName.Buffer - 1,
448                          buffer->ObjectTypeName.Length );
449                 buffer->ObjectName.Buffer[buffer->ObjectName.Length/sizeof(WCHAR)] = 0;
450                 buffer->ObjectTypeName.Buffer[buffer->ObjectTypeName.Length/sizeof(WCHAR)] = 0;
451                 (*context)++;
452             }
453         }
454         SERVER_END_REQ;
455         if (ret_size)
456             *ret_size = buffer->ObjectName.MaximumLength + buffer->ObjectTypeName.MaximumLength + sizeof(*buffer);
457     }
458     else
459     {
460         FIXME("multiple entries not implemented\n");
461         ret = STATUS_NOT_IMPLEMENTED;
462     }
463
464     return ret;
465 }
466
467 /*
468  *      Link objects
469  */
470
471 /******************************************************************************
472  *  NtOpenSymbolicLinkObject    [NTDLL.@]
473  *  ZwOpenSymbolicLinkObject    [NTDLL.@]
474  *
475  * Open a namespace symbolic link object.
476  * 
477  * PARAMS
478  *  LinkHandle       [O] Destination for the new symbolic link handle
479  *  DesiredAccess    [I] Desired access to the symbolic link
480  *  ObjectAttributes [I] Structure describing the symbolic link
481  *
482  * RETURNS
483  *  Success: ERROR_SUCCESS.
484  *  Failure: An NTSTATUS error code.
485  */
486 NTSTATUS WINAPI NtOpenSymbolicLinkObject(OUT PHANDLE LinkHandle, IN ACCESS_MASK DesiredAccess,
487                                          IN POBJECT_ATTRIBUTES ObjectAttributes)
488 {
489     NTSTATUS ret;
490     TRACE("(%p,0x%08x,%s)\n",LinkHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
491
492     if (!LinkHandle) return STATUS_ACCESS_VIOLATION;
493     if (!ObjectAttributes) return STATUS_INVALID_PARAMETER;
494     /* Have to test it here because server won't know difference between
495      * ObjectName == NULL and ObjectName == "" */
496     if (!ObjectAttributes->ObjectName)
497     {
498         if (ObjectAttributes->RootDirectory)
499             return STATUS_OBJECT_NAME_INVALID;
500         else
501             return STATUS_OBJECT_PATH_SYNTAX_BAD;
502     }
503
504     SERVER_START_REQ(open_symlink)
505     {
506         req->access = DesiredAccess;
507         req->attributes = ObjectAttributes->Attributes;
508         req->rootdir = wine_server_obj_handle( ObjectAttributes->RootDirectory );
509         if (ObjectAttributes->ObjectName)
510             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
511                                  ObjectAttributes->ObjectName->Length);
512         ret = wine_server_call( req );
513         *LinkHandle = wine_server_ptr_handle( reply->handle );
514     }
515     SERVER_END_REQ;
516     return ret;
517 }
518
519 /******************************************************************************
520  *  NtCreateSymbolicLinkObject  [NTDLL.@]
521  *  ZwCreateSymbolicLinkObject  [NTDLL.@]
522  *
523  * Open a namespace symbolic link object.
524  * 
525  * PARAMS
526  *  SymbolicLinkHandle [O] Destination for the new symbolic link handle
527  *  DesiredAccess      [I] Desired access to the symbolic link
528  *  ObjectAttributes   [I] Structure describing the symbolic link
529  *  TargetName         [I] Name of the target symbolic link points to
530  *
531  * RETURNS
532  *  Success: ERROR_SUCCESS.
533  *  Failure: An NTSTATUS error code.
534  */
535 NTSTATUS WINAPI NtCreateSymbolicLinkObject(OUT PHANDLE SymbolicLinkHandle,IN ACCESS_MASK DesiredAccess,
536                                            IN POBJECT_ATTRIBUTES ObjectAttributes,
537                                            IN PUNICODE_STRING TargetName)
538 {
539     NTSTATUS ret;
540
541     if (!SymbolicLinkHandle || !TargetName) return STATUS_ACCESS_VIOLATION;
542     if (!TargetName->Buffer) return STATUS_INVALID_PARAMETER;
543
544     TRACE("(%p,0x%08x,%s -> %s)\n", SymbolicLinkHandle, DesiredAccess,
545           debugstr_ObjectAttributes(ObjectAttributes), debugstr_us(TargetName));
546
547     SERVER_START_REQ(create_symlink)
548     {
549         req->access = DesiredAccess;
550         req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
551         req->rootdir = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
552         if (ObjectAttributes && ObjectAttributes->ObjectName)
553         {
554             req->name_len = ObjectAttributes->ObjectName->Length;
555             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
556                                  ObjectAttributes->ObjectName->Length);
557         }
558         else
559             req->name_len = 0;
560         wine_server_add_data(req, TargetName->Buffer, TargetName->Length);
561         ret = wine_server_call( req );
562         *SymbolicLinkHandle = wine_server_ptr_handle( reply->handle );
563     }
564     SERVER_END_REQ;
565     return ret;
566 }
567
568 /******************************************************************************
569  *  NtQuerySymbolicLinkObject   [NTDLL.@]
570  *  ZwQuerySymbolicLinkObject   [NTDLL.@]
571  *
572  * Query a namespace symbolic link object target name.
573  * 
574  * PARAMS
575  *  LinkHandle     [I] Handle to a symbolic link object
576  *  LinkTarget     [O] Destination for the symbolic link target
577  *  ReturnedLength [O] Size of returned data
578  *
579  * RETURNS
580  *  Success: ERROR_SUCCESS.
581  *  Failure: An NTSTATUS error code.
582  */
583 NTSTATUS WINAPI NtQuerySymbolicLinkObject(IN HANDLE LinkHandle, IN OUT PUNICODE_STRING LinkTarget,
584                                           OUT PULONG ReturnedLength OPTIONAL)
585 {
586     NTSTATUS ret;
587     TRACE("(%p,%p,%p)\n", LinkHandle, LinkTarget, ReturnedLength);
588
589     if (!LinkTarget) return STATUS_ACCESS_VIOLATION;
590
591     SERVER_START_REQ(query_symlink)
592     {
593         req->handle = wine_server_obj_handle( LinkHandle );
594         wine_server_set_reply( req, LinkTarget->Buffer, LinkTarget->MaximumLength );
595         if (!(ret = wine_server_call( req )))
596         {
597             LinkTarget->Length = wine_server_reply_size(reply);
598             if (ReturnedLength) *ReturnedLength = LinkTarget->Length;
599         }
600     }
601     SERVER_END_REQ;
602     return ret;
603 }
604
605 /******************************************************************************
606  *  NtAllocateUuids   [NTDLL.@]
607  */
608 NTSTATUS WINAPI NtAllocateUuids(
609         PULARGE_INTEGER Time,
610         PULONG Range,
611         PULONG Sequence)
612 {
613         FIXME("(%p,%p,%p), stub.\n", Time, Range, Sequence);
614         return 0;
615 }
616
617 /**************************************************************************
618  *  NtMakeTemporaryObject       [NTDLL.@]
619  *  ZwMakeTemporaryObject       [NTDLL.@]
620  *
621  * Make a permanent object temporary.
622  *
623  * PARAMS
624  *  Handle [I] handle to permanent object
625  *
626  * RETURNS
627  *  Success: STATUS_SUCCESS.
628  *  Failure: An NTSTATUS error code.
629  */
630 NTSTATUS WINAPI NtMakeTemporaryObject( HANDLE Handle )
631 {
632     FIXME("(%p), stub.\n", Handle);
633     return STATUS_SUCCESS;
634 }