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>
58 #include "wine/library.h"
59 #include "wine/pthread.h"
60 #include "wine/server.h"
61 #include "wine/debug.h"
63 #include "ntdll_misc.h"
65 WINE_DEFAULT_DEBUG_CHANNEL(server);
67 /* Some versions of glibc don't define this */
72 #define SOCKETNAME "socket" /* name of the socket file */
73 #define LOCKNAME "lock" /* name of the lock file */
75 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
76 /* data structure used to pass an fd with sendmsg/recvmsg */
79 int len; /* size of structure */
80 int level; /* SOL_SOCKET */
81 int type; /* SCM_RIGHTS */
82 int fd; /* fd to pass */
84 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
86 static sigset_t block_set; /* signals to block during server calls */
87 static int fd_socket = -1; /* socket to exchange file descriptors with the server */
90 static void fatal_error( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
91 static void fatal_perror( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
92 static void server_connect_error( const char *serverdir ) __attribute__((noreturn));
95 /* die on a fatal error; use only during initialization */
96 static void fatal_error( const char *err, ... )
100 va_start( args, err );
101 fprintf( stderr, "wine: " );
102 vfprintf( stderr, err, args );
107 /* die on a fatal error; use only during initialization */
108 static void fatal_perror( const char *err, ... )
112 va_start( args, err );
113 fprintf( stderr, "wine: " );
114 vfprintf( stderr, err, args );
121 /***********************************************************************
122 * server_abort_thread
124 void server_abort_thread( int status )
126 sigprocmask( SIG_BLOCK, &block_set, NULL );
127 close( NtCurrentTeb()->wait_fd[0] );
128 close( NtCurrentTeb()->wait_fd[1] );
129 close( NtCurrentTeb()->reply_fd );
130 close( NtCurrentTeb()->request_fd );
131 wine_pthread_abort_thread( status );
135 /***********************************************************************
136 * server_protocol_error
138 void server_protocol_error( const char *err, ... )
142 va_start( args, err );
143 fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
144 vfprintf( stderr, err, args );
146 server_abort_thread(1);
150 /***********************************************************************
151 * server_protocol_perror
153 void server_protocol_perror( const char *err )
155 fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
157 server_abort_thread(1);
161 /***********************************************************************
164 * Send a request to the server.
166 static void send_request( const struct __server_request_info *req )
171 if (!req->u.req.request_header.request_size)
173 if ((ret = write( NtCurrentTeb()->request_fd, &req->u.req,
174 sizeof(req->u.req) )) == sizeof(req->u.req)) return;
179 struct iovec vec[__SERVER_MAX_DATA+1];
181 vec[0].iov_base = (void *)&req->u.req;
182 vec[0].iov_len = sizeof(req->u.req);
183 for (i = 0; i < req->data_count; i++)
185 vec[i+1].iov_base = (void *)req->data[i].ptr;
186 vec[i+1].iov_len = req->data[i].size;
188 if ((ret = writev( NtCurrentTeb()->request_fd, vec, i+1 )) ==
189 req->u.req.request_header.request_size + sizeof(req->u.req)) return;
192 if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
193 if (errno == EPIPE) server_abort_thread(0);
194 server_protocol_perror( "write" );
198 /***********************************************************************
201 * Read data from the reply buffer; helper for wait_reply.
203 static void read_reply_data( void *buffer, size_t size )
209 if ((ret = read( NtCurrentTeb()->reply_fd, buffer, size )) > 0)
211 if (!(size -= ret)) return;
212 buffer = (char *)buffer + ret;
216 if (errno == EINTR) continue;
217 if (errno == EPIPE) break;
218 server_protocol_perror("read");
220 /* the server closed the connection; time to die... */
221 server_abort_thread(0);
225 /***********************************************************************
228 * Wait for a reply from the server.
230 inline static void wait_reply( struct __server_request_info *req )
232 read_reply_data( &req->u.reply, sizeof(req->u.reply) );
233 if (req->u.reply.reply_header.reply_size)
234 read_reply_data( req->reply_data, req->u.reply.reply_header.reply_size );
238 /***********************************************************************
239 * wine_server_call (NTDLL.@)
241 * Perform a server call.
244 * req_ptr [I/O] Function dependent data
247 * Depends on server function being called, but usually an NTSTATUS code.
250 * Use the SERVER_START_REQ and SERVER_END_REQ to help you fill out the
251 * server request structure for the particular call. E.g:
252 *| SERVER_START_REQ( event_op )
254 *| req->handle = handle;
255 *| req->op = SET_EVENT;
256 *| ret = wine_server_call( req );
260 unsigned int wine_server_call( void *req_ptr )
262 struct __server_request_info * const req = req_ptr;
265 sigprocmask( SIG_BLOCK, &block_set, &old_set );
268 sigprocmask( SIG_SETMASK, &old_set, NULL );
269 return req->u.reply.reply_header.error;
273 /***********************************************************************
274 * wine_server_send_fd (NTDLL.@)
276 * Send a file descriptor to the server.
279 * fd [I] file descriptor to send
284 void wine_server_send_fd( int fd )
286 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
290 struct msghdr msghdr;
294 vec.iov_base = (void *)&data;
295 vec.iov_len = sizeof(data);
297 msghdr.msg_name = NULL;
298 msghdr.msg_namelen = 0;
299 msghdr.msg_iov = &vec;
300 msghdr.msg_iovlen = 1;
302 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
303 msghdr.msg_accrights = (void *)&fd;
304 msghdr.msg_accrightslen = sizeof(fd);
305 #else /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
306 cmsg.len = sizeof(cmsg);
307 cmsg.level = SOL_SOCKET;
308 cmsg.type = SCM_RIGHTS;
310 msghdr.msg_control = &cmsg;
311 msghdr.msg_controllen = sizeof(cmsg);
312 msghdr.msg_flags = 0;
313 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
315 data.tid = GetCurrentThreadId();
320 if ((ret = sendmsg( fd_socket, &msghdr, 0 )) == sizeof(data)) return;
321 if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
322 if (errno == EINTR) continue;
323 if (errno == EPIPE) server_abort_thread(0);
324 server_protocol_perror( "sendmsg" );
329 /***********************************************************************
332 * Receive a file descriptor passed from the server.
334 static int receive_fd( obj_handle_t *handle )
339 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
340 struct msghdr msghdr;
343 msghdr.msg_accrights = (void *)&fd;
344 msghdr.msg_accrightslen = sizeof(fd);
345 #else /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
346 struct msghdr msghdr;
349 cmsg.len = sizeof(cmsg);
350 cmsg.level = SOL_SOCKET;
351 cmsg.type = SCM_RIGHTS;
353 msghdr.msg_control = &cmsg;
354 msghdr.msg_controllen = sizeof(cmsg);
355 msghdr.msg_flags = 0;
356 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
358 msghdr.msg_name = NULL;
359 msghdr.msg_namelen = 0;
360 msghdr.msg_iov = &vec;
361 msghdr.msg_iovlen = 1;
362 vec.iov_base = (void *)handle;
363 vec.iov_len = sizeof(*handle);
367 if ((ret = recvmsg( fd_socket, &msghdr, 0 )) > 0)
369 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
372 if (fd == -1) server_protocol_error( "no fd received for handle %d\n", *handle );
373 fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
377 if (errno == EINTR) continue;
378 if (errno == EPIPE) break;
379 server_protocol_perror("recvmsg");
381 /* the server closed the connection; time to die... */
382 server_abort_thread(0);
386 /***********************************************************************
389 * Store the cached fd value for a given handle back into the server.
390 * Returns the new fd, which can be different if there was already an
391 * fd in the cache for that handle.
393 inline static int store_cached_fd( int *fd, obj_handle_t handle )
397 SERVER_START_REQ( set_handle_info )
399 req->handle = handle;
403 if (!(ret = wine_server_call( req )))
405 if (reply->cur_fd != *fd)
407 /* someone was here before us */
423 /***********************************************************************
424 * wine_server_fd_to_handle (NTDLL.@)
426 * Allocate a file handle for a Unix file descriptor.
429 * fd [I] Unix file descriptor.
430 * access [I] Win32 access flags.
431 * inherit [I] Indicates whether this handle is inherited by child processes.
432 * handle [O] Address where Wine file handle will be stored.
437 int wine_server_fd_to_handle( int fd, unsigned int access, int inherit, obj_handle_t *handle )
442 wine_server_send_fd( fd );
444 SERVER_START_REQ( alloc_file_handle )
446 req->access = access;
447 req->inherit = inherit;
449 if (!(ret = wine_server_call( req ))) *handle = reply->handle;
456 /***********************************************************************
457 * wine_server_handle_to_fd (NTDLL.@)
459 * Retrieve the file descriptor corresponding to a file handle.
462 * handle [I] Wine file handle.
463 * access [I] Win32 file access rights requested.
464 * unix_fd [O] Address where Unix file descriptor will be stored.
465 * flags [O] Address where the Unix flags associated with file will be stored. Optional.
470 int wine_server_handle_to_fd( obj_handle_t handle, unsigned int access, int *unix_fd, int *flags )
472 obj_handle_t fd_handle;
478 SERVER_START_REQ( get_handle_fd )
480 req->handle = handle;
481 req->access = access;
482 if (!(ret = wine_server_call( req ))) fd = reply->fd;
483 if (flags) *flags = reply->flags;
490 /* it wasn't in the cache, get it from the server */
491 fd = receive_fd( &fd_handle );
492 /* and store it back into the cache */
493 ret = store_cached_fd( &fd, fd_handle );
496 if (fd_handle == handle) break;
497 /* if we received a different handle this means there was
498 * a race with another thread; we restart everything from
499 * scratch in this case.
503 if ((fd != -1) && ((fd = dup(fd)) == -1)) return STATUS_TOO_MANY_OPENED_FILES;
505 return STATUS_SUCCESS;
509 /***********************************************************************
510 * wine_server_release_fd (NTDLL.@)
512 * Release the Unix file descriptor returned by wine_server_handle_to_fd.
515 * handle [I] Wine file handle.
516 * unix_fd [I] Unix file descriptor to release.
521 void wine_server_release_fd( obj_handle_t handle, int unix_fd )
527 /***********************************************************************
530 * Start a new wine server.
532 static void start_server( const char *oldcwd )
534 static int started; /* we only try once */
542 if (pid == -1) fatal_perror( "fork" );
545 argv[0] = "wineserver";
546 argv[1] = TRACE_ON(server) ? "-d" : NULL;
548 /* if server is explicitly specified, use this */
549 if ((p = getenv("WINESERVER")))
551 if (p[0] != '/' && oldcwd[0] == '/') /* make it an absolute path */
553 if (!(path = malloc( strlen(oldcwd) + strlen(p) + 1 )))
554 fatal_error( "out of memory\n" );
555 sprintf( path, "%s/%s", oldcwd, p );
558 wine_exec_wine_binary( p, argv, NULL, FALSE );
559 fatal_perror( "could not exec the server '%s'\n"
560 " specified in the WINESERVER environment variable", p );
562 /* now use the standard search strategy */
563 wine_exec_wine_binary( argv[0], argv, NULL, FALSE );
564 fatal_error( "could not exec wineserver\n" );
566 waitpid( pid, &status, 0 );
567 status = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
568 if (status == 2) return; /* server lock held by someone else, will retry later */
569 if (status) exit(status); /* server failed */
575 /***********************************************************************
576 * server_connect_error
578 * Try to display a meaningful explanation of why we couldn't connect
581 static void server_connect_error( const char *serverdir )
586 if ((fd = open( LOCKNAME, O_WRONLY )) == -1)
587 fatal_error( "for some mysterious reason, the wine server never started.\n" );
590 fl.l_whence = SEEK_SET;
593 if (fcntl( fd, F_GETLK, &fl ) != -1)
595 if (fl.l_type == F_WRLCK) /* the file is locked */
596 fatal_error( "a wine server seems to be running, but I cannot connect to it.\n"
597 " You probably need to kill that process (it might be pid %d).\n",
599 fatal_error( "for some mysterious reason, the wine server failed to run.\n" );
601 fatal_error( "the file system of '%s' doesn't support locks,\n"
602 " and there is a 'socket' file in that directory that prevents wine from starting.\n"
603 " You should make sure no wine server is running, remove that file and try again.\n",
608 /***********************************************************************
611 * Attempt to connect to an existing server socket.
612 * We need to be in the server directory already.
614 static int server_connect( const char *oldcwd, const char *serverdir )
616 struct sockaddr_un addr;
620 /* chdir to the server directory */
621 if (chdir( serverdir ) == -1)
623 if (errno != ENOENT) fatal_perror( "chdir to %s", serverdir );
625 if (chdir( serverdir ) == -1) fatal_perror( "chdir to %s", serverdir );
628 /* make sure we are at the right place */
629 if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
630 if (st.st_uid != getuid()) fatal_error( "'%s' is not owned by you\n", serverdir );
631 if (st.st_mode & 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir );
633 for (retry = 0; retry < 6; retry++)
635 /* if not the first try, wait a bit to leave the previous server time to exit */
638 usleep( 100000 * retry * retry );
639 start_server( oldcwd );
640 if (lstat( SOCKETNAME, &st ) == -1) continue; /* still no socket, wait a bit more */
642 else if (lstat( SOCKETNAME, &st ) == -1) /* check for an already existing socket */
644 if (errno != ENOENT) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
645 start_server( oldcwd );
646 if (lstat( SOCKETNAME, &st ) == -1) continue; /* still no socket, wait a bit more */
649 /* make sure the socket is sane (ISFIFO needed for Solaris) */
650 if (!S_ISSOCK(st.st_mode) && !S_ISFIFO(st.st_mode))
651 fatal_error( "'%s/%s' is not a socket\n", serverdir, SOCKETNAME );
652 if (st.st_uid != getuid())
653 fatal_error( "'%s/%s' is not owned by you\n", serverdir, SOCKETNAME );
655 /* try to connect to it */
656 addr.sun_family = AF_UNIX;
657 strcpy( addr.sun_path, SOCKETNAME );
658 slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
659 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
662 if ((s = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
663 if (connect( s, (struct sockaddr *)&addr, slen ) != -1)
665 fcntl( s, F_SETFD, 1 ); /* set close on exec flag */
670 server_connect_error( serverdir );
674 /***********************************************************************
677 * Remove a directory and all its contents; helper for create_config_dir.
679 static void rm_rf( const char *path )
681 int err = errno; /* preserve errno */
687 if (!(buffer = malloc( strlen(path) + 256 + 1 ))) goto done;
688 strcpy( buffer, path );
689 p = buffer + strlen(buffer);
692 if ((dir = opendir( path )))
694 while ((de = readdir( dir )))
696 if (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." )) continue;
697 strcpy( p, de->d_name );
698 if (unlink( buffer ) != -1) continue;
699 if (errno == EISDIR ||
700 (errno == EPERM && !lstat( buffer, &st ) && S_ISDIR(st.st_mode)))
702 /* recurse in the sub-directory */
715 /***********************************************************************
718 * Create the wine configuration dir (~/.wine).
720 static void create_config_dir(void)
722 const char *config_dir = wine_get_config_dir();
727 if (!(tmp_dir = malloc( strlen(config_dir) + sizeof("-XXXXXX") )))
728 fatal_error( "out of memory\n" );
729 strcpy( tmp_dir, config_dir );
730 strcat( tmp_dir, "-XXXXXX" );
731 if ((fd = mkstemps( tmp_dir, 0 )) == -1)
732 fatal_perror( "can't get temp file name for %s", config_dir );
735 if (mkdir( tmp_dir, 0777 ) == -1)
736 fatal_perror( "cannot create temp dir %s", tmp_dir );
738 MESSAGE( "wine: creating configuration directory '%s'...\n", config_dir );
743 fatal_perror( "fork" );
749 argv[0] = "wineprefixcreate";
752 argv[3] = "--prefix";
755 wine_exec_wine_binary( argv[0], (char **)argv, NULL, FALSE );
757 fatal_perror( "could not exec wineprefixcreate" );
763 while ((wret = waitpid( pid, &status, 0 )) != pid)
765 if (wret == -1 && errno != EINTR) fatal_perror( "wait4" );
767 if (!WIFEXITED(status) || WEXITSTATUS(status))
770 fatal_error( "wineprefixcreate failed while creating '%s'.\n", config_dir );
773 if (rename( tmp_dir, config_dir ) == -1)
776 if (errno != EEXIST && errno != ENOTEMPTY)
777 fatal_perror( "rename '%s' to '%s'", tmp_dir, config_dir );
778 /* else it was probably created by a concurrent wine process */
781 MESSAGE( "wine: '%s' created successfully.\n", config_dir );
785 /***********************************************************************
786 * server_init_process
788 * Start the server and create the initial socket pair.
790 void server_init_process(void)
794 obj_handle_t dummy_handle;
795 const char *server_dir = wine_get_server_dir();
797 if (!server_dir) /* this means the config dir doesn't exist */
800 server_dir = wine_get_server_dir();
803 /* retrieve the current directory */
804 for (size = 512; ; size *= 2)
806 if (!(oldcwd = malloc( size ))) break;
807 if (getcwd( oldcwd, size )) break;
809 if (errno == ERANGE) continue;
814 /* connect to the server */
815 fd_socket = server_connect( oldcwd, server_dir );
817 /* switch back to the starting directory */
824 /* setup the signal mask */
825 sigemptyset( &block_set );
826 sigaddset( &block_set, SIGALRM );
827 sigaddset( &block_set, SIGIO );
828 sigaddset( &block_set, SIGINT );
829 sigaddset( &block_set, SIGHUP );
830 sigaddset( &block_set, SIGUSR1 );
831 sigaddset( &block_set, SIGUSR2 );
832 sigaddset( &block_set, SIGCHLD );
834 /* receive the first thread request fd on the main socket */
835 NtCurrentTeb()->request_fd = receive_fd( &dummy_handle );
839 /***********************************************************************
842 * Send an init thread request. Return 0 if OK.
844 void server_init_thread( int unix_pid, int unix_tid, void *entry_point )
846 TEB *teb = NtCurrentTeb();
849 struct sigaction sig_act;
851 sig_act.sa_handler = SIG_IGN;
852 sig_act.sa_flags = 0;
853 sigemptyset( &sig_act.sa_mask );
855 /* ignore SIGPIPE so that we get an EPIPE error instead */
856 sigaction( SIGPIPE, &sig_act, NULL );
857 /* automatic child reaping to avoid zombies */
859 sig_act.sa_flags |= SA_NOCLDWAIT;
861 sigaction( SIGCHLD, &sig_act, NULL );
863 /* create the server->client communication pipes */
864 if (pipe( reply_pipe ) == -1) server_protocol_perror( "pipe" );
865 if (pipe( teb->wait_fd ) == -1) server_protocol_perror( "pipe" );
866 wine_server_send_fd( reply_pipe[1] );
867 wine_server_send_fd( teb->wait_fd[1] );
868 teb->reply_fd = reply_pipe[0];
869 close( reply_pipe[1] );
871 /* set close on exec flag */
872 fcntl( teb->reply_fd, F_SETFD, 1 );
873 fcntl( teb->wait_fd[0], F_SETFD, 1 );
874 fcntl( teb->wait_fd[1], F_SETFD, 1 );
876 SERVER_START_REQ( init_thread )
878 req->unix_pid = unix_pid;
879 req->unix_tid = unix_tid;
881 req->entry = entry_point;
882 req->reply_fd = reply_pipe[1];
883 req->wait_fd = teb->wait_fd[1];
884 ret = wine_server_call( req );
885 teb->ClientId.UniqueProcess = (HANDLE)reply->pid;
886 teb->ClientId.UniqueThread = (HANDLE)reply->tid;
887 version = reply->version;
891 if (ret) server_protocol_error( "init_thread failed with status %x\n", ret );
892 if (version != SERVER_PROTOCOL_VERSION)
893 server_protocol_error( "version mismatch %d/%d.\n"
894 "Your %s binary was not upgraded correctly,\n"
895 "or you have an older one somewhere in your PATH.\n"
896 "Or maybe the wrong wineserver is still running?\n",
897 version, SERVER_PROTOCOL_VERSION,
898 (version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );