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) != 0;
 169                     p->ProtectFromClose = (reply->old_flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) != 0;
 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 && reply->self)
 336             {
 337                 int fd = server_remove_fd_from_cache( source );
 338                 if (fd != -1) close( fd );
 339             }
 340         }
 341     }
 342     SERVER_END_REQ;
 343     return ret;
 344 }
 345
 346 /* Everquest 2 / Pirates of the Burning Sea hooks NtClose, so we need a wrapper */
 347 NTSTATUS close_handle( HANDLE handle )
 348 {
 349     NTSTATUS ret;
 350     int fd = server_remove_fd_from_cache( handle );
 351
 352     SERVER_START_REQ( close_handle )
 353     {
 354         req->handle = wine_server_obj_handle( handle );
 355         ret = wine_server_call( req );
 356     }
 357     SERVER_END_REQ;
 358     if (fd != -1) close( fd );
 359     return ret;
 360 }
 361
 362 /**************************************************************************
 363  *                 NtClose                              [NTDLL.@]
 364  *
 365  * Close a handle reference to an object.
 366  *
 367  * PARAMS
 368  *  Handle [I] handle to close
 369  *
 370  * RETURNS
 371  *  Success: ERROR_SUCCESS.
 372  *  Failure: An NTSTATUS error code.
 373  */
 374 NTSTATUS WINAPI NtClose( HANDLE Handle )
 375 {
 376     return close_handle( Handle );
 377 }
 378
 379 /*
 380  *      Directory functions
 381  */
 382
 383 /**************************************************************************
 384  * NtOpenDirectoryObject [NTDLL.@]
 385  * ZwOpenDirectoryObject [NTDLL.@]
 386  *
 387  * Open a namespace directory object.
 388  *
 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
 393  *
 394  * RETURNS
 395  *  Success: ERROR_SUCCESS.
 396  *  Failure: An NTSTATUS error code.
 397  */
 398 NTSTATUS WINAPI NtOpenDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess,
 399                                       POBJECT_ATTRIBUTES ObjectAttributes)
 400 {
 401     NTSTATUS ret;
 402
 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)
 409     {
 410         if (ObjectAttributes->RootDirectory)
 411             return STATUS_OBJECT_NAME_INVALID;
 412         else
 413             return STATUS_OBJECT_PATH_SYNTAX_BAD;
 414     }
 415
 416     SERVER_START_REQ(open_directory)
 417     {
 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 );
 426     }
 427     SERVER_END_REQ;
 428     return ret;
 429 }
 430
 431 /******************************************************************************
 432  *  NtCreateDirectoryObject     [NTDLL.@]
 433  *  ZwCreateDirectoryObject     [NTDLL.@]
 434  *
 435  * Create a namespace directory object.
 436  *
 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
 441  *
 442  * RETURNS
 443  *  Success: ERROR_SUCCESS.
 444  *  Failure: An NTSTATUS error code.
 445  */
 446 NTSTATUS WINAPI NtCreateDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess,
 447                                         POBJECT_ATTRIBUTES ObjectAttributes)
 448 {
 449     NTSTATUS ret;
 450
 451     if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
 452     TRACE("(%p,0x%08x,%s)\n", DirectoryHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
 453
 454     SERVER_START_REQ(create_directory)
 455     {
 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 );
 464     }
 465     SERVER_END_REQ;
 466     return ret;
 467 }
 468
 469 /******************************************************************************
 470  * NtQueryDirectoryObject [NTDLL.@]
 471  * ZwQueryDirectoryObject [NTDLL.@]
 472  *
 473  * Read information from a namespace directory.
 474  *
 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)
 483  *
 484  * RETURNS
 485  *  Success: ERROR_SUCCESS.
 486  *  Failure: An NTSTATUS error code.
 487  */
 488 NTSTATUS WINAPI NtQueryDirectoryObject(HANDLE handle, PDIRECTORY_BASIC_INFORMATION buffer,
 489                                        ULONG size, BOOLEAN single_entry, BOOLEAN restart,
 490                                        PULONG context, PULONG ret_size)
 491 {
 492     NTSTATUS ret;
 493
 494     if (restart) *context = 0;
 495
 496     if (single_entry)
 497     {
 498         if (size <= sizeof(*buffer) + 2*sizeof(WCHAR)) return STATUS_BUFFER_OVERFLOW;
 499
 500         SERVER_START_REQ( get_directory_entry )
 501         {
 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 )))
 506             {
 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)++;
 519             }
 520         }
 521         SERVER_END_REQ;
 522         if (ret_size)
 523             *ret_size = buffer->ObjectName.MaximumLength + buffer->ObjectTypeName.MaximumLength + sizeof(*buffer);
 524     }
 525     else
 526     {
 527         FIXME("multiple entries not implemented\n");
 528         ret = STATUS_NOT_IMPLEMENTED;
 529     }
 530
 531     return ret;
 532 }
 533
 534 /*
 535  *      Link objects
 536  */
 537
 538 /******************************************************************************
 539  *  NtOpenSymbolicLinkObject    [NTDLL.@]
 540  *  ZwOpenSymbolicLinkObject    [NTDLL.@]
 541  *
 542  * Open a namespace symbolic link object.
 543  *
 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
 548  *
 549  * RETURNS
 550  *  Success: ERROR_SUCCESS.
 551  *  Failure: An NTSTATUS error code.
 552  */
 553 NTSTATUS WINAPI NtOpenSymbolicLinkObject(OUT PHANDLE LinkHandle, IN ACCESS_MASK DesiredAccess,
 554                                          IN POBJECT_ATTRIBUTES ObjectAttributes)
 555 {
 556     NTSTATUS ret;
 557     TRACE("(%p,0x%08x,%s)\n",LinkHandle, DesiredAccess, debugstr_ObjectAttributes(ObjectAttributes));
 558
 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)
 564     {
 565         if (ObjectAttributes->RootDirectory)
 566             return STATUS_OBJECT_NAME_INVALID;
 567         else
 568             return STATUS_OBJECT_PATH_SYNTAX_BAD;
 569     }
 570
 571     SERVER_START_REQ(open_symlink)
 572     {
 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 );
 581     }
 582     SERVER_END_REQ;
 583     return ret;
 584 }
 585
 586 /******************************************************************************
 587  *  NtCreateSymbolicLinkObject  [NTDLL.@]
 588  *  ZwCreateSymbolicLinkObject  [NTDLL.@]
 589  *
 590  * Open a namespace symbolic link object.
 591  *
 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
 597  *
 598  * RETURNS
 599  *  Success: ERROR_SUCCESS.
 600  *  Failure: An NTSTATUS error code.
 601  */
 602 NTSTATUS WINAPI NtCreateSymbolicLinkObject(OUT PHANDLE SymbolicLinkHandle,IN ACCESS_MASK DesiredAccess,
 603                                            IN POBJECT_ATTRIBUTES ObjectAttributes,
 604                                            IN PUNICODE_STRING TargetName)
 605 {
 606     NTSTATUS ret;
 607
 608     if (!SymbolicLinkHandle || !TargetName) return STATUS_ACCESS_VIOLATION;
 609     if (!TargetName->Buffer) return STATUS_INVALID_PARAMETER;
 610
 611     TRACE("(%p,0x%08x,%s -> %s)\n", SymbolicLinkHandle, DesiredAccess,
 612           debugstr_ObjectAttributes(ObjectAttributes), debugstr_us(TargetName));
 613
 614     SERVER_START_REQ(create_symlink)
 615     {
 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)
 620         {
 621             req->name_len = ObjectAttributes->ObjectName->Length;
 622             wine_server_add_data(req, ObjectAttributes->ObjectName->Buffer,
 623                                  ObjectAttributes->ObjectName->Length);
 624         }
 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 );
 630     }
 631     SERVER_END_REQ;
 632     return ret;
 633 }
 634
 635 /******************************************************************************
 636  *  NtQuerySymbolicLinkObject   [NTDLL.@]
 637  *  ZwQuerySymbolicLinkObject   [NTDLL.@]
 638  *
 639  * Query a namespace symbolic link object target name.
 640  *
 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
 645  *
 646  * RETURNS
 647  *  Success: ERROR_SUCCESS.
 648  *  Failure: An NTSTATUS error code.
 649  */
 650 NTSTATUS WINAPI NtQuerySymbolicLinkObject( HANDLE handle, PUNICODE_STRING target, PULONG length )
 651 {
 652     NTSTATUS ret;
 653
 654     TRACE("(%p,%p,%p)\n", handle, target, length );
 655
 656     if (!target) return STATUS_ACCESS_VIOLATION;
 657
 658     SERVER_START_REQ(query_symlink)
 659     {
 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 )))
 664         {
 665             target->Length = wine_server_reply_size(reply);
 666             target->Buffer[target->Length / sizeof(WCHAR)] = 0;
 667             if (length) *length = reply->total + sizeof(WCHAR);
 668         }
 669         else if (length && ret == STATUS_BUFFER_TOO_SMALL) *length = reply->total + sizeof(WCHAR);
 670     }
 671     SERVER_END_REQ;
 672     return ret;
 673 }
 674
 675 /******************************************************************************
 676  *  NtAllocateUuids   [NTDLL.@]
 677  */
 678 NTSTATUS WINAPI NtAllocateUuids(
 679         PULARGE_INTEGER Time,
 680         PULONG Range,
 681         PULONG Sequence)
 682 {
 683         FIXME("(%p,%p,%p), stub.\n", Time, Range, Sequence);
 684         return 0;
 685 }
 686
 687 /**************************************************************************
 688  *  NtMakeTemporaryObject       [NTDLL.@]
 689  *  ZwMakeTemporaryObject       [NTDLL.@]
 690  *
 691  * Make a permanent object temporary.
 692  *
 693  * PARAMS
 694  *  Handle [I] handle to permanent object
 695  *
 696  * RETURNS
 697  *  Success: STATUS_SUCCESS.
 698  *  Failure: An NTSTATUS error code.
 699  */
 700 NTSTATUS WINAPI NtMakeTemporaryObject( HANDLE Handle )
 701 {
 702     FIXME("(%p), stub.\n", Handle);
 703     return STATUS_SUCCESS;
 704 }