2 * Client part of the client/server communication
4 * Copyright (C) 1998 Alexandre Julliard
17 #include <sys/types.h>
18 #ifdef HAVE_SYS_SOCKET_H
19 # include <sys/socket.h>
21 #ifdef HAVE_SYS_WAIT_H
25 #ifdef HAVE_SYS_MMAN_H
34 #include "wine/server.h"
38 /* Some versions of glibc don't define this */
43 #define CONFDIR "/.wine" /* directory for Wine config relative to $HOME */
44 #define SERVERDIR "/wineserver-" /* server socket directory (hostname appended) */
45 #define SOCKETNAME "socket" /* name of the socket file */
47 #ifndef HAVE_MSGHDR_ACCRIGHTS
48 /* data structure used to pass an fd with sendmsg/recvmsg */
51 int len; /* sizeof structure */
52 int level; /* SOL_SOCKET */
53 int type; /* SCM_RIGHTS */
54 int fd; /* fd to pass */
56 #endif /* HAVE_MSGHDR_ACCRIGHTS */
58 static void *boot_thread_id;
59 static sigset_t block_set; /* signals to block during server calls */
60 static int fd_socket; /* socket to exchange file descriptors with the server */
62 /* die on a fatal error; use only during initialization */
63 static void fatal_error( const char *err, ... ) WINE_NORETURN;
64 static void fatal_error( const char *err, ... )
68 va_start( args, err );
69 fprintf( stderr, "wine: " );
70 vfprintf( stderr, err, args );
75 /* die on a fatal error; use only during initialization */
76 static void fatal_perror( const char *err, ... ) WINE_NORETURN;
77 static void fatal_perror( const char *err, ... )
81 va_start( args, err );
82 fprintf( stderr, "wine: " );
83 vfprintf( stderr, err, args );
89 /***********************************************************************
90 * server_protocol_error
92 void server_protocol_error( const char *err, ... )
96 va_start( args, err );
97 fprintf( stderr, "wine client error:%p: ", NtCurrentTeb()->tid );
98 vfprintf( stderr, err, args );
100 SYSDEPS_ExitThread(1);
104 /***********************************************************************
105 * server_protocol_perror
107 void server_protocol_perror( const char *err )
109 fprintf( stderr, "wine client error:%p: ", NtCurrentTeb()->tid );
111 SYSDEPS_ExitThread(1);
115 /***********************************************************************
116 * __wine_server_exception_handler (NTDLL.@)
118 DWORD __wine_server_exception_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame,
119 CONTEXT *context, EXCEPTION_FRAME **pdispatcher )
121 struct __server_exception_frame *server_frame = (struct __server_exception_frame *)frame;
122 if ((record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)))
123 NtCurrentTeb()->buffer_pos = server_frame->buffer_pos;
124 return ExceptionContinueSearch;
128 /***********************************************************************
129 * wine_server_alloc_req (NTDLL.@)
131 void wine_server_alloc_req( union generic_request *req, size_t size )
133 unsigned int pos = NtCurrentTeb()->buffer_pos;
135 assert( size <= REQUEST_MAX_VAR_SIZE );
137 if (pos + size > NtCurrentTeb()->buffer_size)
138 server_protocol_error( "buffer overflow %d bytes\n",
139 pos + size - NtCurrentTeb()->buffer_pos );
141 NtCurrentTeb()->buffer_pos = pos + size;
142 req->header.var_offset = pos;
143 req->header.var_size = size;
147 /***********************************************************************
150 * Send a request to the server.
152 static void send_request( union generic_request *request )
156 if ((ret = write( NtCurrentTeb()->request_fd, request, sizeof(*request) )) == sizeof(*request))
158 if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
159 if (errno == EPIPE) SYSDEPS_ExitThread(0);
160 server_protocol_perror( "sendmsg" );
163 /***********************************************************************
166 * Wait for a reply from the server.
168 static void wait_reply( union generic_request *req )
174 if ((ret = read( NtCurrentTeb()->reply_fd, req, sizeof(*req) )) == sizeof(*req))
177 if (ret > 0) server_protocol_error( "partial read %d\n", ret );
178 if (errno == EINTR) continue;
179 if (errno == EPIPE) break;
180 server_protocol_perror("read");
182 /* the server closed the connection; time to die... */
183 SYSDEPS_ExitThread(0);
187 /***********************************************************************
188 * wine_server_call (NTDLL.@)
190 * Perform a server call.
192 unsigned int wine_server_call( union generic_request *req, size_t size )
196 memset( (char *)req + size, 0, sizeof(*req) - size );
197 sigprocmask( SIG_BLOCK, &block_set, &old_set );
200 sigprocmask( SIG_SETMASK, &old_set, NULL );
201 return req->header.error;
205 /***********************************************************************
206 * wine_server_send_fd
208 * Send a file descriptor to the server.
210 void wine_server_send_fd( int fd )
212 #ifndef HAVE_MSGHDR_ACCRIGHTS
216 struct msghdr msghdr;
220 vec.iov_base = (void *)&data;
221 vec.iov_len = sizeof(data);
223 msghdr.msg_name = NULL;
224 msghdr.msg_namelen = 0;
225 msghdr.msg_iov = &vec;
226 msghdr.msg_iovlen = 1;
228 #ifdef HAVE_MSGHDR_ACCRIGHTS
229 msghdr.msg_accrights = (void *)&fd;
230 msghdr.msg_accrightslen = sizeof(fd);
231 #else /* HAVE_MSGHDR_ACCRIGHTS */
232 cmsg.len = sizeof(cmsg);
233 cmsg.level = SOL_SOCKET;
234 cmsg.type = SCM_RIGHTS;
236 msghdr.msg_control = &cmsg;
237 msghdr.msg_controllen = sizeof(cmsg);
238 msghdr.msg_flags = 0;
239 #endif /* HAVE_MSGHDR_ACCRIGHTS */
241 data.tid = (void *)GetCurrentThreadId();
246 if ((ret = sendmsg( fd_socket, &msghdr, 0 )) == sizeof(data)) return;
247 if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
248 if (errno == EINTR) continue;
249 if (errno == EPIPE) SYSDEPS_ExitThread(0);
250 server_protocol_perror( "sendmsg" );
255 /***********************************************************************
258 * Receive a file descriptor passed from the server.
260 static int receive_fd( handle_t *handle )
265 #ifdef HAVE_MSGHDR_ACCRIGHTS
266 struct msghdr msghdr;
269 msghdr.msg_accrights = (void *)&fd;
270 msghdr.msg_accrightslen = sizeof(fd);
271 #else /* HAVE_MSGHDR_ACCRIGHTS */
272 struct msghdr msghdr;
275 cmsg.len = sizeof(cmsg);
276 cmsg.level = SOL_SOCKET;
277 cmsg.type = SCM_RIGHTS;
279 msghdr.msg_control = &cmsg;
280 msghdr.msg_controllen = sizeof(cmsg);
281 msghdr.msg_flags = 0;
282 #endif /* HAVE_MSGHDR_ACCRIGHTS */
284 msghdr.msg_name = NULL;
285 msghdr.msg_namelen = 0;
286 msghdr.msg_iov = &vec;
287 msghdr.msg_iovlen = 1;
288 vec.iov_base = (void *)handle;
289 vec.iov_len = sizeof(*handle);
293 if ((ret = recvmsg( fd_socket, &msghdr, 0 )) > 0)
295 #ifndef HAVE_MSGHDR_ACCRIGHTS
298 if (fd == -1) server_protocol_error( "no fd received for handle %d\n", *handle );
299 fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
303 if (errno == EINTR) continue;
304 if (errno == EPIPE) break;
305 server_protocol_perror("recvmsg");
307 /* the server closed the connection; time to die... */
308 SYSDEPS_ExitThread(0);
312 /***********************************************************************
313 * wine_server_recv_fd
315 * Receive a file descriptor passed from the server.
316 * The file descriptor must not be closed.
317 * Return -2 if a race condition stole our file descriptor.
319 int wine_server_recv_fd( handle_t handle )
323 int fd = receive_fd( &fd_handle );
325 /* now store it in the server fd cache for this handle */
327 SERVER_START_REQ( set_handle_info )
329 req->handle = fd_handle;
335 if (req->cur_fd != fd)
337 /* someone was here before us */
350 if (handle != fd_handle) fd = -2; /* not the one we expected */
355 /***********************************************************************
358 * Return the configuration directory ($WINEPREFIX or $HOME/.wine)
360 const char *get_config_dir(void)
362 static char *confdir;
365 const char *prefix = getenv( "WINEPREFIX" );
368 int len = strlen(prefix);
369 if (!(confdir = strdup( prefix ))) fatal_error( "out of memory\n" );
370 if (len > 1 && confdir[len-1] == '/') confdir[len-1] = 0;
374 const char *home = getenv( "HOME" );
377 struct passwd *pwd = getpwuid( getuid() );
378 if (!pwd) fatal_error( "could not find your home directory\n" );
381 if (!(confdir = malloc( strlen(home) + strlen(CONFDIR) + 1 )))
382 fatal_error( "out of memory\n" );
383 strcpy( confdir, home );
384 strcat( confdir, CONFDIR );
391 /***********************************************************************
394 * Start a new wine server.
396 static void start_server( const char *oldcwd )
398 static int started; /* we only try once */
404 if (pid == -1) fatal_perror( "fork" );
407 /* if server is explicitly specified, use this */
408 if ((p = getenv("WINESERVER")))
410 if (p[0] != '/' && oldcwd[0] == '/') /* make it an absolute path */
412 if (!(path = malloc( strlen(oldcwd) + strlen(p) + 1 )))
413 fatal_error( "out of memory\n" );
414 sprintf( path, "%s/%s", oldcwd, p );
417 execl( p, "wineserver", NULL );
418 fatal_perror( "could not exec the server '%s'\n"
419 " specified in the WINESERVER environment variable", p );
422 /* first try the installation dir */
423 execl( BINDIR "/wineserver", "wineserver", NULL );
425 /* now try the dir we were launched from */
428 if (!(path = malloc( strlen(full_argv0) + 20 )))
429 fatal_error( "out of memory\n" );
430 if ((p = strrchr( strcpy( path, full_argv0 ), '/' )))
432 strcpy( p, "/wineserver" );
433 execl( path, "wineserver", NULL );
434 strcpy( p, "/server/wineserver" );
435 execl( path, "wineserver", NULL );
440 /* now try the path */
441 execlp( "wineserver", "wineserver", NULL );
443 /* and finally the current dir */
444 if (!(path = malloc( strlen(oldcwd) + 20 )))
445 fatal_error( "out of memory\n" );
446 p = strcpy( path, oldcwd ) + strlen( oldcwd );
447 strcpy( p, "/wineserver" );
448 execl( path, "wineserver", NULL );
449 strcpy( p, "/server/wineserver" );
450 execl( path, "wineserver", NULL );
452 fatal_error( "could not exec wineserver\n" );
455 waitpid( pid, &status, 0 );
456 status = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
457 if (status) exit(status); /* server failed */
461 /***********************************************************************
464 * Attempt to connect to an existing server socket.
465 * We need to be in the server directory already.
467 static int server_connect( const char *oldcwd, const char *serverdir )
469 struct sockaddr_un addr;
473 /* chdir to the server directory */
474 if (chdir( serverdir ) == -1)
476 if (errno != ENOENT) fatal_perror( "chdir to %s", serverdir );
478 if (chdir( serverdir ) == -1) fatal_perror( "chdir to %s", serverdir );
481 /* make sure we are at the right place */
482 if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
483 if (st.st_uid != getuid()) fatal_error( "'%s' is not owned by you\n", serverdir );
484 if (st.st_mode & 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir );
486 for (retry = 0; retry < 3; retry++)
488 /* if not the first try, wait a bit to leave the server time to exit */
489 if (retry) usleep( 100000 * retry * retry );
491 /* check for an existing socket */
492 if (lstat( SOCKETNAME, &st ) == -1)
494 if (errno != ENOENT) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
495 start_server( oldcwd );
496 if (lstat( SOCKETNAME, &st ) == -1) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
499 /* make sure the socket is sane (ISFIFO needed for Solaris) */
500 if (!S_ISSOCK(st.st_mode) && !S_ISFIFO(st.st_mode))
501 fatal_error( "'%s/%s' is not a socket\n", serverdir, SOCKETNAME );
502 if (st.st_uid != getuid())
503 fatal_error( "'%s/%s' is not owned by you\n", serverdir, SOCKETNAME );
505 /* try to connect to it */
506 addr.sun_family = AF_UNIX;
507 strcpy( addr.sun_path, SOCKETNAME );
508 slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
509 #ifdef HAVE_SOCKADDR_SUN_LEN
512 if ((s = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
513 if (connect( s, (struct sockaddr *)&addr, slen ) != -1)
515 fcntl( s, F_SETFD, 1 ); /* set close on exec flag */
520 fatal_error( "file '%s/%s' exists,\n"
521 " but I cannot connect to it; maybe the wineserver has crashed?\n"
522 " If this is the case, you should remove this socket file and try again.\n",
523 serverdir, SOCKETNAME );
527 /***********************************************************************
530 * Start the server and create the initial socket pair.
532 void CLIENT_InitServer(void)
536 char *oldcwd, *serverdir;
537 const char *configdir;
538 handle_t dummy_handle;
540 /* retrieve the current directory */
541 for (size = 512; ; size *= 2)
543 if (!(oldcwd = malloc( size ))) break;
544 if (getcwd( oldcwd, size )) break;
546 if (errno == ERANGE) continue;
551 /* if argv[0] is a relative path, make it absolute */
553 if (oldcwd && argv0[0] != '/' && strchr( argv0, '/' ))
555 char *new_argv0 = malloc( strlen(oldcwd) + strlen(argv0) + 2 );
558 strcpy( new_argv0, oldcwd );
559 strcat( new_argv0, "/" );
560 strcat( new_argv0, argv0 );
561 full_argv0 = new_argv0;
565 /* get the server directory name */
566 if (gethostname( hostname, sizeof(hostname) ) == -1) fatal_perror( "gethostname" );
567 configdir = get_config_dir();
568 serverdir = malloc( strlen(configdir) + strlen(SERVERDIR) + strlen(hostname) + 1 );
569 if (!serverdir) fatal_error( "out of memory\n" );
570 strcpy( serverdir, configdir );
571 strcat( serverdir, SERVERDIR );
572 strcat( serverdir, hostname );
574 /* connect to the server */
575 fd_socket = server_connect( oldcwd, serverdir );
577 /* switch back to the starting directory */
584 /* setup the signal mask */
585 sigemptyset( &block_set );
586 sigaddset( &block_set, SIGALRM );
587 sigaddset( &block_set, SIGIO );
588 sigaddset( &block_set, SIGINT );
589 sigaddset( &block_set, SIGHUP );
591 /* receive the first thread request fd on the main socket */
592 NtCurrentTeb()->request_fd = receive_fd( &dummy_handle );
598 /***********************************************************************
601 inline static void set_request_buffer(void)
605 unsigned int offset, size;
607 /* create a temporary file */
610 if (!(name = tmpnam(NULL))) server_protocol_perror( "tmpnam" );
611 fd = open( name, O_CREAT | O_EXCL | O_RDWR, 0600 );
612 } while ((fd == -1) && (errno == EEXIST));
614 if (fd == -1) server_protocol_perror( "create" );
617 wine_server_send_fd( fd );
619 SERVER_START_REQ( set_thread_buffer )
623 offset = req->offset;
627 if (ret) server_protocol_error( "set_thread_buffer failed with status %x\n", ret );
629 if ((NtCurrentTeb()->buffer = mmap( 0, size, PROT_READ | PROT_WRITE,
630 MAP_SHARED, fd, offset )) == (void*)-1)
631 server_protocol_perror( "mmap" );
634 NtCurrentTeb()->buffer_pos = 0;
635 NtCurrentTeb()->buffer_size = size;
639 /***********************************************************************
642 * Send an init thread request. Return 0 if OK.
644 void CLIENT_InitThread(void)
646 TEB *teb = NtCurrentTeb();
650 /* ignore SIGPIPE so that we get a EPIPE error instead */
651 signal( SIGPIPE, SIG_IGN );
653 /* create the server->client communication pipes */
654 if (pipe( reply_pipe ) == -1) server_protocol_perror( "pipe" );
655 if (pipe( teb->wait_fd ) == -1) server_protocol_perror( "pipe" );
656 wine_server_send_fd( reply_pipe[1] );
657 wine_server_send_fd( teb->wait_fd[1] );
658 teb->reply_fd = reply_pipe[0];
660 /* set close on exec flag */
661 fcntl( teb->reply_fd, F_SETFD, 1 );
662 fcntl( teb->wait_fd[0], F_SETFD, 1 );
663 fcntl( teb->wait_fd[1], F_SETFD, 1 );
665 SERVER_START_REQ( init_thread )
667 req->unix_pid = getpid();
669 req->entry = teb->entry_point;
670 req->reply_fd = reply_pipe[1];
671 req->wait_fd = teb->wait_fd[1];
675 version = req->version;
676 if (req->boot) boot_thread_id = teb->tid;
677 else if (boot_thread_id == teb->tid) boot_thread_id = 0;
678 close( reply_pipe[1] );
682 if (ret) server_protocol_error( "init_thread failed with status %x\n", ret );
683 if (version != SERVER_PROTOCOL_VERSION)
684 server_protocol_error( "version mismatch %d/%d.\n"
685 "Your %s binary was not upgraded correctly,\n"
686 "or you have an older one somewhere in your PATH.\n"
687 "Or maybe the wrong wineserver is still running?\n",
688 version, SERVER_PROTOCOL_VERSION,
689 (version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );
690 set_request_buffer();
694 /***********************************************************************
697 * Signal that we have finished booting, and set debug level.
699 void CLIENT_BootDone( int debug_level )
701 SERVER_START_REQ( boot_done )
703 req->debug_level = debug_level;
710 /***********************************************************************
711 * CLIENT_IsBootThread
713 * Return TRUE if current thread is the boot thread.
715 int CLIENT_IsBootThread(void)
717 return (GetCurrentThreadId() == (DWORD)boot_thread_id);