Implement the repair mechanism in msiexec, and stub it out in
[wine.git] / dlls / ntdll / server.c
blobfe29378bdd5131efd36882c808dec8017de762c8
1 /*
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
21 #include "config.h"
22 #include "wine/port.h"
24 #include <assert.h>
25 #include <ctype.h>
26 #include <dirent.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <signal.h>
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <string.h>
33 #include <sys/types.h>
34 #ifdef HAVE_SYS_SOCKET_H
35 # include <sys/socket.h>
36 #endif
37 #ifdef HAVE_SYS_WAIT_H
38 #include <sys/wait.h>
39 #endif
40 #ifdef HAVE_SYS_UN_H
41 #include <sys/un.h>
42 #endif
43 #ifdef HAVE_SYS_MMAN_H
44 #include <sys/mman.h>
45 #endif
46 #include <sys/stat.h>
47 #ifdef HAVE_SYS_UIO_H
48 #include <sys/uio.h>
49 #endif
50 #ifdef HAVE_UNISTD_H
51 # include <unistd.h>
52 #endif
54 #include "ntstatus.h"
55 #include "thread.h"
56 #include "wine/library.h"
57 #include "wine/pthread.h"
58 #include "wine/server.h"
59 #include "wine/debug.h"
60 #include "winerror.h"
61 #include "ntdll_misc.h"
63 WINE_DEFAULT_DEBUG_CHANNEL(server);
65 /* Some versions of glibc don't define this */
66 #ifndef SCM_RIGHTS
67 #define SCM_RIGHTS 1
68 #endif
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 */
75 struct cmsg_fd
77 int len; /* size of structure */
78 int level; /* SOL_SOCKET */
79 int type; /* SCM_RIGHTS */
80 int fd; /* fd to pass */
82 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
84 static sigset_t block_set; /* signals to block during server calls */
85 static int fd_socket = -1; /* socket to exchange file descriptors with the server */
87 #ifdef __GNUC__
88 static void fatal_error( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
89 static void fatal_perror( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
90 static void server_connect_error( const char *serverdir ) __attribute__((noreturn));
91 #endif
93 /* die on a fatal error; use only during initialization */
94 static void fatal_error( const char *err, ... )
96 va_list args;
98 va_start( args, err );
99 fprintf( stderr, "wine: " );
100 vfprintf( stderr, err, args );
101 va_end( args );
102 exit(1);
105 /* die on a fatal error; use only during initialization */
106 static void fatal_perror( const char *err, ... )
108 va_list args;
110 va_start( args, err );
111 fprintf( stderr, "wine: " );
112 vfprintf( stderr, err, args );
113 perror( " " );
114 va_end( args );
115 exit(1);
119 /***********************************************************************
120 * server_abort_thread
122 void server_abort_thread( int status )
124 sigprocmask( SIG_BLOCK, &block_set, NULL );
125 close( NtCurrentTeb()->wait_fd[0] );
126 close( NtCurrentTeb()->wait_fd[1] );
127 close( NtCurrentTeb()->reply_fd );
128 close( NtCurrentTeb()->request_fd );
129 wine_pthread_abort_thread( status );
133 /***********************************************************************
134 * server_protocol_error
136 void server_protocol_error( const char *err, ... )
138 va_list args;
140 va_start( args, err );
141 fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
142 vfprintf( stderr, err, args );
143 va_end( args );
144 server_abort_thread(1);
148 /***********************************************************************
149 * server_protocol_perror
151 void server_protocol_perror( const char *err )
153 fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
154 perror( err );
155 server_abort_thread(1);
159 /***********************************************************************
160 * send_request
162 * Send a request to the server.
164 static void send_request( const struct __server_request_info *req )
166 int i, ret;
168 if (!req->u.req.request_header.request_size)
170 if ((ret = write( NtCurrentTeb()->request_fd, &req->u.req,
171 sizeof(req->u.req) )) == sizeof(req->u.req)) return;
174 else
176 struct iovec vec[__SERVER_MAX_DATA+1];
178 vec[0].iov_base = (void *)&req->u.req;
179 vec[0].iov_len = sizeof(req->u.req);
180 for (i = 0; i < req->data_count; i++)
182 vec[i+1].iov_base = (void *)req->data[i].ptr;
183 vec[i+1].iov_len = req->data[i].size;
185 if ((ret = writev( NtCurrentTeb()->request_fd, vec, i+1 )) ==
186 req->u.req.request_header.request_size + sizeof(req->u.req)) return;
189 if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
190 if (errno == EPIPE) server_abort_thread(0);
191 server_protocol_perror( "write" );
195 /***********************************************************************
196 * read_reply_data
198 * Read data from the reply buffer; helper for wait_reply.
200 static void read_reply_data( void *buffer, size_t size )
202 int ret;
204 for (;;)
206 if ((ret = read( NtCurrentTeb()->reply_fd, buffer, size )) > 0)
208 if (!(size -= ret)) return;
209 buffer = (char *)buffer + ret;
210 continue;
212 if (!ret) break;
213 if (errno == EINTR) continue;
214 if (errno == EPIPE) break;
215 server_protocol_perror("read");
217 /* the server closed the connection; time to die... */
218 server_abort_thread(0);
222 /***********************************************************************
223 * wait_reply
225 * Wait for a reply from the server.
227 inline static void wait_reply( struct __server_request_info *req )
229 read_reply_data( &req->u.reply, sizeof(req->u.reply) );
230 if (req->u.reply.reply_header.reply_size)
231 read_reply_data( req->reply_data, req->u.reply.reply_header.reply_size );
235 /***********************************************************************
236 * wine_server_call (NTDLL.@)
238 * Perform a server call.
240 unsigned int wine_server_call( void *req_ptr )
242 struct __server_request_info * const req = req_ptr;
243 sigset_t old_set;
245 sigprocmask( SIG_BLOCK, &block_set, &old_set );
246 send_request( req );
247 wait_reply( req );
248 sigprocmask( SIG_SETMASK, &old_set, NULL );
249 return req->u.reply.reply_header.error;
253 /***********************************************************************
254 * wine_server_send_fd
256 * Send a file descriptor to the server.
258 void wine_server_send_fd( int fd )
260 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
261 struct cmsg_fd cmsg;
262 #endif
263 struct send_fd data;
264 struct msghdr msghdr;
265 struct iovec vec;
266 int ret;
268 vec.iov_base = (void *)&data;
269 vec.iov_len = sizeof(data);
271 msghdr.msg_name = NULL;
272 msghdr.msg_namelen = 0;
273 msghdr.msg_iov = &vec;
274 msghdr.msg_iovlen = 1;
276 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
277 msghdr.msg_accrights = (void *)&fd;
278 msghdr.msg_accrightslen = sizeof(fd);
279 #else /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
280 cmsg.len = sizeof(cmsg);
281 cmsg.level = SOL_SOCKET;
282 cmsg.type = SCM_RIGHTS;
283 cmsg.fd = fd;
284 msghdr.msg_control = &cmsg;
285 msghdr.msg_controllen = sizeof(cmsg);
286 msghdr.msg_flags = 0;
287 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
289 data.tid = GetCurrentThreadId();
290 data.fd = fd;
292 for (;;)
294 if ((ret = sendmsg( fd_socket, &msghdr, 0 )) == sizeof(data)) return;
295 if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
296 if (errno == EINTR) continue;
297 if (errno == EPIPE) server_abort_thread(0);
298 server_protocol_perror( "sendmsg" );
303 /***********************************************************************
304 * receive_fd
306 * Receive a file descriptor passed from the server.
308 static int receive_fd( obj_handle_t *handle )
310 struct iovec vec;
311 int ret, fd;
313 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
314 struct msghdr msghdr;
316 fd = -1;
317 msghdr.msg_accrights = (void *)&fd;
318 msghdr.msg_accrightslen = sizeof(fd);
319 #else /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
320 struct msghdr msghdr;
321 struct cmsg_fd cmsg;
323 cmsg.len = sizeof(cmsg);
324 cmsg.level = SOL_SOCKET;
325 cmsg.type = SCM_RIGHTS;
326 cmsg.fd = -1;
327 msghdr.msg_control = &cmsg;
328 msghdr.msg_controllen = sizeof(cmsg);
329 msghdr.msg_flags = 0;
330 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
332 msghdr.msg_name = NULL;
333 msghdr.msg_namelen = 0;
334 msghdr.msg_iov = &vec;
335 msghdr.msg_iovlen = 1;
336 vec.iov_base = (void *)handle;
337 vec.iov_len = sizeof(*handle);
339 for (;;)
341 if ((ret = recvmsg( fd_socket, &msghdr, 0 )) > 0)
343 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
344 fd = cmsg.fd;
345 #endif
346 if (fd == -1) server_protocol_error( "no fd received for handle %d\n", *handle );
347 fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
348 return fd;
350 if (!ret) break;
351 if (errno == EINTR) continue;
352 if (errno == EPIPE) break;
353 server_protocol_perror("recvmsg");
355 /* the server closed the connection; time to die... */
356 server_abort_thread(0);
360 /***********************************************************************
361 * store_cached_fd
363 * Store the cached fd value for a given handle back into the server.
364 * Returns the new fd, which can be different if there was already an
365 * fd in the cache for that handle.
367 inline static int store_cached_fd( int *fd, obj_handle_t handle )
369 int ret;
371 SERVER_START_REQ( set_handle_info )
373 req->handle = handle;
374 req->flags = 0;
375 req->mask = 0;
376 req->fd = *fd;
377 if (!(ret = wine_server_call( req )))
379 if (reply->cur_fd != *fd)
381 /* someone was here before us */
382 close( *fd );
383 *fd = reply->cur_fd;
386 else
388 close( *fd );
389 *fd = -1;
392 SERVER_END_REQ;
393 return ret;
397 /***********************************************************************
398 * wine_server_fd_to_handle (NTDLL.@)
400 * Allocate a file handle for a Unix fd.
402 int wine_server_fd_to_handle( int fd, unsigned int access, int inherit, obj_handle_t *handle )
404 int ret;
406 *handle = 0;
407 wine_server_send_fd( fd );
409 SERVER_START_REQ( alloc_file_handle )
411 req->access = access;
412 req->inherit = inherit;
413 req->fd = fd;
414 if (!(ret = wine_server_call( req ))) *handle = reply->handle;
416 SERVER_END_REQ;
417 return ret;
421 /***********************************************************************
422 * wine_server_handle_to_fd (NTDLL.@)
424 * Retrieve the Unix fd corresponding to a file handle.
426 int wine_server_handle_to_fd( obj_handle_t handle, unsigned int access, int *unix_fd,
427 enum fd_type *type, int *flags )
429 obj_handle_t fd_handle;
430 int ret, fd = -1;
432 *unix_fd = -1;
433 for (;;)
435 SERVER_START_REQ( get_handle_fd )
437 req->handle = handle;
438 req->access = access;
439 if (!(ret = wine_server_call( req ))) fd = reply->fd;
440 if (type) *type = reply->type;
441 if (flags) *flags = reply->flags;
443 SERVER_END_REQ;
444 if (ret) return ret;
446 if (fd != -1) break;
448 /* it wasn't in the cache, get it from the server */
449 fd = receive_fd( &fd_handle );
450 /* and store it back into the cache */
451 ret = store_cached_fd( &fd, fd_handle );
452 if (ret) return ret;
454 if (fd_handle == handle) break;
455 /* if we received a different handle this means there was
456 * a race with another thread; we restart everything from
457 * scratch in this case.
461 if ((fd != -1) && ((fd = dup(fd)) == -1)) return STATUS_TOO_MANY_OPENED_FILES;
462 *unix_fd = fd;
463 return STATUS_SUCCESS;
467 /***********************************************************************
468 * wine_server_release_fd (NTDLL.@)
470 * Release the Unix fd returned by wine_server_handle_to_fd.
472 void wine_server_release_fd( obj_handle_t handle, int unix_fd )
474 close( unix_fd );
478 /***********************************************************************
479 * start_server
481 * Start a new wine server.
483 static void start_server( const char *oldcwd )
485 static int started; /* we only try once */
486 char *path, *p;
487 char *argv[3];
489 if (!started)
491 int status;
492 int pid = fork();
493 if (pid == -1) fatal_perror( "fork" );
494 if (!pid)
496 argv[0] = "wineserver";
497 argv[1] = TRACE_ON(server) ? "-d" : NULL;
498 argv[2] = NULL;
499 /* if server is explicitly specified, use this */
500 if ((p = getenv("WINESERVER")))
502 if (p[0] != '/' && oldcwd[0] == '/') /* make it an absolute path */
504 if (!(path = malloc( strlen(oldcwd) + strlen(p) + 1 )))
505 fatal_error( "out of memory\n" );
506 sprintf( path, "%s/%s", oldcwd, p );
507 p = path;
509 wine_exec_wine_binary( p, argv, NULL, FALSE );
510 fatal_perror( "could not exec the server '%s'\n"
511 " specified in the WINESERVER environment variable", p );
513 /* now use the standard search strategy */
514 wine_exec_wine_binary( argv[0], argv, NULL, FALSE );
515 fatal_error( "could not exec wineserver\n" );
517 waitpid( pid, &status, 0 );
518 status = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
519 if (status == 2) return; /* server lock held by someone else, will retry later */
520 if (status) exit(status); /* server failed */
521 started = 1;
526 /***********************************************************************
527 * server_connect_error
529 * Try to display a meaningful explanation of why we couldn't connect
530 * to the server.
532 static void server_connect_error( const char *serverdir )
534 int fd;
535 struct flock fl;
537 if ((fd = open( LOCKNAME, O_WRONLY )) == -1)
538 fatal_error( "for some mysterious reason, the wine server never started.\n" );
540 fl.l_type = F_WRLCK;
541 fl.l_whence = SEEK_SET;
542 fl.l_start = 0;
543 fl.l_len = 1;
544 if (fcntl( fd, F_GETLK, &fl ) != -1)
546 if (fl.l_type == F_WRLCK) /* the file is locked */
547 fatal_error( "a wine server seems to be running, but I cannot connect to it.\n"
548 " You probably need to kill that process (it might be pid %d).\n",
549 (int)fl.l_pid );
550 fatal_error( "for some mysterious reason, the wine server failed to run.\n" );
552 fatal_error( "the file system of '%s' doesn't support locks,\n"
553 " and there is a 'socket' file in that directory that prevents wine from starting.\n"
554 " You should make sure no wine server is running, remove that file and try again.\n",
555 serverdir );
559 /***********************************************************************
560 * server_connect
562 * Attempt to connect to an existing server socket.
563 * We need to be in the server directory already.
565 static int server_connect( const char *oldcwd, const char *serverdir )
567 struct sockaddr_un addr;
568 struct stat st;
569 int s, slen, retry;
571 /* chdir to the server directory */
572 if (chdir( serverdir ) == -1)
574 if (errno != ENOENT) fatal_perror( "chdir to %s", serverdir );
575 start_server( "." );
576 if (chdir( serverdir ) == -1) fatal_perror( "chdir to %s", serverdir );
579 /* make sure we are at the right place */
580 if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
581 if (st.st_uid != getuid()) fatal_error( "'%s' is not owned by you\n", serverdir );
582 if (st.st_mode & 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir );
584 for (retry = 0; retry < 6; retry++)
586 /* if not the first try, wait a bit to leave the previous server time to exit */
587 if (retry)
589 usleep( 100000 * retry * retry );
590 start_server( oldcwd );
591 if (lstat( SOCKETNAME, &st ) == -1) continue; /* still no socket, wait a bit more */
593 else if (lstat( SOCKETNAME, &st ) == -1) /* check for an already existing socket */
595 if (errno != ENOENT) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
596 start_server( oldcwd );
597 if (lstat( SOCKETNAME, &st ) == -1) continue; /* still no socket, wait a bit more */
600 /* make sure the socket is sane (ISFIFO needed for Solaris) */
601 if (!S_ISSOCK(st.st_mode) && !S_ISFIFO(st.st_mode))
602 fatal_error( "'%s/%s' is not a socket\n", serverdir, SOCKETNAME );
603 if (st.st_uid != getuid())
604 fatal_error( "'%s/%s' is not owned by you\n", serverdir, SOCKETNAME );
606 /* try to connect to it */
607 addr.sun_family = AF_UNIX;
608 strcpy( addr.sun_path, SOCKETNAME );
609 slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
610 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
611 addr.sun_len = slen;
612 #endif
613 if ((s = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
614 if (connect( s, (struct sockaddr *)&addr, slen ) != -1)
616 fcntl( s, F_SETFD, 1 ); /* set close on exec flag */
617 return s;
619 close( s );
621 server_connect_error( serverdir );
625 /***********************************************************************
626 * rm_rf
628 * Remove a directory and all its contents; helper for create_config_dir.
630 static void rm_rf( const char *path )
632 int err = errno; /* preserve errno */
633 DIR *dir;
634 char *buffer, *p;
635 struct stat st;
636 struct dirent *de;
638 if (!(buffer = malloc( strlen(path) + 256 + 1 ))) goto done;
639 strcpy( buffer, path );
640 p = buffer + strlen(buffer);
641 *p++ = '/';
643 if ((dir = opendir( path )))
645 while ((de = readdir( dir )))
647 if (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." )) continue;
648 strcpy( p, de->d_name );
649 if (unlink( buffer ) != -1) continue;
650 if (errno == EISDIR ||
651 (errno == EPERM && !lstat( buffer, &st ) && S_ISDIR(st.st_mode)))
653 /* recurse in the sub-directory */
654 rm_rf( buffer );
657 closedir( dir );
659 free( buffer );
660 rmdir( path );
661 done:
662 errno = err;
666 /***********************************************************************
667 * create_config_dir
669 * Create the wine configuration dir (~/.wine).
671 static void create_config_dir(void)
673 const char *config_dir = wine_get_config_dir();
674 char *tmp_dir;
675 int fd;
676 pid_t pid, wret;
678 if (!(tmp_dir = malloc( strlen(config_dir) + sizeof("-XXXXXX") )))
679 fatal_error( "out of memory\n" );
680 strcpy( tmp_dir, config_dir );
681 strcat( tmp_dir, "-XXXXXX" );
682 if ((fd = mkstemps( tmp_dir, 0 )) == -1)
683 fatal_perror( "can't get temp file name for %s", config_dir );
684 close( fd );
685 unlink( tmp_dir );
686 if (mkdir( tmp_dir, 0777 ) == -1)
687 fatal_perror( "cannot create temp dir %s", tmp_dir );
689 MESSAGE( "wine: creating configuration directory '%s'...\n", config_dir );
690 pid = fork();
691 if (pid == -1)
693 rmdir( tmp_dir );
694 fatal_perror( "fork" );
696 if (!pid)
698 const char *argv[5];
700 argv[0] = "wineprefixcreate";
701 argv[1] = "--quiet";
702 argv[2] = "--prefix";
703 argv[3] = tmp_dir;
704 argv[4] = NULL;
705 wine_exec_wine_binary( argv[0], (char **)argv, NULL, FALSE );
706 rmdir( tmp_dir );
707 fatal_perror( "could not exec wineprefixcreate" );
709 else
711 int status;
713 while ((wret = waitpid( pid, &status, 0 )) != pid)
715 if (wret == -1 && errno != EINTR) fatal_perror( "wait4" );
717 if (!WIFEXITED(status) || WEXITSTATUS(status))
719 rm_rf( tmp_dir );
720 fatal_error( "wineprefixcreate failed while creating '%s'.\n", config_dir );
723 if (rename( tmp_dir, config_dir ) == -1)
725 rm_rf( tmp_dir );
726 if (errno != EEXIST && errno != ENOTEMPTY)
727 fatal_perror( "rename '%s' to '%s'", tmp_dir, config_dir );
728 /* else it was probably created by a concurrent wine process */
730 free( tmp_dir );
731 MESSAGE( "wine: '%s' created successfully.\n", config_dir );
735 /***********************************************************************
736 * server_init_process
738 * Start the server and create the initial socket pair.
740 void server_init_process(void)
742 int size;
743 char *oldcwd;
744 obj_handle_t dummy_handle;
745 const char *server_dir = wine_get_server_dir();
747 if (!server_dir) /* this means the config dir doesn't exist */
749 create_config_dir();
750 server_dir = wine_get_server_dir();
753 /* retrieve the current directory */
754 for (size = 512; ; size *= 2)
756 if (!(oldcwd = malloc( size ))) break;
757 if (getcwd( oldcwd, size )) break;
758 free( oldcwd );
759 if (errno == ERANGE) continue;
760 oldcwd = NULL;
761 break;
764 /* connect to the server */
765 fd_socket = server_connect( oldcwd, server_dir );
767 /* switch back to the starting directory */
768 if (oldcwd)
770 chdir( oldcwd );
771 free( oldcwd );
774 /* setup the signal mask */
775 sigemptyset( &block_set );
776 sigaddset( &block_set, SIGALRM );
777 sigaddset( &block_set, SIGIO );
778 sigaddset( &block_set, SIGINT );
779 sigaddset( &block_set, SIGHUP );
780 sigaddset( &block_set, SIGUSR1 );
781 sigaddset( &block_set, SIGUSR2 );
783 /* receive the first thread request fd on the main socket */
784 NtCurrentTeb()->request_fd = receive_fd( &dummy_handle );
788 /***********************************************************************
789 * server_init_thread
791 * Send an init thread request. Return 0 if OK.
793 void server_init_thread( int unix_pid, int unix_tid, void *entry_point )
795 TEB *teb = NtCurrentTeb();
796 int version, ret;
797 int reply_pipe[2];
798 struct sigaction sig_act;
800 sig_act.sa_handler = SIG_IGN;
801 sig_act.sa_flags = 0;
802 sigemptyset( &sig_act.sa_mask );
804 /* ignore SIGPIPE so that we get a EPIPE error instead */
805 sigaction( SIGPIPE, &sig_act, NULL );
806 /* automatic child reaping to avoid zombies */
807 #ifdef SA_NOCLDWAIT
808 sig_act.sa_flags |= SA_NOCLDWAIT;
809 #endif
810 sigaction( SIGCHLD, &sig_act, NULL );
812 /* create the server->client communication pipes */
813 if (pipe( reply_pipe ) == -1) server_protocol_perror( "pipe" );
814 if (pipe( teb->wait_fd ) == -1) server_protocol_perror( "pipe" );
815 wine_server_send_fd( reply_pipe[1] );
816 wine_server_send_fd( teb->wait_fd[1] );
817 teb->reply_fd = reply_pipe[0];
818 close( reply_pipe[1] );
820 /* set close on exec flag */
821 fcntl( teb->reply_fd, F_SETFD, 1 );
822 fcntl( teb->wait_fd[0], F_SETFD, 1 );
823 fcntl( teb->wait_fd[1], F_SETFD, 1 );
825 SERVER_START_REQ( init_thread )
827 req->unix_pid = unix_pid;
828 req->unix_tid = unix_tid;
829 req->teb = teb;
830 req->entry = entry_point;
831 req->reply_fd = reply_pipe[1];
832 req->wait_fd = teb->wait_fd[1];
833 ret = wine_server_call( req );
834 teb->ClientId.UniqueProcess = (HANDLE)reply->pid;
835 teb->ClientId.UniqueThread = (HANDLE)reply->tid;
836 version = reply->version;
838 SERVER_END_REQ;
840 if (ret) server_protocol_error( "init_thread failed with status %x\n", ret );
841 if (version != SERVER_PROTOCOL_VERSION)
842 server_protocol_error( "version mismatch %d/%d.\n"
843 "Your %s binary was not upgraded correctly,\n"
844 "or you have an older one somewhere in your PATH.\n"
845 "Or maybe the wrong wineserver is still running?\n",
846 version, SERVER_PROTOCOL_VERSION,
847 (version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );