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" );