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 }