2 * Wine server communication
4 * Copyright (C) 1998 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
33 #include <sys/types.h>
34 #ifdef HAVE_SYS_SOCKET_H
35 # include <sys/socket.h>
37 #ifdef HAVE_SYS_WAIT_H
43 #ifdef HAVE_SYS_MMAN_H
46 #ifdef HAVE_SYS_STAT_H
47 # include <sys/stat.h>
57 #include "wine/library.h"
58 #include "wine/pthread.h"
59 #include "wine/server.h"
60 #include "wine/debug.h"
61 #include "ntdll_misc.h"
63 WINE_DEFAULT_DEBUG_CHANNEL(server);
65 /* Some versions of glibc don't define this */
70 #define SOCKETNAME "socket" /* name of the socket file */
71 #define LOCKNAME "lock" /* name of the lock file */
73 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
74 /* data structure used to pass an fd with sendmsg/recvmsg */
79 size_t len; /* size of structure */
80 int level; /* SOL_SOCKET */
81 int type; /* SCM_RIGHTS */
83 int fd; /* fd to pass */
85 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
87 time_t server_start_time = 0; /* time of server startup */
89 extern struct wine_pthread_functions pthread_functions;
91 static sigset_t block_set; /* signals to block during server calls */
92 static int fd_socket = -1; /* socket to exchange file descriptors with the server */
94 static RTL_CRITICAL_SECTION fd_cache_section;
95 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
97 0, 0, &fd_cache_section,
98 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
99 0, 0, { (DWORD_PTR)(__FILE__ ": fd_cache_section") }
101 static RTL_CRITICAL_SECTION fd_cache_section = { &critsect_debug, -1, 0, 0, 0, 0 };
105 static void fatal_error( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
106 static void fatal_perror( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
107 static void server_connect_error( const char *serverdir ) __attribute__((noreturn));
110 /* die on a fatal error; use only during initialization */
111 static void fatal_error( const char *err, ... )
115 va_start( args, err );
116 fprintf( stderr, "wine: " );
117 vfprintf( stderr, err, args );
122 /* die on a fatal error; use only during initialization */
123 static void fatal_perror( const char *err, ... )
127 va_start( args, err );
128 fprintf( stderr, "wine: " );
129 vfprintf( stderr, err, args );
136 /***********************************************************************
139 void server_exit_thread( int status )
141 struct wine_pthread_thread_info info;
145 RemoveEntryList( &NtCurrentTeb()->TlsLinks );
148 info.stack_base = NtCurrentTeb()->DeallocationStack;
149 info.teb_base = NtCurrentTeb();
150 info.teb_sel = wine_get_fs();
151 info.exit_status = status;
154 NtFreeVirtualMemory( GetCurrentProcess(), &info.stack_base, &size, MEM_RELEASE | MEM_SYSTEM );
155 info.stack_size = size;
158 NtFreeVirtualMemory( GetCurrentProcess(), &info.teb_base, &size, MEM_RELEASE | MEM_SYSTEM );
159 info.teb_size = size;
161 sigprocmask( SIG_BLOCK, &block_set, NULL );
162 close( ntdll_get_thread_data()->wait_fd[0] );
163 close( ntdll_get_thread_data()->wait_fd[1] );
164 close( ntdll_get_thread_data()->reply_fd );
165 close( ntdll_get_thread_data()->request_fd );
166 pthread_functions.exit_thread( &info );
170 /***********************************************************************
171 * server_abort_thread
173 void server_abort_thread( int status )
175 sigprocmask( SIG_BLOCK, &block_set, NULL );
176 close( ntdll_get_thread_data()->wait_fd[0] );
177 close( ntdll_get_thread_data()->wait_fd[1] );
178 close( ntdll_get_thread_data()->reply_fd );
179 close( ntdll_get_thread_data()->request_fd );
180 pthread_functions.abort_thread( status );
184 /***********************************************************************
185 * server_protocol_error
187 void server_protocol_error( const char *err, ... )
191 va_start( args, err );
192 fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
193 vfprintf( stderr, err, args );
195 server_abort_thread(1);
199 /***********************************************************************
200 * server_protocol_perror
202 void server_protocol_perror( const char *err )
204 fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
206 server_abort_thread(1);
210 /***********************************************************************
213 * Send a request to the server.
215 static void send_request( const struct __server_request_info *req )
220 if (!req->u.req.request_header.request_size)
222 if ((ret = write( ntdll_get_thread_data()->request_fd, &req->u.req,
223 sizeof(req->u.req) )) == sizeof(req->u.req)) return;
228 struct iovec vec[__SERVER_MAX_DATA+1];
230 vec[0].iov_base = (void *)&req->u.req;
231 vec[0].iov_len = sizeof(req->u.req);
232 for (i = 0; i < req->data_count; i++)
234 vec[i+1].iov_base = (void *)req->data[i].ptr;
235 vec[i+1].iov_len = req->data[i].size;
237 if ((ret = writev( ntdll_get_thread_data()->request_fd, vec, i+1 )) ==
238 req->u.req.request_header.request_size + sizeof(req->u.req)) return;
241 if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
242 if (errno == EPIPE) server_abort_thread(0);
243 server_protocol_perror( "write" );
247 /***********************************************************************
250 * Read data from the reply buffer; helper for wait_reply.
252 static void read_reply_data( void *buffer, size_t size )
258 if ((ret = read( ntdll_get_thread_data()->reply_fd, buffer, size )) > 0)
260 if (!(size -= ret)) return;
261 buffer = (char *)buffer + ret;
265 if (errno == EINTR) continue;
266 if (errno == EPIPE) break;
267 server_protocol_perror("read");
269 /* the server closed the connection; time to die... */
270 server_abort_thread(0);
274 /***********************************************************************
277 * Wait for a reply from the server.
279 inline static void wait_reply( struct __server_request_info *req )
281 read_reply_data( &req->u.reply, sizeof(req->u.reply) );
282 if (req->u.reply.reply_header.reply_size)
283 read_reply_data( req->reply_data, req->u.reply.reply_header.reply_size );
287 /***********************************************************************
288 * wine_server_call (NTDLL.@)
290 * Perform a server call.
293 * req_ptr [I/O] Function dependent data
296 * Depends on server function being called, but usually an NTSTATUS code.
299 * Use the SERVER_START_REQ and SERVER_END_REQ to help you fill out the
300 * server request structure for the particular call. E.g:
301 *| SERVER_START_REQ( event_op )
303 *| req->handle = handle;
304 *| req->op = SET_EVENT;
305 *| ret = wine_server_call( req );
309 unsigned int wine_server_call( void *req_ptr )
311 struct __server_request_info * const req = req_ptr;
314 sigprocmask( SIG_BLOCK, &block_set, &old_set );
317 sigprocmask( SIG_SETMASK, &old_set, NULL );
318 return req->u.reply.reply_header.error;
322 /***********************************************************************
323 * wine_server_send_fd (NTDLL.@)
325 * Send a file descriptor to the server.
328 * fd [I] file descriptor to send
333 void wine_server_send_fd( int fd )
335 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
339 struct msghdr msghdr;
343 vec.iov_base = (void *)&data;
344 vec.iov_len = sizeof(data);
346 msghdr.msg_name = NULL;
347 msghdr.msg_namelen = 0;
348 msghdr.msg_iov = &vec;
349 msghdr.msg_iovlen = 1;
351 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
352 msghdr.msg_accrights = (void *)&fd;
353 msghdr.msg_accrightslen = sizeof(fd);
354 #else /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
355 cmsg.header.len = sizeof(cmsg.header) + sizeof(fd);
356 cmsg.header.level = SOL_SOCKET;
357 cmsg.header.type = SCM_RIGHTS;
359 msghdr.msg_control = &cmsg;
360 msghdr.msg_controllen = sizeof(cmsg.header) + sizeof(fd);
361 msghdr.msg_flags = 0;
362 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
364 data.tid = GetCurrentThreadId();
369 if ((ret = sendmsg( fd_socket, &msghdr, 0 )) == sizeof(data)) return;
370 if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
371 if (errno == EINTR) continue;
372 if (errno == EPIPE) server_abort_thread(0);
373 server_protocol_perror( "sendmsg" );
378 /***********************************************************************
381 * Receive a file descriptor passed from the server.
383 static int receive_fd( obj_handle_t *handle )
388 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
389 struct msghdr msghdr;
392 msghdr.msg_accrights = (void *)&fd;
393 msghdr.msg_accrightslen = sizeof(fd);
394 #else /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
395 struct msghdr msghdr;
398 cmsg.header.len = sizeof(cmsg.header) + sizeof(fd);
399 cmsg.header.level = SOL_SOCKET;
400 cmsg.header.type = SCM_RIGHTS;
402 msghdr.msg_control = &cmsg;
403 msghdr.msg_controllen = sizeof(cmsg.header) + sizeof(fd);
404 msghdr.msg_flags = 0;
405 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
407 msghdr.msg_name = NULL;
408 msghdr.msg_namelen = 0;
409 msghdr.msg_iov = &vec;
410 msghdr.msg_iovlen = 1;
411 vec.iov_base = (void *)handle;
412 vec.iov_len = sizeof(*handle);
416 if ((ret = recvmsg( fd_socket, &msghdr, 0 )) > 0)
418 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
421 if (fd != -1) fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
425 if (errno == EINTR) continue;
426 if (errno == EPIPE) break;
427 server_protocol_perror("recvmsg");
429 /* the server closed the connection; time to die... */
430 server_abort_thread(0);
434 /***********************************************************************
435 * wine_server_fd_to_handle (NTDLL.@)
437 * Allocate a file handle for a Unix file descriptor.
440 * fd [I] Unix file descriptor.
441 * access [I] Win32 access flags.
442 * inherit [I] Indicates whether this handle is inherited by child processes.
443 * handle [O] Address where Wine file handle will be stored.
448 int wine_server_fd_to_handle( int fd, unsigned int access, int inherit, obj_handle_t *handle )
453 wine_server_send_fd( fd );
455 SERVER_START_REQ( alloc_file_handle )
457 req->access = access;
458 req->inherit = inherit;
460 if (!(ret = wine_server_call( req ))) *handle = reply->handle;
467 /***********************************************************************
468 * wine_server_handle_to_fd (NTDLL.@)
470 * Retrieve the file descriptor corresponding to a file handle.
473 * handle [I] Wine file handle.
474 * access [I] Win32 file access rights requested.
475 * unix_fd [O] Address where Unix file descriptor will be stored.
476 * flags [O] Address where the Unix flags associated with file will be stored. Optional.
481 int wine_server_handle_to_fd( obj_handle_t handle, unsigned int access, int *unix_fd, int *flags )
483 obj_handle_t fd_handle;
484 int ret, removable = -1, fd = -1;
486 RtlEnterCriticalSection( &fd_cache_section );
491 SERVER_START_REQ( get_handle_fd )
493 req->handle = handle;
494 req->access = access;
495 if (!(ret = wine_server_call( req )))
498 removable = reply->removable;
499 if (flags) *flags = reply->flags;
507 if ((fd = dup(fd)) == -1) ret = FILE_GetNtStatus();
511 /* it wasn't in the cache, get it from the server */
512 fd = receive_fd( &fd_handle );
515 ret = STATUS_TOO_MANY_OPENED_FILES;
518 if (fd_handle != handle) removable = -1;
522 FILE_FS_DEVICE_INFORMATION info;
523 if (FILE_GetDeviceInfo( fd, &info ) == STATUS_SUCCESS)
524 removable = (info.Characteristics & FILE_REMOVABLE_MEDIA) != 0;
526 else if (removable) break; /* don't cache it */
528 /* and store it back into the cache */
529 SERVER_START_REQ( set_handle_fd )
531 req->handle = fd_handle;
533 req->removable = removable;
534 if (!(ret = wine_server_call( req )))
536 if (reply->cur_fd != -1) /* it has been cached */
538 if (reply->cur_fd != fd) close( fd ); /* someone was here before us */
539 if ((fd = dup(reply->cur_fd)) == -1) ret = FILE_GetNtStatus();
551 if (fd_handle == handle) break;
552 /* if we received a different handle this means there was
553 * a race with another thread; we restart everything from
554 * scratch in this case.
559 RtlLeaveCriticalSection( &fd_cache_section );
560 if (!ret) *unix_fd = fd;
565 /***********************************************************************
566 * wine_server_release_fd (NTDLL.@)
568 * Release the Unix file descriptor returned by wine_server_handle_to_fd.
571 * handle [I] Wine file handle.
572 * unix_fd [I] Unix file descriptor to release.
577 void wine_server_release_fd( obj_handle_t handle, int unix_fd )
583 /***********************************************************************
586 * Start a new wine server.
588 static void start_server( const char *oldcwd )
590 static int started; /* we only try once */
598 if (pid == -1) fatal_perror( "fork" );
601 argv[0] = "wineserver";
602 argv[1] = TRACE_ON(server) ? "-d" : NULL;
604 /* if server is explicitly specified, use this */
605 if ((p = getenv("WINESERVER")))
607 if (p[0] != '/' && oldcwd[0] == '/') /* make it an absolute path */
609 if (!(path = malloc( strlen(oldcwd) + strlen(p) + 1 )))
610 fatal_error( "out of memory\n" );
611 sprintf( path, "%s/%s", oldcwd, p );
614 wine_exec_wine_binary( p, argv, NULL, FALSE );
615 fatal_perror( "could not exec the server '%s'\n"
616 " specified in the WINESERVER environment variable", p );
618 /* now use the standard search strategy */
619 wine_exec_wine_binary( argv[0], argv, NULL, FALSE );
620 fatal_error( "could not exec wineserver\n" );
622 waitpid( pid, &status, 0 );
623 status = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
624 if (status == 2) return; /* server lock held by someone else, will retry later */
625 if (status) exit(status); /* server failed */
631 /***********************************************************************
632 * server_connect_error
634 * Try to display a meaningful explanation of why we couldn't connect
637 static void server_connect_error( const char *serverdir )
642 if ((fd = open( LOCKNAME, O_WRONLY )) == -1)
643 fatal_error( "for some mysterious reason, the wine server never started.\n" );
646 fl.l_whence = SEEK_SET;
649 if (fcntl( fd, F_GETLK, &fl ) != -1)
651 if (fl.l_type == F_WRLCK) /* the file is locked */
652 fatal_error( "a wine server seems to be running, but I cannot connect to it.\n"
653 " You probably need to kill that process (it might be pid %d).\n",
655 fatal_error( "for some mysterious reason, the wine server failed to run.\n" );
657 fatal_error( "the file system of '%s' doesn't support locks,\n"
658 " and there is a 'socket' file in that directory that prevents wine from starting.\n"
659 " You should make sure no wine server is running, remove that file and try again.\n",
664 /***********************************************************************
667 * Attempt to connect to an existing server socket.
668 * We need to be in the server directory already.
670 static int server_connect( const char *oldcwd, const char *serverdir )
672 struct sockaddr_un addr;
676 /* chdir to the server directory */
677 if (chdir( serverdir ) == -1)
679 if (errno != ENOENT) fatal_perror( "chdir to %s", serverdir );
681 if (chdir( serverdir ) == -1) fatal_perror( "chdir to %s", serverdir );
684 /* make sure we are at the right place */
685 if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
686 if (st.st_uid != getuid()) fatal_error( "'%s' is not owned by you\n", serverdir );
687 if (st.st_mode & 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir );
689 for (retry = 0; retry < 6; retry++)
691 /* if not the first try, wait a bit to leave the previous server time to exit */
694 usleep( 100000 * retry * retry );
695 start_server( oldcwd );
696 if (lstat( SOCKETNAME, &st ) == -1) continue; /* still no socket, wait a bit more */
698 else if (lstat( SOCKETNAME, &st ) == -1) /* check for an already existing socket */
700 if (errno != ENOENT) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
701 start_server( oldcwd );
702 if (lstat( SOCKETNAME, &st ) == -1) continue; /* still no socket, wait a bit more */
705 /* make sure the socket is sane (ISFIFO needed for Solaris) */
706 if (!S_ISSOCK(st.st_mode) && !S_ISFIFO(st.st_mode))
707 fatal_error( "'%s/%s' is not a socket\n", serverdir, SOCKETNAME );
708 if (st.st_uid != getuid())
709 fatal_error( "'%s/%s' is not owned by you\n", serverdir, SOCKETNAME );
711 /* try to connect to it */
712 addr.sun_family = AF_UNIX;
713 strcpy( addr.sun_path, SOCKETNAME );
714 slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
715 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
718 if ((s = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
719 if (connect( s, (struct sockaddr *)&addr, slen ) != -1)
721 fcntl( s, F_SETFD, 1 ); /* set close on exec flag */
726 server_connect_error( serverdir );
730 /***********************************************************************
733 * Remove a directory and all its contents; helper for create_config_dir.
735 static void rm_rf( const char *path )
737 int err = errno; /* preserve errno */
743 if (!(buffer = malloc( strlen(path) + 256 + 1 ))) goto done;
744 strcpy( buffer, path );
745 p = buffer + strlen(buffer);
748 if ((dir = opendir( path )))
750 while ((de = readdir( dir )))
752 if (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." )) continue;
753 strcpy( p, de->d_name );
754 if (unlink( buffer ) != -1) continue;
755 if (errno == EISDIR ||
756 (errno == EPERM && !lstat( buffer, &st ) && S_ISDIR(st.st_mode)))
758 /* recurse in the sub-directory */
771 /***********************************************************************
774 * Create the wine configuration dir (~/.wine).
776 static void create_config_dir(void)
778 const char *config_dir = wine_get_config_dir();
783 if (!(tmp_dir = malloc( strlen(config_dir) + sizeof("-XXXXXX") )))
784 fatal_error( "out of memory\n" );
785 strcpy( tmp_dir, config_dir );
786 strcat( tmp_dir, "-XXXXXX" );
787 if ((fd = mkstemps( tmp_dir, 0 )) == -1)
788 fatal_perror( "can't get temp file name for %s", config_dir );
791 if (mkdir( tmp_dir, 0777 ) == -1)
792 fatal_perror( "cannot create temp dir %s", tmp_dir );
794 MESSAGE( "wine: creating configuration directory '%s'...\n", config_dir );
799 fatal_perror( "fork" );
805 argv[0] = "wineprefixcreate";
808 argv[3] = "--prefix";
811 wine_exec_wine_binary( argv[0], (char **)argv, NULL, FALSE );
813 fatal_perror( "could not exec wineprefixcreate" );
819 while ((wret = waitpid( pid, &status, 0 )) != pid)
821 if (wret == -1 && errno != EINTR) fatal_perror( "wait4" );
823 if (!WIFEXITED(status) || WEXITSTATUS(status))
826 fatal_error( "wineprefixcreate failed while creating '%s'.\n", config_dir );
829 if (rename( tmp_dir, config_dir ) == -1)
832 if (errno != EEXIST && errno != ENOTEMPTY)
833 fatal_perror( "rename '%s' to '%s'", tmp_dir, config_dir );
834 /* else it was probably created by a concurrent wine process */
837 MESSAGE( "wine: '%s' created successfully.\n", config_dir );
841 /***********************************************************************
842 * server_init_process
844 * Start the server and create the initial socket pair.
846 void server_init_process(void)
850 obj_handle_t dummy_handle;
851 const char *server_dir = wine_get_server_dir();
853 if (!server_dir) /* this means the config dir doesn't exist */
856 server_dir = wine_get_server_dir();
859 /* retrieve the current directory */
860 for (size = 512; ; size *= 2)
862 if (!(oldcwd = malloc( size ))) break;
863 if (getcwd( oldcwd, size )) break;
865 if (errno == ERANGE) continue;
870 /* connect to the server */
871 fd_socket = server_connect( oldcwd, server_dir );
873 /* switch back to the starting directory */
880 /* setup the signal mask */
881 sigemptyset( &block_set );
882 sigaddset( &block_set, SIGALRM );
883 sigaddset( &block_set, SIGIO );
884 sigaddset( &block_set, SIGINT );
885 sigaddset( &block_set, SIGHUP );
886 sigaddset( &block_set, SIGUSR1 );
887 sigaddset( &block_set, SIGUSR2 );
888 sigaddset( &block_set, SIGCHLD );
890 /* receive the first thread request fd on the main socket */
891 ntdll_get_thread_data()->request_fd = receive_fd( &dummy_handle );
895 /***********************************************************************
898 * Send an init thread request. Return 0 if OK.
900 size_t server_init_thread( int unix_pid, int unix_tid, void *entry_point )
904 struct sigaction sig_act;
907 sig_act.sa_handler = SIG_IGN;
908 sig_act.sa_flags = 0;
909 sigemptyset( &sig_act.sa_mask );
911 /* ignore SIGPIPE so that we get an EPIPE error instead */
912 sigaction( SIGPIPE, &sig_act, NULL );
913 /* automatic child reaping to avoid zombies */
915 sig_act.sa_flags |= SA_NOCLDWAIT;
917 sigaction( SIGCHLD, &sig_act, NULL );
919 /* create the server->client communication pipes */
920 if (pipe( reply_pipe ) == -1) server_protocol_perror( "pipe" );
921 if (pipe( ntdll_get_thread_data()->wait_fd ) == -1) server_protocol_perror( "pipe" );
922 wine_server_send_fd( reply_pipe[1] );
923 wine_server_send_fd( ntdll_get_thread_data()->wait_fd[1] );
924 ntdll_get_thread_data()->reply_fd = reply_pipe[0];
925 close( reply_pipe[1] );
927 /* set close on exec flag */
928 fcntl( ntdll_get_thread_data()->reply_fd, F_SETFD, 1 );
929 fcntl( ntdll_get_thread_data()->wait_fd[0], F_SETFD, 1 );
930 fcntl( ntdll_get_thread_data()->wait_fd[1], F_SETFD, 1 );
932 SERVER_START_REQ( init_thread )
934 req->unix_pid = unix_pid;
935 req->unix_tid = unix_tid;
936 req->teb = NtCurrentTeb();
937 req->peb = NtCurrentTeb()->Peb;
938 req->entry = entry_point;
939 req->ldt_copy = &wine_ldt_copy;
940 req->reply_fd = reply_pipe[1];
941 req->wait_fd = ntdll_get_thread_data()->wait_fd[1];
942 req->debug_level = (TRACE_ON(server) != 0);
943 ret = wine_server_call( req );
944 NtCurrentTeb()->ClientId.UniqueProcess = (HANDLE)reply->pid;
945 NtCurrentTeb()->ClientId.UniqueThread = (HANDLE)reply->tid;
946 info_size = reply->info_size;
947 version = reply->version;
948 server_start_time = reply->server_start;
952 if (ret) server_protocol_error( "init_thread failed with status %x\n", ret );
953 if (version != SERVER_PROTOCOL_VERSION)
954 server_protocol_error( "version mismatch %d/%d.\n"
955 "Your %s binary was not upgraded correctly,\n"
956 "or you have an older one somewhere in your PATH.\n"
957 "Or maybe the wrong wineserver is still running?\n",
958 version, SERVER_PROTOCOL_VERSION,
959 (version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );