Added exception handling wrapper to a number of server requests.

dlls/kernel/toolhelp.c

@@ -184,7 +184,7 @@ FARPROC16 tmp;
  */
 HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process ) 
 {
-    struct create_snapshot_request *req = get_req_buffer();
+    HANDLE ret;
 
     TRACE("%lx,%lx\n", flags, process );
     if (!(flags & (TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)))
@@ -195,11 +195,17 @@ HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
     }
 
     /* Now do the snapshot */
+    SERVER_START_REQ
+    {
+        struct create_snapshot_request *req = server_alloc_req( sizeof(*req), 0 );
         req->flags   = flags & ~TH32CS_INHERIT;
         req->inherit = (flags & TH32CS_INHERIT) != 0;
         req->pid     = (void *)process;
         server_call( REQ_CREATE_SNAPSHOT );
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -210,7 +216,7 @@ HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
  */
 static BOOL TOOLHELP_Thread32Next( HANDLE handle, LPTHREADENTRY32 lpte, BOOL first )
 {
-    struct next_thread_request *req = get_req_buffer();
+    BOOL ret;
 
     if (lpte->dwSize < sizeof(THREADENTRY32))
     {
@@ -218,16 +224,23 @@ static BOOL TOOLHELP_Thread32Next( HANDLE handle, LPTHREADENTRY32 lpte, BOOL fir
         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(THREADENTRY32), lpte->dwSize);
         return FALSE;
     }
+    SERVER_START_REQ
+    {
+        struct next_thread_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->reset = first;
-    if (server_call( REQ_NEXT_THREAD )) return FALSE;
+        if ((ret = !server_call( REQ_NEXT_THREAD )))
+        {
             lpte->cntUsage           = req->count;
             lpte->th32ThreadID       = (DWORD)req->tid;
             lpte->th32OwnerProcessID = (DWORD)req->pid;
             lpte->tbBasePri          = req->base_pri;
             lpte->tbDeltaPri         = req->delta_pri;
             lpte->dwFlags            = 0;  /* SDK: "reserved; do not use" */
-    return TRUE;
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /***********************************************************************
@@ -257,7 +270,7 @@ BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
  */
 static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY32 lppe, BOOL first )
 {
-    struct next_process_request *req = get_req_buffer();
+    BOOL ret;
 
     if (lppe->dwSize < sizeof(PROCESSENTRY32))
     {
@@ -265,9 +278,13 @@ static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY32 lppe, BOOL f
         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32), lppe->dwSize);
         return FALSE;
     }
+    SERVER_START_REQ
+    {
+        struct next_process_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->reset = first;
-    if (server_call( REQ_NEXT_PROCESS )) return FALSE;
+        if ((ret = !server_call( REQ_NEXT_PROCESS )))
+        {
             lppe->cntUsage            = req->count;
             lppe->th32ProcessID       = (DWORD)req->pid;
             lppe->th32DefaultHeapID   = 0;  /* FIXME */
@@ -277,7 +294,10 @@ static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY32 lppe, BOOL f
             lppe->pcPriClassBase      = req->priority;
             lppe->dwFlags             = -1; /* FIXME */
             lppe->szExeFile[0]        = 0;  /* FIXME */
-    return TRUE;
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -309,7 +329,7 @@ BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
  */
 static BOOL TOOLHELP_Module32Next( HANDLE handle, LPMODULEENTRY32 lpme, BOOL first )
 {
-    struct next_module_request *req = get_req_buffer();
+    BOOL ret;
 
     if (lpme->dwSize < sizeof (MODULEENTRY32))
     {
@@ -317,9 +337,13 @@ static BOOL TOOLHELP_Module32Next( HANDLE handle, LPMODULEENTRY32 lpme, BOOL fir
         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32), lpme->dwSize);
         return FALSE;
     }
+    SERVER_START_REQ
+    {
+        struct next_module_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->reset = first;
-    if (server_call( REQ_NEXT_MODULE )) return FALSE;
+        if ((ret = !server_call( REQ_NEXT_MODULE )))
+        {
             lpme->th32ModuleID   = 0;  /* toolhelp internal id, never used */
             lpme->th32ProcessID  = (DWORD)req->pid;
             lpme->GlblcntUsage   = 0; /* FIXME */
@@ -329,7 +353,10 @@ static BOOL TOOLHELP_Module32Next( HANDLE handle, LPMODULEENTRY32 lpme, BOOL fir
             lpme->hModule        = (DWORD)req->base;
             lpme->szModule[0]    = 0;  /* FIXME */
             lpme->szExePath[0]   = 0;  /* FIXME */
-    return TRUE;
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /***********************************************************************

dlls/ntdll/exception.c

@@ -86,18 +86,24 @@ static DWORD EXC_CallHandler( EXCEPTION_RECORD *record, EXCEPTION_FRAME *frame,
 
 
 /**********************************************************************
- *           EXC_SendEvent
+ *           send_debug_event
  *
  * Send an EXCEPTION_DEBUG_EVENT event to the debugger.
  */
 static inline int send_debug_event( EXCEPTION_RECORD *rec, int first_chance, CONTEXT *context )
 {
-    struct exception_event_request *req = get_req_buffer();
+    int ret;
+    SERVER_START_REQ
+    {
+        struct exception_event_request *req = server_alloc_req( sizeof(*req), 0 );
         req->record  = *rec;
         req->first   = first_chance;
         req->context = *context;
         if (!server_call_noerr( REQ_EXCEPTION_EVENT )) *context = req->context;
-    return req->status;
+        ret = req->status;
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 

dlls/ntdll/nt.c

@@ -75,10 +75,17 @@ NTSTATUS WINAPI NtQueryTimerResolution(DWORD x1,DWORD x2,DWORD x3)
 NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code )
 {
     NTSTATUS ret;
-    struct terminate_process_request *req = get_req_buffer();
+    BOOL self;
+    SERVER_START_REQ
+    {
+        struct terminate_process_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle    = handle;
         req->exit_code = exit_code;
-    if (!(ret = server_call_noerr( REQ_TERMINATE_PROCESS )) && req->self) exit( exit_code );
+        ret = server_call_noerr( REQ_TERMINATE_PROCESS );
+        self = !ret && req->self;
+    }
+    SERVER_END_REQ;
+    if (self) exit( exit_code );
     return ret;
 }
 
@@ -134,24 +141,35 @@ NTSTATUS WINAPI NtResumeThread(
 	return 0;
 }
 
+
 /******************************************************************************
  *  NtTerminateThread	[NTDLL] 
  */
-NTSTATUS WINAPI NtTerminateThread( IN HANDLE handle,
-                                   IN NTSTATUS exit_code )
+NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code )
 {
     NTSTATUS ret;
-    struct terminate_thread_request *req = get_req_buffer();
+    BOOL self, last;
+
+    SERVER_START_REQ
+    {
+        struct terminate_thread_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle    = handle;
         req->exit_code = exit_code;
-    if (!(ret = server_call_noerr( REQ_TERMINATE_THREAD )) && req->self)
+        ret = server_call_noerr( REQ_TERMINATE_THREAD );
+        self = !ret && req->self;
+        last = req->last;
+    }
+    SERVER_END_REQ;
+
+    if (self)
     {
-        if (req->last) exit( exit_code );
+        if (last) exit( exit_code );
         else SYSDEPS_ExitThread( exit_code );
     }
     return ret;
 }
 
+
 /******************************************************************************
 *  NtQueryInformationThread		[NTDLL.] 
 *

dlls/ntdll/om.c

@@ -215,9 +215,15 @@ NTSTATUS WINAPI NtDuplicateObject(
  */
 NTSTATUS WINAPI NtClose( HANDLE Handle )
 {
-    struct close_handle_request *req = get_req_buffer();
+    NTSTATUS ret;
+    SERVER_START_REQ
+    {
+        struct close_handle_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = Handle;
-    return server_call_noerr( REQ_CLOSE_HANDLE );
+        ret = server_call_noerr( REQ_CLOSE_HANDLE );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /******************************************************************************

dlls/ntdll/sync.c

@@ -16,17 +16,6 @@
 
 DEFAULT_DEBUG_CHANNEL(ntdll);
 
-/* copy a key name into the request buffer */
-static inline NTSTATUS copy_nameU( LPWSTR Dest, const OBJECT_ATTRIBUTES *attr )
-{
-    if (attr && attr->ObjectName && attr->ObjectName->Buffer)
-    {
-        if ((attr->ObjectName->Length) > MAX_PATH) return STATUS_BUFFER_OVERFLOW;
-        strcpyW( Dest, attr->ObjectName->Buffer );
-    }
-    else Dest[0] = 0;
-    return STATUS_SUCCESS;
-}
 
 /*
  *	Semaphores
@@ -35,44 +24,56 @@ static inline NTSTATUS copy_nameU( LPWSTR Dest, const OBJECT_ATTRIBUTES *attr )
 /******************************************************************************
  *  NtCreateSemaphore
  */
-NTSTATUS WINAPI NtCreateSemaphore(
-	OUT PHANDLE SemaphoreHandle,
-	IN ACCESS_MASK DesiredAccess,
-	IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+NTSTATUS WINAPI NtCreateSemaphore( OUT PHANDLE SemaphoreHandle,
+                                   IN ACCESS_MASK access,
+                                   IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
                                    IN ULONG InitialCount,
-	IN ULONG MaximumCount) 
+                                   IN ULONG MaximumCount )
 {
-    struct create_semaphore_request *req = get_req_buffer();
+    DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
     NTSTATUS ret;
 
     if ((MaximumCount <= 0) || (InitialCount < 0) || (InitialCount > MaximumCount))
         return STATUS_INVALID_PARAMETER;
 
     *SemaphoreHandle = 0;
+
+    SERVER_START_REQ
+    {
+        struct create_semaphore_request *req = server_alloc_req( sizeof(*req), len );
         req->initial = InitialCount;
         req->max     = MaximumCount;
-    req->inherit = ObjectAttributes && (ObjectAttributes->Attributes & OBJ_INHERIT);
-    if (!(ret = copy_nameU( req->name, ObjectAttributes )) &&
-        !(ret = server_call_noerr( REQ_CREATE_SEMAPHORE ))) *SemaphoreHandle = req->handle;
+        req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
+        if (len) memcpy( server_data_ptr(req), attr->ObjectName->Buffer, len );
+        if (!(ret = server_call_noerr( REQ_CREATE_SEMAPHORE )))
+            *SemaphoreHandle = req->handle;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
 /******************************************************************************
  *  NtOpenSemaphore
  */
-NTSTATUS WINAPI NtOpenSemaphore(
-	OUT PHANDLE SemaphoreHandle,
-	IN ACCESS_MASK DesiredAcces,
-	IN POBJECT_ATTRIBUTES ObjectAttributes)
+NTSTATUS WINAPI NtOpenSemaphore( OUT PHANDLE SemaphoreHandle,
+                                 IN ACCESS_MASK access,
+                                 IN const OBJECT_ATTRIBUTES *attr )
 {
-    struct open_semaphore_request *req = get_req_buffer();
+    DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
     NTSTATUS ret;
 
     *SemaphoreHandle = 0;
-    req->access  = DesiredAcces;
-    req->inherit = ObjectAttributes && (ObjectAttributes->Attributes & OBJ_INHERIT);
-    if (!(ret = copy_nameU( req->name, ObjectAttributes )) &&
-        !(ret = server_call_noerr( REQ_OPEN_SEMAPHORE ))) *SemaphoreHandle = req->handle;
+
+    SERVER_START_REQ
+    {
+        struct open_semaphore_request *req = server_alloc_req( sizeof(*req), len );
+        req->access  = access;
+        req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
+        if (len) memcpy( server_data_ptr(req), attr->ObjectName->Buffer, len );
+        if (!(ret = server_call_noerr( REQ_OPEN_SEMAPHORE )))
+            *SemaphoreHandle = req->handle;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -90,25 +91,24 @@ NTSTATUS WINAPI NtQuerySemaphore(
 	SemaphoreHandle, SemaphoreInformationClass, SemaphoreInformation, Length, ReturnLength);
 	return STATUS_SUCCESS;
 }
+
 /******************************************************************************
  *  NtReleaseSemaphore
  */
-NTSTATUS WINAPI NtReleaseSemaphore(
-	IN HANDLE SemaphoreHandle,
-	IN ULONG ReleaseCount,
-	IN PULONG PreviousCount)
+NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, PULONG previous )
 {
-    struct release_semaphore_request *req = get_req_buffer();
     NTSTATUS ret;
-
-    if (ReleaseCount < 0) return STATUS_INVALID_PARAMETER;
-
-    req->handle = SemaphoreHandle;
-    req->count  = ReleaseCount;
+    SERVER_START_REQ
+    {
+        struct release_semaphore_request *req = server_alloc_req( sizeof(*req), 0 );
+        req->handle = handle;
+        req->count  = count;
         if (!(ret = server_call_noerr( REQ_RELEASE_SEMAPHORE )))
         {
-        if (PreviousCount) *PreviousCount = req->prev_count;
+            if (previous) *previous = req->prev_count;
         }
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -122,19 +122,25 @@ NTSTATUS WINAPI NtReleaseSemaphore(
 NTSTATUS WINAPI NtCreateEvent(
 	OUT PHANDLE EventHandle,
 	IN ACCESS_MASK DesiredAccess,
-	IN POBJECT_ATTRIBUTES ObjectAttributes,
+	IN const OBJECT_ATTRIBUTES *attr,
 	IN BOOLEAN ManualReset,
 	IN BOOLEAN InitialState)
 {
-    struct create_event_request *req = get_req_buffer();
+    DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
     NTSTATUS ret;
 
     *EventHandle = 0;
+
+    SERVER_START_REQ
+    {
+        struct create_event_request *req = server_alloc_req( sizeof(*req), len );
         req->manual_reset = ManualReset;
         req->initial_state = InitialState;
-    req->inherit = ObjectAttributes && (ObjectAttributes->Attributes & OBJ_INHERIT);
-    if (!(ret = copy_nameU( req->name, ObjectAttributes )) &&
-        !(ret = server_call_noerr( REQ_CREATE_EVENT ))) *EventHandle = req->handle;
+        req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
+        if (len) memcpy( server_data_ptr(req), attr->ObjectName->Buffer, len );
+        if (!(ret = server_call_noerr( REQ_CREATE_EVENT ))) *EventHandle = req->handle;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -144,16 +150,23 @@ NTSTATUS WINAPI NtCreateEvent(
 NTSTATUS WINAPI NtOpenEvent(
 	OUT PHANDLE EventHandle,
 	IN ACCESS_MASK DesiredAccess,
-	IN POBJECT_ATTRIBUTES ObjectAttributes)
+	IN const OBJECT_ATTRIBUTES *attr )
 {
-    struct open_event_request *req = get_req_buffer();
+    DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
     NTSTATUS ret;
 
     *EventHandle = 0;
+
+    SERVER_START_REQ
+    {
+        struct open_event_request *req = server_alloc_req( sizeof(*req), len );
+
         req->access  = DesiredAccess;
-    req->inherit = ObjectAttributes && (ObjectAttributes->Attributes & OBJ_INHERIT);
-    if (!(ret = copy_nameU( req->name, ObjectAttributes )) &&
-        !(ret = server_call_noerr( REQ_OPEN_EVENT ))) *EventHandle = req->handle;
+        req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
+        if (len) memcpy( server_data_ptr(req), attr->ObjectName->Buffer, len );
+        if (!(ret = server_call_noerr( REQ_OPEN_EVENT ))) *EventHandle = req->handle;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -161,29 +174,40 @@ NTSTATUS WINAPI NtOpenEvent(
 /******************************************************************************
  *  NtSetEvent
  */
-NTSTATUS WINAPI NtSetEvent(
-	IN HANDLE EventHandle,
-	PULONG NumberOfThreadsReleased)
+NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 {
-    struct event_op_request *req = get_req_buffer();
-    FIXME("(0x%08x,%p)\n", EventHandle, NumberOfThreadsReleased);
-    req->handle = EventHandle;
+    NTSTATUS ret;
+    FIXME("(0x%08x,%p)\n", handle, NumberOfThreadsReleased);
+    SERVER_START_REQ
+    {
+        struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
+        req->handle = handle;
         req->op     = SET_EVENT;
-    return server_call_noerr( REQ_EVENT_OP );
+        ret = server_call_noerr( REQ_EVENT_OP );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /******************************************************************************
  *  NtResetEvent
  */
-NTSTATUS WINAPI NtResetEvent(
-	IN HANDLE EventHandle,
-	PULONG NumberOfThreadsReleased)
+NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 {
-    struct event_op_request *req = get_req_buffer();
-    FIXME("(0x%08x,%p)\n", EventHandle, NumberOfThreadsReleased);
-    req->handle = EventHandle;
+    NTSTATUS ret;
+
+    /* resetting an event can't release any thread... */
+    if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
+
+    SERVER_START_REQ
+    {
+        struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
+        req->handle = handle;
         req->op     = RESET_EVENT;
-    return server_call_noerr( REQ_EVENT_OP );
+        ret = server_call_noerr( REQ_EVENT_OP );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /******************************************************************************
@@ -192,10 +216,9 @@ NTSTATUS WINAPI NtResetEvent(
  * FIXME
  *   same as NtResetEvent ???
  */
-NTSTATUS WINAPI NtClearEvent (
-	IN HANDLE EventHandle)
+NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
 {
-    return NtResetEvent( EventHandle, NULL );
+    return NtResetEvent( handle, NULL );
 }
 
 /******************************************************************************
@@ -204,15 +227,19 @@ NTSTATUS WINAPI NtClearEvent (
  * FIXME
  *   PulseCount
  */
-NTSTATUS WINAPI NtPulseEvent(
-	IN HANDLE EventHandle,
-	IN PULONG PulseCount)
+NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
 {
-    struct event_op_request *req = get_req_buffer();
-    FIXME("(0x%08x,%p)\n", EventHandle, PulseCount);
-    req->handle = EventHandle;
+    NTSTATUS ret;
+    FIXME("(0x%08x,%p)\n", handle, PulseCount);
+    SERVER_START_REQ
+    {
+        struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
+        req->handle = handle;
         req->op     = PULSE_EVENT;
-    return server_call_noerr( REQ_EVENT_OP );
+        ret = server_call_noerr( REQ_EVENT_OP );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /******************************************************************************

files/change.c

@@ -28,13 +28,19 @@ DEFAULT_DEBUG_CHANNEL(file);
 HANDLE WINAPI FindFirstChangeNotificationA( LPCSTR lpPathName, BOOL bWatchSubtree,
                                             DWORD dwNotifyFilter ) 
 {
-    struct create_change_notification_request *req = get_req_buffer();
+    HANDLE ret = -1;
 
     FIXME("this is not supported yet (non-trivial).\n");
+
+    SERVER_START_REQ
+    {
+        struct create_change_notification_request *req = server_alloc_req( sizeof(*req), 0 );
         req->subtree = bWatchSubtree;
         req->filter  = dwNotifyFilter;
-    server_call( REQ_CREATE_CHANGE_NOTIFICATION );
-    return req->handle;
+        if (!server_call( REQ_CREATE_CHANGE_NOTIFICATION )) ret = req->handle;
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /****************************************************************************

files/file.c

@@ -368,14 +368,20 @@ HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
  */
 HFILE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
 {
-    struct create_device_request *req = get_req_buffer();
+    HFILE ret;
+    SERVER_START_REQ
+    {
+        struct create_device_request *req = server_alloc_req( sizeof(*req), 0 );
 
         req->access  = access;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
         req->id      = client_id;
         SetLastError(0);
         server_call( REQ_CREATE_DEVICE );
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -566,11 +572,15 @@ BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info )
 DWORD WINAPI GetFileInformationByHandle( HANDLE hFile,
                                          BY_HANDLE_FILE_INFORMATION *info )
 {
-    struct get_file_info_request *req = get_req_buffer();
-
+    DWORD ret;
     if (!info) return 0;
+
+    SERVER_START_REQ
+    {
+        struct get_file_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hFile;
-    if (server_call( REQ_GET_FILE_INFO )) return 0;
+        if ((ret = !server_call( REQ_GET_FILE_INFO )))
+        {
             RtlSecondsSince1970ToTime( req->write_time, &info->ftCreationTime );
             RtlSecondsSince1970ToTime( req->write_time, &info->ftLastWriteTime );
             RtlSecondsSince1970ToTime( req->access_time, &info->ftLastAccessTime );
@@ -581,7 +591,10 @@ DWORD WINAPI GetFileInformationByHandle( HANDLE hFile,
             info->nNumberOfLinks       = req->links;
             info->nFileIndexHigh       = req->index_high;
             info->nFileIndexLow        = req->index_low;
-    return 1;
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -1271,7 +1284,7 @@ HFILE WINAPI _lcreat( LPCSTR path, INT attr )
 DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
                              DWORD method )
 {
-    struct set_file_pointer_request *req = get_req_buffer();
+    DWORD ret = 0xffffffff;
 
     if (highword &&
         ((distance >= 0 && *highword != 0) || (distance < 0 && *highword != -1)))
@@ -1280,20 +1293,28 @@ DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
               "SetFilePointer(%08x,%08lx,%08lx,%08lx)\n",
               hFile,distance,*highword,method);
         SetLastError( ERROR_INVALID_PARAMETER );
-        return 0xffffffff;
+        return ret;
     }
     TRACE("handle %d offset %ld origin %ld\n",
           hFile, distance, method );
 
+    SERVER_START_REQ
+    {
+        struct set_file_pointer_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hFile;
         req->low = distance;
         req->high = highword ? *highword : (distance >= 0) ? 0 : -1;
         /* FIXME: assumes 1:1 mapping between Windows and Unix seek constants */
         req->whence = method;
         SetLastError( 0 );
-    if (server_call( REQ_SET_FILE_POINTER )) return 0xffffffff;
+        if (!server_call( REQ_SET_FILE_POINTER ))
+        {
+            ret = req->new_low;
             if (highword) *highword = req->new_high;
-    return req->new_low;
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -1480,9 +1501,15 @@ UINT WINAPI SetHandleCount( UINT count )
  */
 BOOL WINAPI FlushFileBuffers( HANDLE hFile )
 {
-    struct flush_file_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct flush_file_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hFile;
-    return !server_call( REQ_FLUSH_FILE );
+        ret = !server_call( REQ_FLUSH_FILE );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -1491,9 +1518,15 @@ BOOL WINAPI FlushFileBuffers( HANDLE hFile )
  */
 BOOL WINAPI SetEndOfFile( HANDLE hFile )
 {
-    struct truncate_file_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct truncate_file_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hFile;
-    return !server_call( REQ_TRUNCATE_FILE );
+        ret = !server_call( REQ_TRUNCATE_FILE );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -1645,10 +1678,15 @@ int FILE_munmap( LPVOID start, DWORD size_high, DWORD size_low )
  */
 DWORD WINAPI GetFileType( HANDLE hFile )
 {
-    struct get_file_info_request *req = get_req_buffer();
+    DWORD ret = FILE_TYPE_UNKNOWN;
+    SERVER_START_REQ
+    {
+        struct get_file_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hFile;
-    if (server_call( REQ_GET_FILE_INFO )) return FILE_TYPE_UNKNOWN;
-    return req->type;
+        if (!server_call( REQ_GET_FILE_INFO )) ret = req->type;
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -1931,8 +1969,10 @@ BOOL WINAPI SetFileTime( HANDLE hFile,
                            const FILETIME *lpLastAccessTime,
                            const FILETIME *lpLastWriteTime )
 {
-    struct set_file_time_request *req = get_req_buffer();
-
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct set_file_time_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hFile;
         if (lpLastAccessTime)
             req->access_time = DOSFS_FileTimeToUnixTime(lpLastAccessTime, NULL);
@@ -1942,7 +1982,10 @@ BOOL WINAPI SetFileTime( HANDLE hFile,
             req->write_time = DOSFS_FileTimeToUnixTime(lpLastWriteTime, NULL);
         else
             req->write_time = 0; /* FIXME */
-    return !server_call( REQ_SET_FILE_TIME );
+        ret = !server_call( REQ_SET_FILE_TIME );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -1952,14 +1995,20 @@ BOOL WINAPI SetFileTime( HANDLE hFile,
 BOOL WINAPI LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
                         DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
 {
-    struct lock_file_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct lock_file_request *req = server_alloc_req( sizeof(*req), 0 );
 
         req->handle      = hFile;
         req->offset_low  = dwFileOffsetLow;
         req->offset_high = dwFileOffsetHigh;
         req->count_low   = nNumberOfBytesToLockLow;
         req->count_high  = nNumberOfBytesToLockHigh;
-    return !server_call( REQ_LOCK_FILE );
+        ret = !server_call( REQ_LOCK_FILE );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /**************************************************************************
@@ -1999,14 +2048,20 @@ BOOL WINAPI LockFileEx( HANDLE hFile, DWORD flags, DWORD reserved,
 BOOL WINAPI UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
                           DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
 {
-    struct unlock_file_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct unlock_file_request *req = server_alloc_req( sizeof(*req), 0 );
 
         req->handle      = hFile;
         req->offset_low  = dwFileOffsetLow;
         req->offset_high = dwFileOffsetHigh;
         req->count_low   = nNumberOfBytesToUnlockLow;
         req->count_high  = nNumberOfBytesToUnlockHigh;
-    return !server_call( REQ_UNLOCK_FILE );
+        ret = !server_call( REQ_UNLOCK_FILE );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 

include/ntddk.h

@@ -910,12 +910,10 @@ NTSTATUS WINAPI NtClose(
 	HANDLE Handle);
 
 NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code );
+NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code );
 
-NTSTATUS WINAPI NtCreateSemaphore( OUT PHANDLE SemaphoreHandle,
-                                   IN ACCESS_MASK DesiredAccess,
-                                   IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
-                                   IN ULONG InitialCount,
-                                   IN ULONG MaximumCount);
+NTSTATUS WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
+NTSTATUS WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
 NTSTATUS WINAPI NtReleaseSemaphore( IN HANDLE SemaphoreHandle,
                                     IN ULONG ReleaseCount,
                                     IN PULONG PreviousCount);

include/server.h

@@ -350,8 +350,7 @@ struct get_apc_request
     REQUEST_HEADER;                /* request header */
     OUT void*        func;         /* function to call */
     OUT int          type;         /* function type */
-    OUT int          nb_args;      /* number of arguments */
-    OUT void*        args[1];      /* function arguments */
+    OUT VARARG(args,ptrs);         /* function arguments */
 };
 enum apc_type { APC_NONE, APC_USER, APC_TIMER };
 
@@ -415,11 +414,10 @@ struct open_process_request
 struct select_request
 {
     REQUEST_HEADER;                /* request header */
-    IN  int          count;        /* handles count */
     IN  int          flags;        /* wait flags (see below) */
     IN  int          timeout;      /* timeout in ms */
     OUT int          signaled;     /* signaled handle */
-    IN  int          handles[1];   /* handles to select on */
+    IN  VARARG(handles,ints);      /* handles to select on */
 };
 #define SELECT_ALL       1
 #define SELECT_ALERTABLE 2
@@ -434,7 +432,7 @@ struct create_event_request
     IN  int          initial_state; /* initial state of the event */
     IN  int          inherit;       /* inherit flag */
     OUT int          handle;        /* handle to the event */
-    IN  WCHAR        name[1];       /* event name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 /* Event operation */
@@ -454,7 +452,7 @@ struct open_event_request
     IN  unsigned int access;        /* wanted access rights */
     IN  int          inherit;       /* inherit flag */
     OUT int          handle;        /* handle to the event */
-    IN  WCHAR        name[1];       /* object name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 
@@ -465,7 +463,7 @@ struct create_mutex_request
     IN  int          owned;         /* initially owned? */
     IN  int          inherit;       /* inherit flag */
     OUT int          handle;        /* handle to the mutex */
-    IN  WCHAR        name[1];       /* mutex name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 
@@ -484,7 +482,7 @@ struct open_mutex_request
     IN  unsigned int access;        /* wanted access rights */
     IN  int          inherit;       /* inherit flag */
     OUT int          handle;        /* handle to the mutex */
-    IN  WCHAR        name[1];       /* object name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 
@@ -496,7 +494,7 @@ struct create_semaphore_request
     IN  unsigned int max;           /* maximum count */
     IN  int          inherit;       /* inherit flag */
     OUT int          handle;        /* handle to the semaphore */
-    IN  WCHAR        name[1];       /* semaphore name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 
@@ -517,7 +515,7 @@ struct open_semaphore_request
     IN  unsigned int access;        /* wanted access rights */
     IN  int          inherit;       /* inherit flag */
     OUT int          handle;        /* handle to the semaphore */
-    IN  WCHAR        name[1];       /* object name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 
@@ -835,7 +833,7 @@ struct create_mapping_request
     IN  int          inherit;       /* inherit flag */
     IN  int          file_handle;   /* file handle */
     OUT int          handle;        /* handle to the mapping */
-    IN  WCHAR        name[1];       /* object name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 /* protection flags */
 #define VPROT_READ       0x01
@@ -855,7 +853,7 @@ struct open_mapping_request
     IN  unsigned int access;        /* wanted access rights */
     IN  int          inherit;       /* inherit flag */
     OUT int          handle;        /* handle to the mapping */
-    IN  WCHAR        name[1];       /* object name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 
@@ -941,7 +939,7 @@ struct wait_debug_event_request
     IN  int           timeout;     /* timeout in ms */
     OUT void*         pid;         /* process id */
     OUT void*         tid;         /* thread id */
-    OUT debug_event_t event;       /* debug event data */
+    OUT VARARG(event,debug_event); /* debug event data */
 };
 
 
@@ -1175,7 +1173,7 @@ struct create_timer_request
     IN  int          inherit;       /* inherit flag */
     IN  int          manual;        /* manual reset */
     OUT int          handle;        /* handle to the timer */
-    IN  WCHAR        name[1];       /* timer name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 
@@ -1186,7 +1184,7 @@ struct open_timer_request
     IN  unsigned int access;        /* wanted access rights */
     IN  int          inherit;       /* inherit flag */
     OUT int          handle;        /* handle to the timer */
-    IN  WCHAR        name[1];       /* timer name */
+    IN  VARARG(name,unicode_str);   /* object name */
 };
 
 /* Set a waitable timer */
@@ -1247,7 +1245,7 @@ struct add_atom_request
     REQUEST_HEADER;                /* request header */
     IN  int           local;       /* is atom in local process table? */
     OUT int           atom;        /* resulting atom */
-    IN  WCHAR         name[1];     /* atom name */
+    IN  VARARG(name,unicode_str);  /* atom name */
 };
 
 
@@ -1266,7 +1264,7 @@ struct find_atom_request
     REQUEST_HEADER;                /* request header */
     IN  int          local;        /* is atom in local process table? */
     OUT int          atom;         /* atom handle */
-    IN  WCHAR        name[1];      /* atom name */
+    IN  VARARG(name,unicode_str);  /* atom name */
 };
 
 
@@ -1277,7 +1275,7 @@ struct get_atom_name_request
     IN  int          atom;         /* atom handle */
     IN  int          local;        /* is atom in local process table? */
     OUT int          count;        /* atom lock count */
-    OUT WCHAR        name[1];      /* atom name */
+    OUT VARARG(name,unicode_str);  /* atom name */
 };
 
 
@@ -1542,7 +1540,7 @@ union generic_request
     struct wait_input_idle_request wait_input_idle;
 };
 
-#define SERVER_PROTOCOL_VERSION 18
+#define SERVER_PROTOCOL_VERSION 19
 
 /* ### make_requests end ### */
 /* Everything above this line is generated automatically by tools/make_requests */
@@ -1621,6 +1619,12 @@ inline static void *server_data_ptr( void *req )
     return (union generic_request *)req + 1;
 }
 
+/* get the size of the variable part of the request */
+inline static size_t server_data_size( void *req )
+{
+    return ((struct request_header *)req)->var_size;
+}
+
 
 /* exception support for server calls */
 

loader/module.c

@@ -1526,12 +1526,14 @@ BOOL MODULE_FreeLibrary( WINE_MODREF *wm )
     /* Call process detach notifications */
     if ( PROCESS_Current()->free_lib_count <= 1 )
     {
-        struct unload_dll_request *req = get_req_buffer();
-
         MODULE_DllProcessDetach( FALSE, NULL );
+        SERVER_START_REQ
+        {
+            struct unload_dll_request *req = server_alloc_req( sizeof(*req), 0 );
             req->base = (void *)wm->module;
             server_call_noerr( REQ_UNLOAD_DLL );
-    
+        }
+        SERVER_END_REQ;
         MODULE_FlushModrefs();
     }
 

loader/ne/module.c

@@ -992,7 +992,6 @@ static HINSTANCE16 MODULE_LoadModule16( LPCSTR libname, BOOL implicit, BOOL lib_
  */
 HINSTANCE16 WINAPI LoadModule16( LPCSTR name, LPVOID paramBlock )
 {
-    struct new_thread_request *req = get_req_buffer();
     TEB *teb = NULL;
     BOOL lib_only = !paramBlock || (paramBlock == (LPVOID)-1);
     LOADPARAMS16 *params;
@@ -1003,7 +1002,7 @@ HINSTANCE16 WINAPI LoadModule16( LPCSTR name, LPVOID paramBlock )
     TDB *pTask;
     LPSTR cmdline;
     WORD cmdShow;
-    HANDLE hThread;
+    HANDLE hThread = -1;
     int socket;
 
     /* Load module */
@@ -1046,10 +1045,15 @@ HINSTANCE16 WINAPI LoadModule16( LPCSTR name, LPVOID paramBlock )
 
     /* Create the main thread */
 
+    SERVER_START_REQ
+    {
+        struct new_thread_request *req = server_alloc_req( sizeof(*req), 0 );
         req->suspend = 0;
         req->inherit = 0;
-    if (server_call_fd( REQ_NEW_THREAD, -1, &socket )) return 0;
-    hThread = req->handle;
+        if (!server_call_fd( REQ_NEW_THREAD, -1, &socket )) hThread = req->handle;
+    }
+    SERVER_END_REQ;
+    if (hThread == -1) return 0;
 
     if (!(teb = THREAD_Create( socket, 0, FALSE ))) goto error;
     teb->startup = NE_InitProcess;

loader/pe_image.c

@@ -23,6 +23,7 @@
  *   NE_MODULE.module32.
  */
 
+#include <sys/types.h>
 #ifdef HAVE_SYS_MMAN_H
 #include <sys/mman.h>
 #endif
@@ -682,7 +683,9 @@ WINE_MODREF *PE_CreateModule( HMODULE hModule, LPCSTR filename, DWORD flags,
 
     if (nt->FileHeader.Characteristics & IMAGE_FILE_DLL)
     {
-        struct load_dll_request *req = get_req_buffer();
+        SERVER_START_REQ
+        {
+            struct load_dll_request *req = server_alloc_req( sizeof(*req), 0 );
             req->handle     = hFile;
             req->base       = (void *)hModule;
             req->dbg_offset = nt->FileHeader.PointerToSymbolTable;
@@ -690,6 +693,8 @@ WINE_MODREF *PE_CreateModule( HMODULE hModule, LPCSTR filename, DWORD flags,
             req->name       = &wm->filename;
             server_call_noerr( REQ_LOAD_DLL );
         }
+        SERVER_END_REQ;
+    }
 
     return wm;
 }

memory/atom.c

@@ -401,9 +401,15 @@ UINT16 WINAPI GetAtomName16( ATOM atom, LPSTR buffer, INT16 count )
  */
 BOOL WINAPI InitAtomTable( DWORD entries )
 {
-    struct init_atom_table_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct init_atom_table_request *req = server_alloc_req( sizeof(*req), 0 );
         req->entries = entries;
-    return !server_call( REQ_INIT_ATOM_TABLE );
+        ret = !server_call( REQ_INIT_ATOM_TABLE );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -412,11 +418,21 @@ static ATOM ATOM_AddAtomA( LPCSTR str, BOOL local )
     ATOM atom = 0;
     if (!ATOM_IsIntAtomA( str, &atom ))
     {
-        struct add_atom_request *req = get_req_buffer();
-        server_strcpyAtoW( req->name, str );
+        DWORD len = MultiByteToWideChar( CP_ACP, 0, str, strlen(str), NULL, 0 );
+        if (len > MAX_ATOM_LEN)
+        {
+            SetLastError( ERROR_INVALID_PARAMETER );
+            return 0;
+        }
+        SERVER_START_REQ
+        {
+            struct add_atom_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
+            MultiByteToWideChar( CP_ACP, 0, str, strlen(str), server_data_ptr(req), len );
             req->local = local;
             if (!server_call( REQ_ADD_ATOM )) atom = req->atom + MIN_STR_ATOM;
         }
+        SERVER_END_REQ;
+    }
     TRACE( "(%s) %s -> %x\n", local ? "local" : "global", debugres_a(str), atom );
     return atom;
 }
@@ -458,11 +474,21 @@ static ATOM ATOM_AddAtomW( LPCWSTR str, BOOL local )
     ATOM atom = 0;
     if (!ATOM_IsIntAtomW( str, &atom ))
     {
-        struct add_atom_request *req = get_req_buffer();
-        server_strcpyW( req->name, str );
+        DWORD len = strlenW(str);
+        if (len > MAX_ATOM_LEN)
+        {
+            SetLastError( ERROR_INVALID_PARAMETER );
+            return 0;
+        }
+        SERVER_START_REQ
+        {
+            struct add_atom_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
+            memcpy( server_data_ptr(req), str, len * sizeof(WCHAR) );
             req->local = local;
             if (!server_call( REQ_ADD_ATOM )) atom = req->atom + MIN_STR_ATOM;
         }
+        SERVER_END_REQ;
+    }
     TRACE( "(%s) %s -> %x\n", local ? "local" : "global", debugres_w(str), atom );
     return atom;
 }
@@ -492,11 +518,15 @@ static ATOM ATOM_DeleteAtom( ATOM atom,  BOOL local)
     if (atom < MIN_STR_ATOM) atom = 0;
     else
     {
-        struct delete_atom_request *req = get_req_buffer();
+        SERVER_START_REQ
+        {
+            struct delete_atom_request *req = server_alloc_req( sizeof(*req), 0 );
             req->atom = atom - MIN_STR_ATOM;
             req->local = local;
             if (!server_call( REQ_DELETE_ATOM )) atom = 0;
         }
+        SERVER_END_REQ;
+    }
     return atom;
 }
 
@@ -536,10 +566,20 @@ static ATOM ATOM_FindAtomA( LPCSTR str, BOOL local )
     ATOM atom = 0;
     if (!ATOM_IsIntAtomA( str, &atom ))
     {
-        struct find_atom_request *req = get_req_buffer();
-        server_strcpyAtoW( req->name, str );
+        DWORD len = MultiByteToWideChar( CP_ACP, 0, str, strlen(str), NULL, 0 );
+        if (len > MAX_ATOM_LEN)
+        {
+            SetLastError( ERROR_INVALID_PARAMETER );
+            return 0;
+        }
+        SERVER_START_REQ
+        {
+            struct find_atom_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
+            MultiByteToWideChar( CP_ACP, 0, str, strlen(str), server_data_ptr(req), len );
             req->local = local;
-        if (!server_call( REQ_FIND_ATOM )) atom = req->atom + MIN_STR_ATOM;
+            if (!server_call( REQ_ADD_ATOM )) atom = req->atom + MIN_STR_ATOM;
+        }
+        SERVER_END_REQ;
     }
     TRACE( "(%s) %s -> %x\n", local ? "local" : "global", debugres_a(str), atom );
     return atom;
@@ -581,11 +621,21 @@ static ATOM ATOM_FindAtomW( LPCWSTR str, BOOL local )
     ATOM atom = 0;
     if (!ATOM_IsIntAtomW( str, &atom ))
     {
-        struct find_atom_request *req = get_req_buffer();
-        server_strcpyW( req->name, str );
+        DWORD len = strlenW(str);
+        if (len > MAX_ATOM_LEN)
+        {
+            SetLastError( ERROR_INVALID_PARAMETER );
+            return 0;
+        }
+        SERVER_START_REQ
+        {
+            struct find_atom_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
+            memcpy( server_data_ptr(req), str, len * sizeof(WCHAR) );
             req->local = local;
             if (!server_call( REQ_FIND_ATOM )) atom = req->atom + MIN_STR_ATOM;
         }
+        SERVER_END_REQ;
+    }
     TRACE( "(%s) %s -> %x\n", local ? "local" : "global", debugres_w(str), atom );
     return atom;
 }
@@ -612,6 +662,12 @@ ATOM WINAPI FindAtomW( LPCWSTR str )
 static UINT ATOM_GetAtomNameA( ATOM atom, LPSTR buffer, INT count, BOOL local )
 {
     INT len;
+
+    if (count <= 0)
+    {
+        SetLastError( ERROR_MORE_DATA );
+        return 0;
+    }
     if (atom < MIN_STR_ATOM)
     {
         char name[8];
@@ -625,16 +681,28 @@ static UINT ATOM_GetAtomNameA( ATOM atom, LPSTR buffer, INT count, BOOL local )
     }
     else
     {
-        struct get_atom_name_request *req = get_req_buffer();
+        len = 0;
+        SERVER_START_REQ
+        {
+            struct get_atom_name_request *req = server_alloc_req( sizeof(*req),
+                                                                  MAX_ATOM_LEN * sizeof(WCHAR) );
             req->atom = atom - MIN_STR_ATOM;
             req->local = local;
-        if (server_call( REQ_GET_ATOM_NAME )) return 0;
-        lstrcpynWtoA( buffer, req->name, count );
-        len = strlenW( req->name );
+            if (!server_call( REQ_GET_ATOM_NAME ))
+            {
+                len = WideCharToMultiByte( CP_ACP, 0, server_data_ptr(req), server_data_size(req),
+                                           buffer, count - 1, NULL, NULL );
+                if (!len) len = count; /* overflow */
+                else buffer[len] = 0;
             }
-    if (count <= len)
+        }
+        SERVER_END_REQ;
+    }
+
+    if (len && count <= len)
     {
         SetLastError( ERROR_MORE_DATA );
+        buffer[count-1] = 0;
         return 0;
     }
     TRACE( "(%s) %x -> %s\n", local ? "local" : "global", atom, debugstr_a(buffer) );
@@ -680,6 +748,12 @@ UINT WINAPI GetAtomNameA(
 static UINT ATOM_GetAtomNameW( ATOM atom, LPWSTR buffer, INT count, BOOL local )
 {
     INT len;
+
+    if (count <= 0)
+    {
+        SetLastError( ERROR_MORE_DATA );
+        return 0;
+    }
     if (atom < MIN_STR_ATOM)
     {
         char name[8];
@@ -688,17 +762,29 @@ static UINT ATOM_GetAtomNameW( ATOM atom, LPWSTR buffer, INT count, BOOL local )
             SetLastError( ERROR_INVALID_PARAMETER );
             return 0;
         }
-        len = sprintf( name, "#%d", atom );
-        lstrcpynAtoW( buffer, name, count );
+        sprintf( name, "#%d", atom );
+        len = MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, count );
+        if (!len) buffer[count-1] = 0;  /* overflow */
     }
     else
     {
-        struct get_atom_name_request *req = get_req_buffer();
+        len = 0;
+        SERVER_START_REQ
+        {
+            struct get_atom_name_request *req = server_alloc_req( sizeof(*req),
+                                                                  MAX_ATOM_LEN * sizeof(WCHAR) );
             req->atom = atom - MIN_STR_ATOM;
             req->local = local;
-        if (server_call( REQ_GET_ATOM_NAME )) return 0;
-        lstrcpynW( buffer, req->name, count );
-        len = strlenW( req->name );
+            if (!server_call( REQ_GET_ATOM_NAME ))
+            {
+                len = server_data_size(req) / sizeof(WCHAR);
+                if (count > len) count = len + 1;
+                memcpy( buffer, server_data_ptr(req), (count-1) * sizeof(WCHAR) );
+                buffer[count-1] = 0;
+            }
+        }
+        SERVER_END_REQ;
+        if (!len) return 0;
     }
     if (count <= len)
     {

memory/selector.c

@@ -606,7 +606,7 @@ void WINAPI UnMapLS( SEGPTR sptr )
 BOOL WINAPI GetThreadSelectorEntry( HANDLE hthread, DWORD sel, LPLDT_ENTRY ldtent)
 {
 #ifdef __i386__
-    struct get_selector_entry_request *req = get_req_buffer();
+    BOOL ret;
 
     if (!(sel & 4))  /* GDT selector */
     {
@@ -639,15 +639,21 @@ BOOL WINAPI GetThreadSelectorEntry( HANDLE hthread, DWORD sel, LPLDT_ENTRY ldten
         return FALSE;
     }
 
+    SERVER_START_REQ
+    {
+        struct get_selector_entry_request *req = server_alloc_req( sizeof(*req), 0 );
+
         req->handle = hthread;
         req->entry = sel >> __AHSHIFT;
-    if (server_call( REQ_GET_SELECTOR_ENTRY )) return FALSE;
-
+        if ((ret = !server_call( REQ_GET_SELECTOR_ENTRY )))
+        {
             if (!(req->flags & LDT_FLAGS_ALLOCATED))
             {
                 SetLastError( ERROR_MR_MID_NOT_FOUND );  /* sic */
-        return FALSE;
+                ret = FALSE;
             }
+            else
+            {
                 if (req->flags & LDT_FLAGS_BIG) req->limit >>= 12;
                 ldtent->BaseLow                   = req->base & 0x0000ffff;
                 ldtent->HighWord.Bits.BaseMid     = (req->base & 0x00ff0000) >> 16;
@@ -661,7 +667,11 @@ BOOL WINAPI GetThreadSelectorEntry( HANDLE hthread, DWORD sel, LPLDT_ENTRY ldten
                 ldtent->HighWord.Bits.Default_Big = (req->flags & LDT_FLAGS_32BIT) != 0;
                 ldtent->HighWord.Bits.Type        = ((req->flags & LDT_FLAGS_TYPE) << 2) | 0x10;
                 if (!(req->flags & LDT_FLAGS_READONLY)) ldtent->HighWord.Bits.Type |= 0x2;
-    return TRUE;
+            }
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
 #else
     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
     return FALSE;

memory/virtual.c

@@ -22,6 +22,7 @@
 #endif
 #include "winbase.h"
 #include "wine/exception.h"
+#include "wine/unicode.h"
 #include "winerror.h"
 #include "file.h"
 #include "process.h"
@@ -1195,14 +1196,20 @@ HANDLE WINAPI CreateFileMappingA(
                 DWORD size_low,  /* [in] Low-order 32 bits of object size */
                 LPCSTR name      /* [in] Name of file-mapping object */ )
 {
-    struct create_mapping_request *req = get_req_buffer();
+    HANDLE ret;
     BYTE vprot;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
 
     /* Check parameters */
 
     TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
           hFile, sa, protect, size_high, size_low, debugstr_a(name) );
 
+    if (len > MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
     vprot = VIRTUAL_GetProt( protect );
     if (protect & SEC_RESERVE)
     {
@@ -1218,16 +1225,23 @@ HANDLE WINAPI CreateFileMappingA(
 
     /* Create the server object */
 
+    SERVER_START_REQ
+    {
+        struct create_mapping_request *req = server_alloc_req( sizeof(*req),
+                                                               len * sizeof(WCHAR) );
         req->file_handle = hFile;
         req->size_high   = size_high;
         req->size_low    = size_low;
         req->protect     = vprot;
         req->inherit     = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         SetLastError(0);
         server_call( REQ_CREATE_MAPPING );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -1239,14 +1253,21 @@ HANDLE WINAPI CreateFileMappingW( HFILE hFile, LPSECURITY_ATTRIBUTES sa,
                                   DWORD protect, DWORD size_high,  
                                   DWORD size_low, LPCWSTR name )
 {
-    struct create_mapping_request *req = get_req_buffer();
+    HANDLE ret;
     BYTE vprot;
+    DWORD len = name ? strlenW(name) : 0;
 
     /* Check parameters */
 
     TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
           hFile, sa, protect, size_high, size_low, debugstr_w(name) );
 
+    if (len > MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+
     vprot = VIRTUAL_GetProt( protect );
     if (protect & SEC_RESERVE)
     {
@@ -1262,16 +1283,23 @@ HANDLE WINAPI CreateFileMappingW( HFILE hFile, LPSECURITY_ATTRIBUTES sa,
 
     /* Create the server object */
 
+    SERVER_START_REQ
+    {
+        struct create_mapping_request *req = server_alloc_req( sizeof(*req),
+                                                               len * sizeof(WCHAR) );
         req->file_handle = hFile;
         req->size_high   = size_high;
         req->size_low    = size_low;
         req->protect     = vprot;
         req->inherit     = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         SetLastError(0);
         server_call( REQ_CREATE_MAPPING );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -1288,14 +1316,26 @@ HANDLE WINAPI OpenFileMappingA(
                 BOOL inherit, /* [in] Inherit flag */
                 LPCSTR name )   /* [in] Name of file-mapping object */
 {
-    struct open_mapping_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
+    if (len > MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_mapping_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         server_call( REQ_OPEN_MAPPING );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -1305,14 +1345,26 @@ HANDLE WINAPI OpenFileMappingA(
  */
 HANDLE WINAPI OpenFileMappingW( DWORD access, BOOL inherit, LPCWSTR name)
 {
-    struct open_mapping_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
+    if (len > MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_mapping_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         server_call( REQ_OPEN_MAPPING );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 

misc/registry.c

@@ -1323,16 +1323,19 @@ void _w31_loadreg(void) {
 /* configure save files and start the periodic saving timer */
 static void SHELL_InitRegistrySaving( HKEY hkey_users_default )
 {
-    struct set_registry_levels_request *req = get_req_buffer();
-
     int all = PROFILE_GetWineIniBool( "registry", "SaveOnlyUpdatedKeys", 1 );
     int period = PROFILE_GetWineIniInt( "registry", "PeriodicSave", 0 );
 
     /* set saving level (0 for saving everything, 1 for saving only modified keys) */
+    SERVER_START_REQ
+    {
+        struct set_registry_levels_request *req = server_alloc_req( sizeof(*req), 0 );
         req->current = 1;
         req->saving  = !all;
         req->period  = period * 1000;
         server_call( REQ_SET_REGISTRY_LEVELS );
+    }
+    SERVER_END_REQ;
 
     if (PROFILE_GetWineIniBool("registry","WritetoHomeRegistries",1))
     {
@@ -1377,12 +1380,16 @@ static void SHELL_InitRegistrySaving( HKEY hkey_users_default )
  */
 static void SetLoadLevel(int level)
 {
-	struct set_registry_levels_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct set_registry_levels_request *req = server_alloc_req( sizeof(*req), 0 );
 
 	req->current = level;
 	req->saving  = 0;
         req->period  = 0;
 	server_call( REQ_SET_REGISTRY_LEVELS );
+    }
+    SERVER_END_REQ;
 }
 
 /**********************************************************************************

scheduler/debugger.c

@@ -26,72 +26,83 @@ DEFAULT_DEBUG_CHANNEL(debugstr);
  */
 BOOL WINAPI WaitForDebugEvent( LPDEBUG_EVENT event, DWORD timeout )
 {
-    struct wait_debug_event_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        debug_event_t *data;
+        struct wait_debug_event_request *req = server_alloc_req( sizeof(*req), sizeof(*data) );
 
         req->timeout = timeout;
-    if (server_call( REQ_WAIT_DEBUG_EVENT )) return FALSE;
-    if ((req->event.code < 0) || (req->event.code > RIP_EVENT))
-        server_protocol_error( "WaitForDebugEvent: bad code %d\n", req->event.code );
+        if (!(ret = !server_call( REQ_WAIT_DEBUG_EVENT ))) goto done;
 
-    event->dwDebugEventCode = req->event.code;
+        if (!server_data_size(req))  /* timeout */
+        {
+            SetLastError( ERROR_SEM_TIMEOUT );
+            ret = FALSE;
+            goto done;
+        }
+        data = server_data_ptr(req);
+        event->dwDebugEventCode = data->code;
         event->dwProcessId      = (DWORD)req->pid;
         event->dwThreadId       = (DWORD)req->tid;
-    switch(req->event.code)
+        switch(data->code)
         {
-    case 0:  /* timeout */
-        SetLastError( ERROR_SEM_TIMEOUT );
-        return FALSE;
         case EXCEPTION_DEBUG_EVENT:
-        event->u.Exception.ExceptionRecord = req->event.info.exception.record;
-        event->u.Exception.dwFirstChance   = req->event.info.exception.first;
+            event->u.Exception.ExceptionRecord = data->info.exception.record;
+            event->u.Exception.dwFirstChance   = data->info.exception.first;
             break;
         case CREATE_THREAD_DEBUG_EVENT:
-        event->u.CreateThread.hThread           = req->event.info.create_thread.handle;
-        event->u.CreateThread.lpThreadLocalBase = req->event.info.create_thread.teb;
-        event->u.CreateThread.lpStartAddress    = req->event.info.create_thread.start;
+            event->u.CreateThread.hThread           = data->info.create_thread.handle;
+            event->u.CreateThread.lpThreadLocalBase = data->info.create_thread.teb;
+            event->u.CreateThread.lpStartAddress    = data->info.create_thread.start;
             break;
         case CREATE_PROCESS_DEBUG_EVENT:
-        event->u.CreateProcessInfo.hFile                 = req->event.info.create_process.file;
-        event->u.CreateProcessInfo.hProcess              = req->event.info.create_process.process;
-        event->u.CreateProcessInfo.hThread               = req->event.info.create_process.thread;
-        event->u.CreateProcessInfo.lpBaseOfImage         = req->event.info.create_process.base;
-        event->u.CreateProcessInfo.dwDebugInfoFileOffset = req->event.info.create_process.dbg_offset;
-        event->u.CreateProcessInfo.nDebugInfoSize        = req->event.info.create_process.dbg_size;
-        event->u.CreateProcessInfo.lpThreadLocalBase     = req->event.info.create_process.teb;
-        event->u.CreateProcessInfo.lpStartAddress        = req->event.info.create_process.start;
-        event->u.CreateProcessInfo.lpImageName           = req->event.info.create_process.name;
-        event->u.CreateProcessInfo.fUnicode              = req->event.info.create_process.unicode;
-        if (req->event.info.create_process.file == -1) event->u.CreateProcessInfo.hFile = 0;
+            event->u.CreateProcessInfo.hFile                 = data->info.create_process.file;
+            event->u.CreateProcessInfo.hProcess              = data->info.create_process.process;
+            event->u.CreateProcessInfo.hThread               = data->info.create_process.thread;
+            event->u.CreateProcessInfo.lpBaseOfImage         = data->info.create_process.base;
+            event->u.CreateProcessInfo.dwDebugInfoFileOffset = data->info.create_process.dbg_offset;
+            event->u.CreateProcessInfo.nDebugInfoSize        = data->info.create_process.dbg_size;
+            event->u.CreateProcessInfo.lpThreadLocalBase     = data->info.create_process.teb;
+            event->u.CreateProcessInfo.lpStartAddress        = data->info.create_process.start;
+            event->u.CreateProcessInfo.lpImageName           = data->info.create_process.name;
+            event->u.CreateProcessInfo.fUnicode              = data->info.create_process.unicode;
+            if (data->info.create_process.file == -1) event->u.CreateProcessInfo.hFile = 0;
             break;
         case EXIT_THREAD_DEBUG_EVENT:
-        event->u.ExitThread.dwExitCode = req->event.info.exit.exit_code;
+            event->u.ExitThread.dwExitCode = data->info.exit.exit_code;
             break;
         case EXIT_PROCESS_DEBUG_EVENT:
-        event->u.ExitProcess.dwExitCode = req->event.info.exit.exit_code;
+            event->u.ExitProcess.dwExitCode = data->info.exit.exit_code;
             break;
         case LOAD_DLL_DEBUG_EVENT:
-        event->u.LoadDll.hFile                 = req->event.info.load_dll.handle;
-        event->u.LoadDll.lpBaseOfDll           = req->event.info.load_dll.base;
-        event->u.LoadDll.dwDebugInfoFileOffset = req->event.info.load_dll.dbg_offset;
-        event->u.LoadDll.nDebugInfoSize        = req->event.info.load_dll.dbg_size;
-        event->u.LoadDll.lpImageName           = req->event.info.load_dll.name;
-        event->u.LoadDll.fUnicode              = req->event.info.load_dll.unicode;
-        if (req->event.info.load_dll.handle == -1) event->u.LoadDll.hFile = 0;
+            event->u.LoadDll.hFile                 = data->info.load_dll.handle;
+            event->u.LoadDll.lpBaseOfDll           = data->info.load_dll.base;
+            event->u.LoadDll.dwDebugInfoFileOffset = data->info.load_dll.dbg_offset;
+            event->u.LoadDll.nDebugInfoSize        = data->info.load_dll.dbg_size;
+            event->u.LoadDll.lpImageName           = data->info.load_dll.name;
+            event->u.LoadDll.fUnicode              = data->info.load_dll.unicode;
+            if (data->info.load_dll.handle == -1) event->u.LoadDll.hFile = 0;
             break;
         case UNLOAD_DLL_DEBUG_EVENT:
-        event->u.UnloadDll.lpBaseOfDll = req->event.info.unload_dll.base;
+            event->u.UnloadDll.lpBaseOfDll = data->info.unload_dll.base;
             break;
         case OUTPUT_DEBUG_STRING_EVENT:
-        event->u.DebugString.lpDebugStringData  = req->event.info.output_string.string;
-        event->u.DebugString.fUnicode           = req->event.info.output_string.unicode;
-        event->u.DebugString.nDebugStringLength = req->event.info.output_string.length;
+            event->u.DebugString.lpDebugStringData  = data->info.output_string.string;
+            event->u.DebugString.fUnicode           = data->info.output_string.unicode;
+            event->u.DebugString.nDebugStringLength = data->info.output_string.length;
             break;
         case RIP_EVENT:
-        event->u.RipInfo.dwError = req->event.info.rip_info.error;
-        event->u.RipInfo.dwType  = req->event.info.rip_info.type;
+            event->u.RipInfo.dwError = data->info.rip_info.error;
+            event->u.RipInfo.dwType  = data->info.rip_info.type;
             break;
+        default:
+            server_protocol_error( "WaitForDebugEvent: bad code %d\n", data->code );
         }
-    return TRUE;
+    done:
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -100,11 +111,17 @@ BOOL WINAPI WaitForDebugEvent( LPDEBUG_EVENT event, DWORD timeout )
  */
 BOOL WINAPI ContinueDebugEvent( DWORD pid, DWORD tid, DWORD status )
 {
-    struct continue_debug_event_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct continue_debug_event_request *req = server_alloc_req( sizeof(*req), 0 );
         req->pid    = (void *)pid;
         req->tid    = (void *)tid;
         req->status = status;
-    return !server_call( REQ_CONTINUE_DEBUG_EVENT );
+        ret = !server_call( REQ_CONTINUE_DEBUG_EVENT );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -113,9 +130,15 @@ BOOL WINAPI ContinueDebugEvent( DWORD pid, DWORD tid, DWORD status )
  */
 BOOL WINAPI DebugActiveProcess( DWORD pid )
 {
-    struct debug_process_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct debug_process_request *req = server_alloc_req( sizeof(*req), 0 );
         req->pid = (void *)pid;
-    return !server_call( REQ_DEBUG_PROCESS );
+        ret = !server_call( REQ_DEBUG_PROCESS );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -124,11 +147,15 @@ BOOL WINAPI DebugActiveProcess( DWORD pid )
  */
 void WINAPI OutputDebugStringA( LPCSTR str )
 {
-    struct output_debug_string_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct output_debug_string_request *req = server_alloc_req( sizeof(*req), 0 );
         req->string  = (void *)str;
         req->unicode = 0;
         req->length  = strlen(str) + 1;
         server_call_noerr( REQ_OUTPUT_DEBUG_STRING );
+    }
+    SERVER_END_REQ;
     WARN("%s\n", str);
 }
 
@@ -138,11 +165,15 @@ void WINAPI OutputDebugStringA( LPCSTR str )
  */
 void WINAPI OutputDebugStringW( LPCWSTR str )
 {
-    struct output_debug_string_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct output_debug_string_request *req = server_alloc_req( sizeof(*req), 0 );
         req->string  = (void *)str;
         req->unicode = 1;
         req->length  = (lstrlenW(str) + 1) * sizeof(WCHAR);
         server_call_noerr( REQ_OUTPUT_DEBUG_STRING );
+    }
+    SERVER_END_REQ;
     WARN("%s\n", debugstr_w(str));
 }
 
@@ -189,8 +220,12 @@ void WINAPI DebugBreak16( CONTEXT86 *context )
 BOOL WINAPI IsDebuggerPresent(void)
 {
     BOOL ret = FALSE;
-    struct get_process_info_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct get_process_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = GetCurrentProcess();
         if (!server_call( REQ_GET_PROCESS_INFO )) ret = req->debugged;
+    }
+    SERVER_END_REQ;
     return ret;
 }

scheduler/event.c

@@ -7,6 +7,7 @@
 #include <assert.h>
 #include <string.h>
 #include "winerror.h"
+#include "wine/unicode.h"
 #include "syslevel.h"
 #include "server.h"
 
@@ -17,16 +18,28 @@
 HANDLE WINAPI CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
                             BOOL initial_state, LPCSTR name )
 {
-    struct create_event_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct create_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->manual_reset = manual_reset;
         req->initial_state = initial_state;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         SetLastError(0);
         server_call( REQ_CREATE_EVENT );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -36,16 +49,28 @@ HANDLE WINAPI CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
 HANDLE WINAPI CreateEventW( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
                             BOOL initial_state, LPCWSTR name )
 {
-    struct create_event_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct create_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->manual_reset = manual_reset;
         req->initial_state = initial_state;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         SetLastError(0);
         server_call( REQ_CREATE_EVENT );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 /***********************************************************************
@@ -62,14 +87,26 @@ HANDLE WINAPI WIN16_CreateEvent( BOOL manual_reset, BOOL initial_state )
  */
 HANDLE WINAPI OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
 {
-    struct open_event_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         server_call( REQ_OPEN_EVENT );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -78,14 +115,26 @@ HANDLE WINAPI OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
  */
 HANDLE WINAPI OpenEventW( DWORD access, BOOL inherit, LPCWSTR name )
 {
-    struct open_event_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         server_call( REQ_OPEN_EVENT );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -96,10 +145,16 @@ HANDLE WINAPI OpenEventW( DWORD access, BOOL inherit, LPCWSTR name )
  */
 static BOOL EVENT_Operation( HANDLE handle, enum event_op op )
 {
-    struct event_op_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->op     = op;
-    return !server_call( REQ_EVENT_OP );
+        ret = !server_call( REQ_EVENT_OP );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 

scheduler/handle.c

@@ -18,14 +18,17 @@ DEFAULT_DEBUG_CHANNEL(win32)
  */
 BOOL WINAPI CloseHandle( HANDLE handle )
 {
-    struct close_handle_request *req = get_req_buffer();
+    NTSTATUS status;
+
     /* stdio handles need special treatment */
     if ((handle == STD_INPUT_HANDLE) ||
         (handle == STD_OUTPUT_HANDLE) ||
         (handle == STD_ERROR_HANDLE))
         handle = GetStdHandle( handle );
-    req->handle = handle;
-    return !server_call( REQ_CLOSE_HANDLE );
+
+    status = NtClose( handle );
+    if (status) SetLastError( RtlNtStatusToDosError(status) );
+    return !status;
 }
 
 
@@ -34,11 +37,16 @@ BOOL WINAPI CloseHandle( HANDLE handle )
  */
 BOOL WINAPI GetHandleInformation( HANDLE handle, LPDWORD flags )
 {
-    struct get_handle_info_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct get_handle_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
-    if (server_call( REQ_GET_HANDLE_INFO )) return FALSE;
-    if (flags) *flags = req->flags;
-    return TRUE;
+        ret = !server_call( REQ_GET_HANDLE_INFO );
+        if (ret && flags) *flags = req->flags;
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -47,11 +55,17 @@ BOOL WINAPI GetHandleInformation( HANDLE handle, LPDWORD flags )
  */
 BOOL WINAPI SetHandleInformation( HANDLE handle, DWORD mask, DWORD flags )
 {
-    struct set_handle_info_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct set_handle_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->flags  = flags;
         req->mask   = mask;
-    return !server_call( REQ_SET_HANDLE_INFO );
+        ret = !server_call( REQ_SET_HANDLE_INFO );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -62,7 +76,10 @@ BOOL WINAPI DuplicateHandle( HANDLE source_process, HANDLE source,
                                HANDLE dest_process, HANDLE *dest,
                                DWORD access, BOOL inherit, DWORD options )
 {
-    struct dup_handle_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct dup_handle_request *req = server_alloc_req( sizeof(*req), 0 );
 
         req->src_process = source_process;
         req->src_handle  = source;
@@ -71,9 +88,11 @@ BOOL WINAPI DuplicateHandle( HANDLE source_process, HANDLE source,
         req->inherit     = inherit;
         req->options     = options;
 
-    if (server_call( REQ_DUP_HANDLE )) return FALSE;
-    if (dest) *dest = req->handle;
-    return TRUE;
+        ret = !server_call( REQ_DUP_HANDLE );
+        if (ret && dest) *dest = req->handle;
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -82,17 +101,10 @@ BOOL WINAPI DuplicateHandle( HANDLE source_process, HANDLE source,
  */
 HANDLE WINAPI ConvertToGlobalHandle(HANDLE hSrc)
 {
-    struct dup_handle_request *req = get_req_buffer();
-
-    req->src_process = GetCurrentProcess();
-    req->src_handle  = hSrc;
-    req->dst_process = -1;
-    req->access      = 0;
-    req->inherit     = FALSE;
-    req->options     = DUP_HANDLE_MAKE_GLOBAL | DUP_HANDLE_SAME_ACCESS | DUP_HANDLE_CLOSE_SOURCE;
-
-    server_call( REQ_DUP_HANDLE );
-    return req->handle;
+    HANDLE ret = -1;
+    DuplicateHandle( GetCurrentProcess(), hSrc, (HANDLE)-1, &ret, 0, FALSE,
+                     DUP_HANDLE_MAKE_GLOBAL | DUP_HANDLE_SAME_ACCESS | DUP_HANDLE_CLOSE_SOURCE );
+    return ret;
 }
 
 /***********************************************************************

scheduler/mutex.c

@@ -7,6 +7,7 @@
 #include <assert.h>
 #include <string.h>
 #include "winerror.h"
+#include "wine/unicode.h"
 #include "server.h"
 
 
@@ -15,15 +16,27 @@
  */
 HANDLE WINAPI CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCSTR name )
 {
-    struct create_mutex_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct create_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->owned   = owner;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         SetLastError(0);
         server_call( REQ_CREATE_MUTEX );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -32,15 +45,27 @@ HANDLE WINAPI CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCSTR name )
  */
 HANDLE WINAPI CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCWSTR name )
 {
-    struct create_mutex_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct create_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->owned   = owner;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         SetLastError(0);
         server_call( REQ_CREATE_MUTEX );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -49,14 +74,26 @@ HANDLE WINAPI CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCWSTR name )
  */
 HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
 {
-    struct open_mutex_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         server_call( REQ_OPEN_MUTEX );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -65,14 +102,26 @@ HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
  */
 HANDLE WINAPI OpenMutexW( DWORD access, BOOL inherit, LPCWSTR name )
 {
-    struct open_mutex_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         server_call( REQ_OPEN_MUTEX );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -81,7 +130,13 @@ HANDLE WINAPI OpenMutexW( DWORD access, BOOL inherit, LPCWSTR name )
  */
 BOOL WINAPI ReleaseMutex( HANDLE handle )
 {
-    struct release_mutex_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct release_mutex_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
-    return !server_call( REQ_RELEASE_MUTEX );
+        ret = !server_call( REQ_RELEASE_MUTEX );
+    }
+    SERVER_END_REQ;
+    return ret;
 }

scheduler/pipe.c

@@ -16,11 +16,18 @@
 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
                           LPSECURITY_ATTRIBUTES sa, DWORD size )
 {
-    struct create_pipe_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct create_pipe_request *req = server_alloc_req( sizeof(*req), 0 );
 
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    if (server_call( REQ_CREATE_PIPE )) return FALSE;
+        if ((ret = !server_call( REQ_CREATE_PIPE )))
+        {
             *hReadPipe  = req->handle_read;
             *hWritePipe = req->handle_write;
-    return TRUE;
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
 }

scheduler/process.c

@@ -164,7 +164,7 @@ void PROCESS_CallUserSignalProc( UINT uCode, HMODULE hModule )
  */
 static BOOL process_init( char *argv[] )
 {
-    struct init_process_request *req;
+    BOOL ret;
 
     /* store the program name */
     argv0 = argv[0];
@@ -183,11 +183,15 @@ static BOOL process_init( char *argv[] )
     if (CLIENT_InitThread()) return FALSE;
 
     /* Retrieve startup info from the server */
-    req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct init_process_request *req = server_alloc_req( sizeof(*req), 0 );
+
         req->ldt_copy  = ldt_copy;
         req->ldt_flags = ldt_flags_copy;
         req->ppid      = getppid();
-    if (server_call( REQ_INIT_PROCESS )) return FALSE;
+        if ((ret = !server_call( REQ_INIT_PROCESS )))
+        {
             main_exe_file               = req->exe_file;
             if (req->filename[0]) main_exe_name = strdup( req->filename );
             current_startupinfo.dwFlags     = req->start_flags;
@@ -195,6 +199,10 @@ static BOOL process_init( char *argv[] )
             current_envdb.hStdin   = current_startupinfo.hStdInput  = req->hstdin;
             current_envdb.hStdout  = current_startupinfo.hStdOutput = req->hstdout;
             current_envdb.hStderr  = current_startupinfo.hStdError  = req->hstderr;
+        }
+    }
+    SERVER_END_REQ;
+    if (!ret) return FALSE;
 
     /* Remember TEB selector of initial process for emergency use */
     SYSLEVEL_EmergencyTeb = NtCurrentTeb()->teb_sel;
@@ -298,7 +306,6 @@ static inline char *build_command_line( char **argv )
  */
 static void start_process(void)
 {
-    struct init_process_done_request *req = get_req_buffer();
     int debugged, console_app;
     LPTHREAD_START_ROUTINE entry;
     HMODULE module = current_process.exe_modref->module;
@@ -316,12 +323,17 @@ static void start_process(void)
     if (console_app) current_process.flags |= PDB32_CONSOLE_PROC;
 
     /* Signal the parent process to continue */
+    SERVER_START_REQ
+    {
+        struct init_process_done_request *req = server_alloc_req( sizeof(*req), 0 );
         req->module = (void *)module;
         req->entry  = entry;
         req->name   = &current_process.exe_modref->filename;
         req->gui    = !console_app;
         server_call( REQ_INIT_PROCESS_DONE );
         debugged = req->debugged;
+    }
+    SERVER_END_REQ;
 
     /* Install signal handlers; this cannot be done before, since we cannot
      * send exceptions to the debugger before the create process event that
@@ -705,13 +717,13 @@ BOOL PROCESS_Create( HFILE hFile, LPCSTR filename, LPSTR cmd_line, LPCSTR env,
                      BOOL inherit, DWORD flags, LPSTARTUPINFOA startup,
                      LPPROCESS_INFORMATION info, LPCSTR lpCurrentDirectory )
 {
+    BOOL ret;
     int pid;
     const char *unixfilename = NULL;
     const char *unixdir = NULL;
     DOS_FULL_NAME full_name;
     HANDLE load_done_evt = -1;
     struct new_process_request *req = get_req_buffer();
-    struct wait_process_request *wait_req = get_req_buffer();
 
     info->hThread = info->hProcess = INVALID_HANDLE_VALUE;
     
@@ -764,16 +776,24 @@ BOOL PROCESS_Create( HFILE hFile, LPCSTR filename, LPSTR cmd_line, LPCSTR env,
 
     pid = fork_and_exec( unixfilename, cmd_line, env ? env : GetEnvironmentStringsA(), unixdir );
 
-    wait_req->cancel   = (pid == -1);
-    wait_req->pinherit = (psa && (psa->nLength >= sizeof(*psa)) && psa->bInheritHandle);
-    wait_req->tinherit = (tsa && (tsa->nLength >= sizeof(*tsa)) && tsa->bInheritHandle);
-    wait_req->timeout  = 2000;
-    if (server_call( REQ_WAIT_PROCESS ) || (pid == -1)) goto error;
-    info->dwProcessId = (DWORD)wait_req->pid;
-    info->dwThreadId  = (DWORD)wait_req->tid;
-    info->hProcess    = wait_req->phandle;
-    info->hThread     = wait_req->thandle;
-    load_done_evt     = wait_req->event;
+    SERVER_START_REQ
+    {
+        struct wait_process_request *req = server_alloc_req( sizeof(*req), 0 );
+        req->cancel   = (pid == -1);
+        req->pinherit = (psa && (psa->nLength >= sizeof(*psa)) && psa->bInheritHandle);
+        req->tinherit = (tsa && (tsa->nLength >= sizeof(*tsa)) && tsa->bInheritHandle);
+        req->timeout  = 2000;
+        if ((ret = !server_call( REQ_WAIT_PROCESS )) && (pid != -1))
+        {
+            info->dwProcessId = (DWORD)req->pid;
+            info->dwThreadId  = (DWORD)req->tid;
+            info->hProcess    = req->phandle;
+            info->hThread     = req->thandle;
+            load_done_evt     = req->event;
+        }
+    }
+    SERVER_END_REQ;
+    if (!ret || (pid == -1)) goto error;
 
     /* Wait until process is initialized (or initialization failed) */
     if (load_done_evt != -1)
@@ -809,13 +829,16 @@ error:
  */
 void WINAPI ExitProcess( DWORD status )
 {
-    struct terminate_process_request *req = get_req_buffer();
-
     MODULE_DllProcessDetach( TRUE, (LPVOID)1 );
+    SERVER_START_REQ
+    {
+        struct terminate_process_request *req = server_alloc_req( sizeof(*req), 0 );
         /* send the exit code to the server */
         req->handle    = GetCurrentProcess();
         req->exit_code = status;
         server_call( REQ_TERMINATE_PROCESS );
+    }
+    SERVER_END_REQ;
     exit( status );
 }
 
@@ -833,12 +856,9 @@ void WINAPI ExitProcess16( WORD status )
  */
 BOOL WINAPI TerminateProcess( HANDLE handle, DWORD exit_code )
 {
-    BOOL ret;
-    struct terminate_process_request *req = get_req_buffer();
-    req->handle    = handle;
-    req->exit_code = exit_code;
-    if ((ret = !server_call( REQ_TERMINATE_PROCESS )) && req->self) exit( exit_code );
-    return ret;
+    NTSTATUS status = NtTerminateProcess( handle, exit_code );
+    if (status) SetLastError( RtlNtStatusToDosError(status) );
+    return !status;
 }
 
 
@@ -973,12 +993,16 @@ void WINAPI SetProcessDword( DWORD dwProcessID, INT offset, DWORD value )
 HANDLE WINAPI OpenProcess( DWORD access, BOOL inherit, DWORD id )
 {
     HANDLE ret = 0;
-    struct open_process_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct open_process_request *req = server_alloc_req( sizeof(*req), 0 );
 
         req->pid     = (void *)id;
         req->access  = access;
         req->inherit = inherit;
         if (!server_call( REQ_OPEN_PROCESS )) ret = req->handle;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -988,9 +1012,13 @@ HANDLE WINAPI OpenProcess( DWORD access, BOOL inherit, DWORD id )
 DWORD WINAPI MapProcessHandle( HANDLE handle )
 {
     DWORD ret = 0;
-    struct get_process_info_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct get_process_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         if (!server_call( REQ_GET_PROCESS_INFO )) ret = (DWORD)req->pid;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -999,11 +1027,17 @@ DWORD WINAPI MapProcessHandle( HANDLE handle )
  */
 BOOL WINAPI SetPriorityClass( HANDLE hprocess, DWORD priorityclass )
 {
-    struct set_process_info_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct set_process_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle   = hprocess;
         req->priority = priorityclass;
         req->mask     = SET_PROCESS_INFO_PRIORITY;
-    return !server_call( REQ_SET_PROCESS_INFO );
+        ret = !server_call( REQ_SET_PROCESS_INFO );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -1013,9 +1047,13 @@ BOOL WINAPI SetPriorityClass( HANDLE hprocess, DWORD priorityclass )
 DWORD WINAPI GetPriorityClass(HANDLE hprocess)
 {
     DWORD ret = 0;
-    struct get_process_info_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct get_process_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hprocess;
         if (!server_call( REQ_GET_PROCESS_INFO )) ret = req->priority;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -1025,11 +1063,17 @@ DWORD WINAPI GetPriorityClass(HANDLE hprocess)
  */
 BOOL WINAPI SetProcessAffinityMask( HANDLE hProcess, DWORD affmask )
 {
-    struct set_process_info_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct set_process_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle   = hProcess;
         req->affinity = affmask;
         req->mask     = SET_PROCESS_INFO_AFFINITY;
-    return !server_call( REQ_SET_PROCESS_INFO );
+        ret = !server_call( REQ_SET_PROCESS_INFO );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 /**********************************************************************
@@ -1040,7 +1084,9 @@ BOOL WINAPI GetProcessAffinityMask( HANDLE hProcess,
                                       LPDWORD lpSystemAffinityMask )
 {
     BOOL ret = FALSE;
-    struct get_process_info_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct get_process_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hProcess;
         if (!server_call( REQ_GET_PROCESS_INFO ))
         {
@@ -1048,6 +1094,8 @@ BOOL WINAPI GetProcessAffinityMask( HANDLE hProcess,
             if (lpSystemAffinityMask) *lpSystemAffinityMask = req->system_affinity;
             ret = TRUE;
         }
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -1299,14 +1347,15 @@ BOOL WINAPI GetExitCodeProcess(
     HANDLE hProcess,  /* [I] handle to the process */
     LPDWORD lpExitCode) /* [O] address to receive termination status */
 {
-    BOOL ret = FALSE;
-    struct get_process_info_request *req = get_req_buffer();
-    req->handle = hProcess;
-    if (!server_call( REQ_GET_PROCESS_INFO ))
+    BOOL ret;
+    SERVER_START_REQ
     {
-        if (lpExitCode) *lpExitCode = req->exit_code;
-        ret = TRUE;
+        struct get_process_info_request *req = server_alloc_req( sizeof(*req), 0 );
+        req->handle = hProcess;
+        ret = !server_call( REQ_GET_PROCESS_INFO );
+        if (ret && lpExitCode) *lpExitCode = req->exit_code;
     }
+    SERVER_END_REQ;
     return ret;
 }
 

scheduler/semaphore.c

@@ -7,6 +7,7 @@
 #include <assert.h>
 #include <string.h>
 #include "winerror.h"
+#include "wine/unicode.h"
 #include "server.h"
 
 
@@ -15,7 +16,8 @@
  */
 HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCSTR name )
 {
-    struct create_semaphore_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
 
     /* Check parameters */
 
@@ -24,15 +26,28 @@ HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max,
         SetLastError( ERROR_INVALID_PARAMETER );
         return 0;
     }
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+
+    SERVER_START_REQ
+    {
+        struct create_semaphore_request *req = server_alloc_req( sizeof(*req),
+                                                                 len * sizeof(WCHAR) );
 
         req->initial = (unsigned int)initial;
         req->max     = (unsigned int)max;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         SetLastError(0);
         server_call( REQ_CREATE_SEMAPHORE );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -42,7 +57,8 @@ HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max,
 HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
                                     LONG max, LPCWSTR name )
 {
-    struct create_semaphore_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
 
     /* Check parameters */
 
@@ -51,15 +67,28 @@ HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
         SetLastError( ERROR_INVALID_PARAMETER );
         return 0;
     }
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+
+    SERVER_START_REQ
+    {
+        struct create_semaphore_request *req = server_alloc_req( sizeof(*req),
+                                                                 len * sizeof(WCHAR) );
 
         req->initial = (unsigned int)initial;
         req->max     = (unsigned int)max;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         SetLastError(0);
         server_call( REQ_CREATE_SEMAPHORE );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -68,14 +97,26 @@ HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
  */
 HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
 {
-    struct open_semaphore_request *req = get_req_buffer();
-
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_semaphore_request *req = server_alloc_req( sizeof(*req),
+                                                               len * sizeof(WCHAR) );
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         server_call( REQ_OPEN_SEMAPHORE );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -84,14 +125,25 @@ HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
  */
 HANDLE WINAPI OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
 {
-    struct open_semaphore_request *req = get_req_buffer();
-
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_semaphore_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         server_call( REQ_OPEN_SEMAPHORE );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -100,20 +152,7 @@ HANDLE WINAPI OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
  */
 BOOL WINAPI ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
 {
-    BOOL ret = FALSE;
-    struct release_semaphore_request *req = get_req_buffer();
-
-    if (count < 0)
-    {
-        SetLastError( ERROR_INVALID_PARAMETER );
-        return FALSE;
-    }
-    req->handle = handle;
-    req->count  = (unsigned int)count;
-    if (!server_call( REQ_RELEASE_SEMAPHORE ))
-    {
-        if (previous) *previous = req->prev_count;
-        ret = TRUE;
-    }
-    return ret;
+    NTSTATUS status = NtReleaseSemaphore( handle, count, previous );
+    if (status) SetLastError( RtlNtStatusToDosError(status) );
+    return !status;
 }

scheduler/synchro.c

@@ -23,33 +23,39 @@
  */
 static void call_apcs(void)
 {
-    FARPROC proc;
-    struct get_apc_request *req = get_req_buffer();
+    FARPROC proc = NULL;
+    FILETIME ft;
+    void *args[4];
 
     for (;;)
     {
-        if (server_call( REQ_GET_APC )) return;
-        switch(req->type)
+        int type = APC_NONE;
+        SERVER_START_REQ
+        {
+            struct get_apc_request *req = server_alloc_req( sizeof(*req), sizeof(args) );
+            if (!server_call( REQ_GET_APC ))
+            {
+                type = req->type;
+                proc = req->func;
+                memcpy( args, server_data_ptr(req), server_data_size(req) );
+            }
+        }
+        SERVER_END_REQ;
+
+        switch(type)
         {
         case APC_NONE:
             return;  /* no more APCs */
         case APC_USER:
-            if ((proc = req->func))
-            {
-                proc( req->args[0] );
-            }
+            proc( args[0] );
             break;
         case APC_TIMER:
-            if ((proc = req->func))
-            {
-                FILETIME ft;
             /* convert sec/usec to NT time */
-                DOSFS_UnixTimeToFileTime( (time_t)req->args[0], &ft, (DWORD)req->args[1] * 10 );
-                proc( req->args[2], ft.dwLowDateTime, ft.dwHighDateTime );
-            }
+            DOSFS_UnixTimeToFileTime( (time_t)args[0], &ft, (DWORD)args[1] * 10 );
+            proc( args[2], ft.dwLowDateTime, ft.dwHighDateTime );
             break;
         default:
-            server_protocol_error( "get_apc_request: bad type %d\n", req->type );
+            server_protocol_error( "get_apc_request: bad type %d\n", type );
             break;
         }
     }
@@ -110,7 +116,6 @@ DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
                                        BOOL wait_all, DWORD timeout,
                                        BOOL alertable )
 {
-    struct select_request *req = get_req_buffer();
     int i, ret;
 
     if (count > MAXIMUM_WAIT_OBJECTS)
@@ -119,17 +124,24 @@ DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
         return WAIT_FAILED;
     }
 
-    req->count   = count;
+    SERVER_START_REQ
+    {
+        struct select_request *req = server_alloc_req( sizeof(*req), count * sizeof(int) );
+        int *data = server_data_ptr( req );
+
         req->flags   = 0;
         req->timeout = timeout;
-    for (i = 0; i < count; i++) req->handles[i] = handles[i];
+        for (i = 0; i < count; i++) data[i] = handles[i];
 
         if (wait_all) req->flags |= SELECT_ALL;
         if (alertable) req->flags |= SELECT_ALERTABLE;
         if (timeout != INFINITE) req->flags |= SELECT_TIMEOUT;
 
         server_call( REQ_SELECT );
-    if ((ret = req->signaled) == STATUS_USER_APC) call_apcs();
+        ret = req->signaled;
+    }
+    SERVER_END_REQ;
+    if (ret == STATUS_USER_APC) call_apcs();
     return ret;
 }
 

scheduler/thread.c

@@ -50,13 +50,21 @@ BOOL THREAD_IsWin16( TEB *teb )
  */
 TEB *THREAD_IdToTEB( DWORD id )
 {
-    struct get_thread_info_request *req = get_req_buffer();
+    TEB *ret = NULL;
 
     if (!id || id == GetCurrentThreadId()) return NtCurrentTeb();
+
+    SERVER_START_REQ
+    {
+        struct get_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = -1;
         req->tid_in = (void *)id;
-    if (!server_call_noerr( REQ_GET_THREAD_INFO )) return req->teb;
+        if (!server_call_noerr( REQ_GET_THREAD_INFO )) ret = req->teb;
+    }
+    SERVER_END_REQ;
 
+    if (!ret)
+    {
         /* Allow task handles to be used; convert to main thread */
         if ( IsTask16( id ) )
         {
@@ -64,7 +72,8 @@ TEB *THREAD_IdToTEB( DWORD id )
             if (pTask) return pTask->teb;
         }
         SetLastError( ERROR_INVALID_PARAMETER );
-    return NULL;
+    }
+    return ret;
 }
 
 
@@ -272,16 +281,24 @@ HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
                             LPTHREAD_START_ROUTINE start, LPVOID param,
                             DWORD flags, LPDWORD id )
 {
-    struct new_thread_request *req = get_req_buffer();
     int socket, handle = -1;
     TEB *teb;
-    void *tid;
+    void *tid = 0;
+
+    SERVER_START_REQ
+    {
+        struct new_thread_request *req = server_alloc_req( sizeof(*req), 0 );
 
         req->suspend = ((flags & CREATE_SUSPENDED) != 0);
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    if (server_call_fd( REQ_NEW_THREAD, -1, &socket )) return 0;
+        if (!server_call_fd( REQ_NEW_THREAD, -1, &socket ))
+        {
             handle = req->handle;
             tid = req->tid;
+        }
+    }
+    SERVER_END_REQ;
+    if (handle == -1) return 0;
 
     if (!(teb = THREAD_Create( socket, stack, TRUE )))
     {
@@ -297,6 +314,7 @@ HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
     if (SYSDEPS_SpawnThread( teb ) == -1)
     {
         CloseHandle( handle );
+        THREAD_FreeTEB( teb );
         return 0;
     }
     return handle;
@@ -335,13 +353,20 @@ HANDLE WINAPI CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
  */
 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
 {
-    struct terminate_thread_request *req = get_req_buffer();
+    BOOL last;
+    SERVER_START_REQ
+    {
+        struct terminate_thread_request *req = server_alloc_req( sizeof(*req), 0 );
 
         /* send the exit code to the server */
         req->handle    = GetCurrentThread();
         req->exit_code = code;
         server_call( REQ_TERMINATE_THREAD );
-    if (req->last)
+        last = req->last;
+    }
+    SERVER_END_REQ;
+
+    if (last)
     {
         MODULE_DllProcessDetach( TRUE, (LPVOID)1 );
         exit( code );
@@ -474,11 +499,17 @@ BOOL WINAPI TlsSetValue(
 BOOL WINAPI SetThreadContext( HANDLE handle,           /* [in]  Handle to thread with context */
                               const CONTEXT *context ) /* [in] Address of context structure */
 {
-    struct set_thread_context_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct set_thread_context_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->flags = context->ContextFlags;
         memcpy( &req->context, context, sizeof(*context) );
-    return !server_call( REQ_SET_THREAD_CONTEXT );
+        ret = !server_call( REQ_SET_THREAD_CONTEXT );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -492,13 +523,18 @@ BOOL WINAPI SetThreadContext( HANDLE handle,           /* [in]  Handle to thread
 BOOL WINAPI GetThreadContext( HANDLE handle,     /* [in]  Handle to thread with context */
                               CONTEXT *context ) /* [out] Address of context structure */
 {
-    struct get_thread_context_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct get_thread_context_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->flags = context->ContextFlags;
         memcpy( &req->context, context, sizeof(*context) );
-    if (server_call( REQ_GET_THREAD_CONTEXT )) return FALSE;
+        if ((ret = !server_call( REQ_GET_THREAD_CONTEXT )))
             memcpy( context, &req->context, sizeof(*context) );
-    return TRUE;
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -513,10 +549,14 @@ INT WINAPI GetThreadPriority(
     HANDLE hthread) /* [in] Handle to thread */
 {
     INT ret = THREAD_PRIORITY_ERROR_RETURN;
-    struct get_thread_info_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct get_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hthread;
         req->tid_in = 0;
         if (!server_call( REQ_GET_THREAD_INFO )) ret = req->priority;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -532,11 +572,17 @@ BOOL WINAPI SetThreadPriority(
     HANDLE hthread, /* [in] Handle to thread */
     INT priority)   /* [in] Thread priority level */
 {
-    struct set_thread_info_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct set_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle   = hthread;
         req->priority = priority;
         req->mask     = SET_THREAD_INFO_PRIORITY;
-    return !server_call( REQ_SET_THREAD_INFO );
+        ret = !server_call( REQ_SET_THREAD_INFO );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -581,12 +627,18 @@ BOOL WINAPI SetThreadPriorityBoost(
  */
 DWORD WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD dwThreadAffinityMask )
 {
-    struct set_thread_info_request *req = get_req_buffer();
+    DWORD ret;
+    SERVER_START_REQ
+    {
+        struct set_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle   = hThread;
         req->affinity = dwThreadAffinityMask;
         req->mask     = SET_THREAD_INFO_AFFINITY;
-    if (server_call( REQ_SET_THREAD_INFO )) return 0;
-    return 1;  /* FIXME: should return previous value */
+        ret = !server_call( REQ_SET_THREAD_INFO );
+        /* FIXME: should return previous value */
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -597,21 +649,12 @@ DWORD WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD dwThreadAffinityMask )
  *    Success: TRUE
  *    Failure: FALSE
  */
-BOOL WINAPI TerminateThread(
-    HANDLE handle, /* [in] Handle to thread */
-    DWORD exitcode)  /* [in] Exit code for thread */
+BOOL WINAPI TerminateThread( HANDLE handle,    /* [in] Handle to thread */
+                             DWORD exit_code)  /* [in] Exit code for thread */
 {
-    BOOL ret;
-    struct terminate_thread_request *req = get_req_buffer();
-    req->handle    = handle;
-    req->exit_code = exitcode;
-    if ((ret = !server_call( REQ_TERMINATE_THREAD )) && req->self)
-    {
-        PROCESS_CallUserSignalProc( USIG_THREAD_EXIT, 0 );
-        if (req->last) exit( exitcode );
-        else SYSDEPS_ExitThread( exitcode );
-    }
-    return ret;
+    NTSTATUS status = NtTerminateThread( handle, exit_code );
+    if (status) SetLastError( RtlNtStatusToDosError(status) );
+    return !status;
 }
 
 
@@ -626,15 +669,16 @@ BOOL WINAPI GetExitCodeThread(
     HANDLE hthread, /* [in]  Handle to thread */
     LPDWORD exitcode) /* [out] Address to receive termination status */
 {
-    BOOL ret = FALSE;
-    struct get_thread_info_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct get_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hthread;
         req->tid_in = 0;
-    if (!server_call( REQ_GET_THREAD_INFO ))
-    {
-        if (exitcode) *exitcode = req->exit_code;
-        ret = TRUE;
+        ret = !server_call( REQ_GET_THREAD_INFO );
+        if (ret && exitcode) *exitcode = req->exit_code;
     }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -654,9 +698,13 @@ DWORD WINAPI ResumeThread(
     HANDLE hthread) /* [in] Identifies thread to restart */
 {
     DWORD ret = 0xffffffff;
-    struct resume_thread_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct resume_thread_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hthread;
         if (!server_call( REQ_RESUME_THREAD )) ret = req->count;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -672,9 +720,13 @@ DWORD WINAPI SuspendThread(
     HANDLE hthread) /* [in] Handle to the thread */
 {
     DWORD ret = 0xffffffff;
-    struct suspend_thread_request *req = get_req_buffer();
+    SERVER_START_REQ
+    {
+        struct suspend_thread_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hthread;
         if (!server_call( REQ_SUSPEND_THREAD )) ret = req->count;
+    }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -684,11 +736,17 @@ DWORD WINAPI SuspendThread(
  */
 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
 {
-    struct queue_apc_request *req = get_req_buffer();
+    DWORD ret;
+    SERVER_START_REQ
+    {
+        struct queue_apc_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hthread;
         req->func   = func;
         req->param  = (void *)data;
-    return !server_call( REQ_QUEUE_APC );
+        ret = !server_call( REQ_QUEUE_APC );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 

scheduler/timer.c

@@ -7,6 +7,7 @@
 #include <assert.h>
 #include <string.h>
 #include "winerror.h"
+#include "wine/unicode.h"
 #include "file.h"  /* for FILETIME routines */
 #include "server.h"
 
@@ -16,15 +17,27 @@
  */
 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
 {
-    struct create_timer_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct create_timer_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->manual  = manual;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         SetLastError(0);
         server_call( REQ_CREATE_TIMER );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -33,15 +46,27 @@ HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR
  */
 HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWSTR name )
 {
-    struct create_timer_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct create_timer_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->manual  = manual;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         SetLastError(0);
         server_call( REQ_CREATE_TIMER );
-    if (req->handle == -1) return 0;
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -50,14 +75,26 @@ HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWST
  */
 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
 {
-    struct open_timer_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? MultiByteToWideChar( CP_ACP, 0, name, strlen(name), NULL, 0 ) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_timer_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyAtoW( req->name, name );
+        if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         server_call( REQ_OPEN_TIMER );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -66,14 +103,26 @@ HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
  */
 HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
 {
-    struct open_timer_request *req = get_req_buffer();
+    HANDLE ret;
+    DWORD len = name ? strlenW(name) : 0;
+    if (len >= MAX_PATH)
+    {
+        SetLastError( ERROR_FILENAME_EXCED_RANGE );
+        return 0;
+    }
+    SERVER_START_REQ
+    {
+        struct open_timer_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
 
         req->access  = access;
         req->inherit = inherit;
-    server_strcpyW( req->name, name );
+        memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         server_call( REQ_OPEN_TIMER );
-    if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
-    return req->handle;
+        ret = req->handle;
+    }
+    SERVER_END_REQ;
+    if (ret == -1) ret = 0; /* must return 0 on failure, not -1 */
+    return ret;
 }
 
 
@@ -83,9 +132,9 @@ HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
 BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG period,
                               PTIMERAPCROUTINE callback, LPVOID arg, BOOL resume )
 {
+    BOOL ret;
     FILETIME ft;
     DWORD remainder;
-    struct set_timer_request *req = get_req_buffer();
 
     if (when->s.HighPart < 0)  /* relative time */
     {
@@ -102,6 +151,10 @@ BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG per
         ft.dwHighDateTime = when->s.HighPart;
     }
 
+    SERVER_START_REQ
+    {
+        struct set_timer_request *req = server_alloc_req( sizeof(*req), 0 );
+
         if (!ft.dwLowDateTime && !ft.dwHighDateTime)
         {
             /* special case to start timeout on now+period without too many calculations */
@@ -118,7 +171,10 @@ BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG per
         req->callback = callback;
         req->arg      = arg;
         if (resume) SetLastError( ERROR_NOT_SUPPORTED ); /* set error but can still succeed */
-    return !server_call( REQ_SET_TIMER );
+        ret = !server_call( REQ_SET_TIMER );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 
@@ -127,7 +183,13 @@ BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG per
  */
 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
 {
-    struct cancel_timer_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct cancel_timer_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
-    return !server_call( REQ_CANCEL_TIMER );
+        ret = !server_call( REQ_CANCEL_TIMER );
+    }
+    SERVER_END_REQ;
+    return ret;
 }

server/atom.c

@@ -65,13 +65,17 @@ static struct atom_table *global_table;
 
 
 /* copy an atom name to a temporary area */
-static const WCHAR *copy_name( const WCHAR *str )
+static const WCHAR *copy_name( const WCHAR *str, size_t len )
 {
     static WCHAR buffer[MAX_ATOM_LEN+1];
-    WCHAR *p = buffer;
 
-    while (p < buffer + sizeof(buffer) - 1) if (!(*p++ = *str++)) break;
-    *p = 0;
+    if (len > MAX_ATOM_LEN*sizeof(WCHAR))
+    {
+        set_error( STATUS_INVALID_PARAMETER );
+        return NULL;
+    }
+    memcpy( buffer, str, len );
+    buffer[len / sizeof(WCHAR)] = 0;
     return buffer;
 }
 
@@ -261,16 +265,24 @@ static int find_atom( struct atom_table *table, const WCHAR *str )
 }
 
 /* get an atom name and refcount*/
-static int get_atom_name( struct atom_table *table, int atom, WCHAR *str )
+static size_t get_atom_name( struct atom_table *table, int atom,
+                             WCHAR *str, size_t maxsize, int *count )
 {
-    int count = -1;
+    int len = 0;
     struct atom_entry *entry = get_atom_entry( table, atom );
+    *count = -1;
     if (entry)
     {
-        strcpyW( str, entry->str );
-        count = entry->count;
+        *count = entry->count;
+        len = strlenW( entry->str ) * sizeof(WCHAR);
+        if (len <= maxsize) memcpy( str, entry->str, len );
+        else
+        {
+            set_error( STATUS_BUFFER_OVERFLOW );
+            len = 0;
         }
-    return count;
+    }
+    return len;
 }
 
 /* add a global atom */
@@ -279,29 +291,34 @@ DECL_HANDLER(add_atom)
     struct atom_table **table_ptr = req->local ? &current->process->atom_table : &global_table;
 
     if (!*table_ptr) *table_ptr = create_table(0);
-    if (*table_ptr) req->atom = add_atom( *table_ptr, copy_name( req->name ) );
+    if (*table_ptr)
+    {
+        const WCHAR *name = copy_name( get_req_data(req), get_req_data_size(req) );
+        if (name) req->atom = add_atom( *table_ptr, name );
+    }
 }
 
 /* delete a global atom */
 DECL_HANDLER(delete_atom)
 {
-    delete_atom( req->local ? current->process->atom_table : global_table,
-                 req->atom );
+    delete_atom( req->local ? current->process->atom_table : global_table, req->atom );
 }
 
 /* find a global atom */
 DECL_HANDLER(find_atom)
 {
-    req->atom = find_atom( req->local ? current->process->atom_table : global_table,
-                           copy_name( req->name ) );
+    const WCHAR *name = copy_name( get_req_data(req), get_req_data_size(req) );
+    if (name)
+        req->atom = find_atom( req->local ? current->process->atom_table : global_table, name );
 }
 
 /* get global atom name */
 DECL_HANDLER(get_atom_name)
 {
-    req->name[0] = 0;
-    req->count = get_atom_name( req->local ? current->process->atom_table : global_table,
-                                req->atom, req->name );
+    WCHAR *name = get_req_data(req);
+    size_t size = get_atom_name( req->local ? current->process->atom_table : global_table,
+                                 req->atom, name, get_req_data_size(req), &req->count );
+    set_req_data_size( req, size );
 }
 
 /* init the process atom table */

server/debugger.c

@@ -254,6 +254,7 @@ static void build_wait_debug_reply( struct thread *thread, struct object *obj, i
     {
         struct debug_ctx *debug_ctx = (struct debug_ctx *)obj; 
         struct debug_event *event = find_event_to_send( debug_ctx );
+        size_t size = get_req_data_size(req);
 
         /* the object that woke us has to be our debug context */
         assert( obj->ops == &debug_ctx_ops );
@@ -261,14 +262,15 @@ static void build_wait_debug_reply( struct thread *thread, struct object *obj, i
 
         event->state = EVENT_SENT;
         event->sender->debug_event = event;
-        req->event.code = event->data.code;
         req->pid = event->sender->process;
         req->tid = event->sender;
-        memcpy( &req->event, &event->data, sizeof(req->event) );
+        if (size > sizeof(debug_event_t)) size = sizeof(debug_event_t);
+        memcpy( get_req_data(req), &event->data, size );
+        set_req_data_size( req, size );
     }
     else  /* timeout or error */
     {
-        req->event.code = 0;
+        set_req_data_size( req, 0 );
         req->pid  = 0;
         req->tid  = 0;
     }
@@ -536,9 +538,9 @@ DECL_HANDLER(wait_debug_event)
 {
     if (!wait_for_debug_event( req->timeout ))
     {
-        req->event.code = 0;
         req->pid = NULL;
         req->tid = NULL;
+        set_req_data_size( req, 0 );
     }
 }
 

server/event.c

@@ -114,11 +114,11 @@ static int event_satisfied( struct object *obj, struct thread *thread )
 /* create an event */
 DECL_HANDLER(create_event)
 {
-    size_t len = get_req_strlenW( req, req->name );
     struct event *event;
 
     req->handle = -1;
-    if ((event = create_event( req->name, len, req->manual_reset, req->initial_state )))
+    if ((event = create_event( get_req_data(req), get_req_data_size(req),
+                               req->manual_reset, req->initial_state )))
     {
         req->handle = alloc_handle( current->process, event, EVENT_ALL_ACCESS, req->inherit );
         release_object( event );
@@ -128,8 +128,8 @@ DECL_HANDLER(create_event)
 /* open a handle to an event */
 DECL_HANDLER(open_event)
 {
-    size_t len = get_req_strlenW( req, req->name );
-    req->handle = open_object( req->name, len, &event_ops, req->access, req->inherit );
+    req->handle = open_object( get_req_data(req), get_req_data_size(req),
+                               &event_ops, req->access, req->inherit );
 }
 
 /* do an event operation */

server/mapping.c

@@ -281,12 +281,12 @@ int get_page_size(void)
 /* create a file mapping */
 DECL_HANDLER(create_mapping)
 {
-    size_t len = get_req_strlenW( req, req->name );
     struct object *obj;
 
     req->handle = -1;
     if ((obj = create_mapping( req->size_high, req->size_low,
-                               req->protect, req->file_handle, req->name, len )))
+                               req->protect, req->file_handle,
+                               get_req_data(req), get_req_data_size(req) )))
     {
         int access = FILE_MAP_ALL_ACCESS;
         if (!(req->protect & VPROT_WRITE)) access &= ~FILE_MAP_WRITE;
@@ -298,8 +298,8 @@ DECL_HANDLER(create_mapping)
 /* open a handle to a mapping */
 DECL_HANDLER(open_mapping)
 {
-    size_t len = get_req_strlenW( req, req->name );
-    req->handle = open_object( req->name, len, &mapping_ops, req->access, req->inherit );
+    req->handle = open_object( get_req_data(req), get_req_data_size(req),
+                               &mapping_ops, req->access, req->inherit );
 }
 
 /* get a mapping information */

server/mutex.c

@@ -139,11 +139,10 @@ static void mutex_destroy( struct object *obj )
 /* create a mutex */
 DECL_HANDLER(create_mutex)
 {
-    size_t len = get_req_strlenW( req, req->name );
     struct mutex *mutex;
 
     req->handle = -1;
-    if ((mutex = create_mutex( req->name, len, req->owned )))
+    if ((mutex = create_mutex( get_req_data(req), get_req_data_size(req), req->owned )))
     {
         req->handle = alloc_handle( current->process, mutex, MUTEX_ALL_ACCESS, req->inherit );
         release_object( mutex );
@@ -153,8 +152,8 @@ DECL_HANDLER(create_mutex)
 /* open a handle to a mutex */
 DECL_HANDLER(open_mutex)
 {
-    size_t len = get_req_strlenW( req, req->name );
-    req->handle = open_object( req->name, len, &mutex_ops, req->access, req->inherit );
+    req->handle = open_object( get_req_data(req), get_req_data_size(req),
+                               &mutex_ops, req->access, req->inherit );
 }
 
 /* release a mutex */

server/object.c

@@ -70,6 +70,7 @@ void *memdup( const void *data, size_t len )
 static int get_name_hash( const WCHAR *name, size_t len )
 {
     WCHAR hash = 0;
+    len /= sizeof(WCHAR);
     while (len--) hash ^= *name++;
     return hash % NAME_HASH_SIZE;
 }
@@ -79,11 +80,10 @@ static struct object_name *alloc_name( const WCHAR *name, size_t len )
 {
     struct object_name *ptr;
 
-    if ((ptr = mem_alloc( sizeof(*ptr) + len * sizeof(ptr->name[0]) )))
+    if ((ptr = mem_alloc( sizeof(*ptr) + len - sizeof(ptr->name) )))
     {
         ptr->len = len;
-        memcpy( ptr->name, name, len * sizeof(ptr->name[0]) );
-        ptr->name[len] = 0;
+        memcpy( ptr->name, name, len );
     }
     return ptr;
 }
@@ -186,7 +186,7 @@ void dump_object_name( struct object *obj )
     else
     {
         fprintf( stderr, "name=L\"" );
-        dump_strW( obj->name->name, strlenW(obj->name->name), stderr, "\"\"" );
+        dump_strW( obj->name->name, obj->name->len/sizeof(WCHAR), stderr, "\"\"" );
         fputc( '\"', stderr );
     }
 }
@@ -228,11 +228,12 @@ void release_object( void *ptr )
 struct object *find_object( const WCHAR *name, size_t len )
 {
     struct object_name *ptr;
+
     if (!name || !len) return NULL;
     for (ptr = names[ get_name_hash( name, len ) ]; ptr; ptr = ptr->next)
     {
         if (ptr->len != len) continue;
-        if (!memcmp( ptr->name, name, len*sizeof(WCHAR) )) return grab_object( ptr->obj );
+        if (!memcmp( ptr->name, name, len )) return grab_object( ptr->obj );
     }
     return NULL;
 }

server/request.h

@@ -54,6 +54,18 @@ inline static void *get_req_data( const void *req )
     return ((union generic_request *)req + 1);
 }
 
+/* get the request vararg size */
+inline static size_t get_req_data_size( const void *req )
+{
+    return ((struct request_header *)req)->var_size;
+}
+
+/* set the request vararg size */
+inline static void set_req_data_size( const void *req, size_t size )
+{
+    ((struct request_header *)req)->var_size = size;
+}
+
 
 #define REQUEST_END(req) ((char *)(req) + MAX_REQUEST_LENGTH - sizeof(struct server_buffer_info))
 

server/semaphore.c

@@ -122,11 +122,11 @@ static int semaphore_satisfied( struct object *obj, struct thread *thread )
 /* create a semaphore */
 DECL_HANDLER(create_semaphore)
 {
-    size_t len = get_req_strlenW( req, req->name );
     struct semaphore *sem;
 
     req->handle = -1;
-    if ((sem = create_semaphore( req->name, len, req->initial, req->max )))
+    if ((sem = create_semaphore( get_req_data(req), get_req_data_size(req),
+                                 req->initial, req->max )))
     {
         req->handle = alloc_handle( current->process, sem, SEMAPHORE_ALL_ACCESS, req->inherit );
         release_object( sem );
@@ -136,8 +136,8 @@ DECL_HANDLER(create_semaphore)
 /* open a handle to a semaphore */
 DECL_HANDLER(open_semaphore)
 {
-    size_t len = get_req_strlenW( req, req->name );
-    req->handle = open_object( req->name, len, &semaphore_ops, req->access, req->inherit );
+    req->handle = open_object( get_req_data(req), get_req_data_size(req),
+                               &semaphore_ops, req->access, req->inherit );
 }
 
 /* release a semaphore */

server/thread.c

@@ -787,7 +787,8 @@ DECL_HANDLER(resume_thread)
 /* select on a handle list */
 DECL_HANDLER(select)
 {
-    if (!select_on( req->count, req->handles, req->flags, req->timeout ))
+    int count = get_req_data_size(req) / sizeof(int);
+    if (!select_on( count, get_req_data(req), req->flags, req->timeout ))
         req->signaled = -1;
 }
 
@@ -806,21 +807,31 @@ DECL_HANDLER(queue_apc)
 DECL_HANDLER(get_apc)
 {
     struct thread_apc *apc;
+    size_t size;
 
-    if ((apc = thread_dequeue_apc( current )))
+    for (;;)
     {
-        req->func    = apc->func;
-        req->type    = apc->type;
-        req->nb_args = apc->nb_args;
-        memcpy( req->args, apc->args, apc->nb_args * sizeof(req->args[0]) );
-        free( apc );
-    }
-    else
+        if (!(apc = thread_dequeue_apc( current )))
         {
+            /* no more APCs */
             req->func    = NULL;
             req->type    = APC_NONE;
-        req->nb_args = 0;
+            set_req_data_size( req, 0 );
+            return;
         }
+        /* Optimization: ignore APCs that have a NULL func; they are only used
+         * to wake up a thread, but since we got here the thread woke up already.
+         */
+        if (apc->func) break;
+        free( apc );
+    }
+    size = apc->nb_args * sizeof(apc->args[0]);
+    if (size > get_req_data_size(req)) size = get_req_data_size(req);
+    req->func = apc->func;
+    req->type = apc->type;
+    memcpy( get_req_data(req), apc->args, size );
+    set_req_data_size( req, size );
+    free( apc );
 }
 
 /* fetch a selector entry for a thread */

server/timer.c

@@ -173,11 +173,10 @@ static void timer_destroy( struct object *obj )
 /* create a timer */
 DECL_HANDLER(create_timer)
 {
-    size_t len = get_req_strlenW( req, req->name );
     struct timer *timer;
 
     req->handle = -1;
-    if ((timer = create_timer( req->name, len, req->manual )))
+    if ((timer = create_timer( get_req_data(req), get_req_data_size(req), req->manual )))
     {
         req->handle = alloc_handle( current->process, timer, TIMER_ALL_ACCESS, req->inherit );
         release_object( timer );
@@ -187,8 +186,8 @@ DECL_HANDLER(create_timer)
 /* open a handle to a timer */
 DECL_HANDLER(open_timer)
 {
-    size_t len = get_req_strlenW( req, req->name );
-    req->handle = open_object( req->name, len, &timer_ops, req->access, req->inherit );
+    req->handle = open_object( get_req_data(req), get_req_data_size(req),
+                               &timer_ops, req->access, req->inherit );
 }
 
 /* set a waitable timer */

server/trace.c

@@ -100,13 +100,50 @@ static void dump_exc_record( const void *req, const EXCEPTION_RECORD *rec )
     fputc( '}', stderr );
 }
 
-static void dump_debug_event_t( const void *req, const debug_event_t *event )
+static void dump_varargs_ints( const void *ptr, size_t len )
 {
+    const int *data = ptr;
+    len /= sizeof(*data);
+
+    fputc( '{', stderr );
+    while (len > 0)
+    {
+        fprintf( stderr, "%d", *data++ );
+        if (--len) fputc( ',', stderr );
+    }
+    fputc( '}', stderr );
+}
+
+static void dump_varargs_ptrs( const void *ptr, size_t len )
+{
+    void * const *data = ptr;
+    len /= sizeof(*data);
+
+    fputc( '{', stderr );
+    while (len > 0)
+    {
+        fprintf( stderr, "%p", *data++ );
+        if (--len) fputc( ',', stderr );
+    }
+    fputc( '}', stderr );
+}
+
+static void dump_varargs_unicode_str( const void *ptr, size_t len )
+{
+    fprintf( stderr, "L\"" );
+    dump_strW( ptr, len / sizeof(WCHAR), stderr, "\"\"" );
+    fputc( '\"', stderr );
+}
+
+static void dump_varargs_debug_event( const void *ptr, size_t len )
+{
+    const debug_event_t *event = ptr;
+
     switch(event->code)
     {
     case EXCEPTION_DEBUG_EVENT:
         fprintf( stderr, "{exception," );
-        dump_exc_record( req, &event->info.exception.record );
+        dump_exc_record( ptr, &event->info.exception.record );
         fprintf( stderr, ",first=%d}", event->info.exception.first );
         break;
     case CREATE_THREAD_DEBUG_EVENT:
@@ -156,23 +193,8 @@ static void dump_debug_event_t( const void *req, const debug_event_t *event )
     }
 }
 
-
 /* dumping for functions for requests that have a variable part */
 
-static void dump_varargs_select_request( const struct select_request *req )
-{
-    int count = min( req->count, get_req_size( req, req->handles, sizeof(int) ));
-    dump_ints( req->handles, count );
-}
-
-static void dump_varargs_get_apc_reply( const struct get_apc_request *req )
-{
-    int i;
-    for (i = 0; i < req->nb_args; i++)
-        fprintf( stderr, "%c%p", i ? ',' : '{', req->args[i] );
-    fprintf( stderr, "}" );
-}
-
 static void dump_varargs_get_socket_event_reply( const struct get_socket_event_request *req )
 {
     dump_ints( req->errors, FD_MAX_EVENTS );
@@ -430,9 +452,8 @@ static void dump_get_apc_reply( const struct get_apc_request *req )
 {
     fprintf( stderr, " func=%p,", req->func );
     fprintf( stderr, " type=%d,", req->type );
-    fprintf( stderr, " nb_args=%d,", req->nb_args );
     fprintf( stderr, " args=" );
-    dump_varargs_get_apc_reply( req );
+    dump_varargs_ptrs( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_close_handle_request( const struct close_handle_request *req )
@@ -486,11 +507,10 @@ static void dump_open_process_reply( const struct open_process_request *req )
 
 static void dump_select_request( const struct select_request *req )
 {
-    fprintf( stderr, " count=%d,", req->count );
     fprintf( stderr, " flags=%d,", req->flags );
     fprintf( stderr, " timeout=%d,", req->timeout );
     fprintf( stderr, " handles=" );
-    dump_varargs_select_request( req );
+    dump_varargs_ints( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_select_reply( const struct select_request *req )
@@ -504,7 +524,7 @@ static void dump_create_event_request( const struct create_event_request *req )
     fprintf( stderr, " initial_state=%d,", req->initial_state );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_create_event_reply( const struct create_event_request *req )
@@ -523,7 +543,7 @@ static void dump_open_event_request( const struct open_event_request *req )
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_open_event_reply( const struct open_event_request *req )
@@ -536,7 +556,7 @@ static void dump_create_mutex_request( const struct create_mutex_request *req )
     fprintf( stderr, " owned=%d,", req->owned );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_create_mutex_reply( const struct create_mutex_request *req )
@@ -554,7 +574,7 @@ static void dump_open_mutex_request( const struct open_mutex_request *req )
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_open_mutex_reply( const struct open_mutex_request *req )
@@ -568,7 +588,7 @@ static void dump_create_semaphore_request( const struct create_semaphore_request
     fprintf( stderr, " max=%08x,", req->max );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_create_semaphore_reply( const struct create_semaphore_request *req )
@@ -592,7 +612,7 @@ static void dump_open_semaphore_request( const struct open_semaphore_request *re
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_open_semaphore_reply( const struct open_semaphore_request *req )
@@ -890,7 +910,7 @@ static void dump_create_mapping_request( const struct create_mapping_request *re
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " file_handle=%d,", req->file_handle );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_create_mapping_reply( const struct create_mapping_request *req )
@@ -903,7 +923,7 @@ static void dump_open_mapping_request( const struct open_mapping_request *req )
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_open_mapping_reply( const struct open_mapping_request *req )
@@ -1002,7 +1022,7 @@ static void dump_wait_debug_event_reply( const struct wait_debug_event_request *
     fprintf( stderr, " pid=%p,", req->pid );
     fprintf( stderr, " tid=%p,", req->tid );
     fprintf( stderr, " event=" );
-    dump_debug_event_t( req, &req->event );
+    dump_varargs_debug_event( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_exception_event_request( const struct exception_event_request *req )
@@ -1232,7 +1252,7 @@ static void dump_create_timer_request( const struct create_timer_request *req )
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " manual=%d,", req->manual );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_create_timer_reply( const struct create_timer_request *req )
@@ -1245,7 +1265,7 @@ static void dump_open_timer_request( const struct open_timer_request *req )
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_open_timer_reply( const struct open_timer_request *req )
@@ -1305,7 +1325,7 @@ static void dump_add_atom_request( const struct add_atom_request *req )
 {
     fprintf( stderr, " local=%d,", req->local );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_add_atom_reply( const struct add_atom_request *req )
@@ -1323,7 +1343,7 @@ static void dump_find_atom_request( const struct find_atom_request *req )
 {
     fprintf( stderr, " local=%d,", req->local );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_find_atom_reply( const struct find_atom_request *req )
@@ -1341,7 +1361,7 @@ static void dump_get_atom_name_reply( const struct get_atom_name_request *req )
 {
     fprintf( stderr, " count=%d,", req->count );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req, req->name );
+    dump_varargs_unicode_str( get_req_data(req), get_req_data_size(req) );
 }
 
 static void dump_init_atom_table_request( const struct init_atom_table_request *req )

tools/make_requests

@@ -121,7 +121,7 @@ sub DO_REQUEST
         {
             $dir = $1;
             $var = $2;
-            $type = "&" . $3;
+            $type = "&dump_varargs_" . $3;
         }
 	elsif (/^\s*(IN|OUT)\s*(\w+\**(\s+\w+\**)*)\s+(\w+)(\[[1]\])?;/)
         {
@@ -178,10 +178,19 @@ sub DO_DUMP_FUNC
 	}
 	else  # must be some varargs format
 	{
+            if ($type =~ /^&(.*)/)
+            {
+                my $func = $1;
+                push @trace_lines, "    fprintf( stderr, \" $var=\" );\n";
+                push @trace_lines, "    $func( get_req_data(req), get_req_data_size(req) );\n";
+            }
+            else
+            {
                 push @trace_lines, "    fprintf( stderr, \" $var=\" );\n";
                 push @trace_lines, "    dump_varargs_${name}_${req}( req );\n";
             }
         }
+    }
     push @trace_lines, "}\n\n";
 }
 

win32/console.c

@@ -647,14 +647,15 @@ UINT WINAPI GetConsoleOutputCP(VOID)
  */
 BOOL WINAPI GetConsoleMode(HANDLE hcon,LPDWORD mode)
 {
-    BOOL ret = FALSE;
-    struct get_console_mode_request *req = get_req_buffer();
-    req->handle = hcon;
-    if (!server_call( REQ_GET_CONSOLE_MODE ))
+    BOOL ret;
+    SERVER_START_REQ
     {
-        if (mode) *mode = req->mode;
-        ret = TRUE;
+        struct get_console_mode_request *req = server_alloc_req( sizeof(*req), 0 );
+        req->handle = hcon;
+        ret = !server_call( REQ_GET_CONSOLE_MODE );
+        if (ret && mode) *mode = req->mode;
     }
+    SERVER_END_REQ;
     return ret;
 }
 
@@ -672,10 +673,16 @@ BOOL WINAPI GetConsoleMode(HANDLE hcon,LPDWORD mode)
  */
 BOOL WINAPI SetConsoleMode( HANDLE hcon, DWORD mode )
 {
-    struct set_console_mode_request *req = get_req_buffer();
+    BOOL ret;
+    SERVER_START_REQ
+    {
+        struct set_console_mode_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hcon;
         req->mode = mode;
-    return !server_call( REQ_SET_CONSOLE_MODE );
+        ret = !server_call( REQ_SET_CONSOLE_MODE );
+    }
+    SERVER_END_REQ;
+    return ret;
 }
 
 

win32/device.c

@@ -330,18 +330,22 @@ HANDLE DEVICE_Open( LPCSTR filename, DWORD access,
 
 static const struct VxDInfo *DEVICE_GetInfo( HANDLE handle )
 {
-    struct get_file_info_request *req = get_req_buffer();
+    const struct VxDInfo *info = NULL;
+    SERVER_START_REQ
+    {
+        struct get_file_info_request *req = server_alloc_req( sizeof(*req), 0 );
 
         req->handle = handle;
         if (!server_call( REQ_GET_FILE_INFO ) &&
             (req->type == FILE_TYPE_UNKNOWN) &&
             (req->attr & 0x10000))
         {
-        const struct VxDInfo *info;
             for (info = VxDList; info->name; info++)
-            if (info->id == LOWORD(req->attr)) return info;
+                if (info->id == LOWORD(req->attr)) break;
+        }
     }
-    return NULL;
+    SERVER_END_REQ;
+    return info;
 }
 
 /****************************************************************************

windows/queue.c

@@ -441,9 +441,9 @@ void QUEUE_SetExitingQueue( HQUEUE16 hQueue )
 static HQUEUE16 QUEUE_CreateMsgQueue( BOOL16 bCreatePerQData )
 {
     HQUEUE16 hQueue;
+    HANDLE handle = -1;
     MESSAGEQUEUE * msgQueue;
     TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
-    struct get_msg_queue_request *req = get_req_buffer();
 
     TRACE_(msg)("(): Creating message queue...\n");
 
@@ -455,13 +455,19 @@ static HQUEUE16 QUEUE_CreateMsgQueue( BOOL16 bCreatePerQData )
     if ( !msgQueue )
         return 0;
 
-    if (server_call( REQ_GET_MSG_QUEUE ))
+    SERVER_START_REQ
+    {
+        struct get_msg_queue_request *req = server_alloc_req( sizeof(*req), 0 );
+        if (!server_call( REQ_GET_MSG_QUEUE )) handle = req->handle;
+    }
+    SERVER_END_REQ;
+    if (handle == -1)
     {
         ERR_(msg)("Cannot get thread queue");
         GlobalFree16( hQueue );
         return 0;
     }
-    msgQueue->server_queue = req->handle;
+    msgQueue->server_queue = handle;
     msgQueue->server_queue = ConvertToGlobalHandle( msgQueue->server_queue );
 
     msgQueue->self        = hQueue;
@@ -639,11 +645,15 @@ void QUEUE_SetWakeBit( MESSAGEQUEUE *queue, WORD bit )
         }
         else
         {
-            struct wake_queue_request *req = get_req_buffer();
+            SERVER_START_REQ
+            {
+                struct wake_queue_request *req = server_alloc_req( sizeof(*req), 0 );
                 req->handle = queue->server_queue;
                 req->bits   = bit;
                 server_call( REQ_WAKE_QUEUE );
             }
+            SERVER_END_REQ;
+        }
     }
 }
 
@@ -1500,13 +1510,18 @@ BOOL16 WINAPI GetInputState16(void)
 DWORD WINAPI WaitForInputIdle (HANDLE hProcess, DWORD dwTimeOut)
 {
     DWORD cur_time, ret;
-    HANDLE idle_event;
-    struct wait_input_idle_request *req = get_req_buffer();
+    HANDLE idle_event = -1;
 
+    SERVER_START_REQ
+    {
+        struct wait_input_idle_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hProcess;
         req->timeout = dwTimeOut;
-    if (server_call( REQ_WAIT_INPUT_IDLE )) return 0xffffffff;
-    if ((idle_event = req->event) == -1) return 0;  /* no event to wait on */
+        if (!(ret = server_call( REQ_WAIT_INPUT_IDLE ))) idle_event = req->event;
+    }
+    SERVER_END_REQ;
+    if (ret) return 0xffffffff;  /* error */
+    if (idle_event == -1) return 0;  /* no event to wait on */
 
   cur_time = GetTickCount();