2 * Client part of the client/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"
32 #include <sys/types.h>
33 #ifdef HAVE_SYS_SOCKET_H
34 # include <sys/socket.h>
36 #ifdef HAVE_SYS_WAIT_H
40 #ifdef HAVE_SYS_MMAN_H
49 #include "wine/server.h"
53 /* Some versions of glibc don't define this */
58 #define CONFDIR "/.wine" /* directory for Wine config relative to $HOME */
59 #define SERVERDIR "/wineserver-" /* server socket directory (hostname appended) */
60 #define SOCKETNAME "socket" /* name of the socket file */
62 #ifndef HAVE_MSGHDR_ACCRIGHTS
63 /* data structure used to pass an fd with sendmsg/recvmsg */
66 int len
; /* sizeof structure */
67 int level
; /* SOL_SOCKET */
68 int type
; /* SCM_RIGHTS */
69 int fd
; /* fd to pass */
71 #endif /* HAVE_MSGHDR_ACCRIGHTS */
73 static void *boot_thread_id
;
74 static sigset_t block_set
; /* signals to block during server calls */
75 static int fd_socket
; /* socket to exchange file descriptors with the server */
77 /* die on a fatal error; use only during initialization */
78 static void fatal_error( const char *err
, ... ) WINE_NORETURN
;
79 static void fatal_error( const char *err
, ... )
83 va_start( args
, err
);
84 fprintf( stderr
, "wine: " );
85 vfprintf( stderr
, err
, args
);
90 /* die on a fatal error; use only during initialization */
91 static void fatal_perror( const char *err
, ... ) WINE_NORETURN
;
92 static void fatal_perror( const char *err
, ... )
96 va_start( args
, err
);
97 fprintf( stderr
, "wine: " );
98 vfprintf( stderr
, err
, args
);
104 /***********************************************************************
105 * server_protocol_error
107 void server_protocol_error( const char *err
, ... )
111 va_start( args
, err
);
112 fprintf( stderr
, "wine client error:%p: ", NtCurrentTeb()->tid
);
113 vfprintf( stderr
, err
, args
);
115 SYSDEPS_AbortThread(1);
119 /***********************************************************************
120 * server_protocol_perror
122 void server_protocol_perror( const char *err
)
124 fprintf( stderr
, "wine client error:%p: ", NtCurrentTeb()->tid
);
126 SYSDEPS_AbortThread(1);
130 /***********************************************************************
133 * Send a request to the server.
135 static void send_request( const struct __server_request_info
*req
)
139 if (!req
->u
.req
.request_header
.request_size
)
141 if ((ret
= write( NtCurrentTeb()->request_fd
, &req
->u
.req
,
142 sizeof(req
->u
.req
) )) == sizeof(req
->u
.req
)) return;
147 struct iovec vec
[__SERVER_MAX_DATA
+1];
149 vec
[0].iov_base
= (void *)&req
->u
.req
;
150 vec
[0].iov_len
= sizeof(req
->u
.req
);
151 for (i
= 0; i
< req
->data_count
; i
++)
153 vec
[i
+1].iov_base
= (void *)req
->data
[i
].ptr
;
154 vec
[i
+1].iov_len
= req
->data
[i
].size
;
156 if ((ret
= writev( NtCurrentTeb()->request_fd
, vec
, i
+1 )) ==
157 req
->u
.req
.request_header
.request_size
+ sizeof(req
->u
.req
)) return;
160 if (ret
>= 0) server_protocol_error( "partial write %d\n", ret
);
161 if (errno
== EPIPE
) SYSDEPS_AbortThread(0);
162 server_protocol_perror( "sendmsg" );
166 /***********************************************************************
169 * Read data from the reply buffer; helper for wait_reply.
171 static void read_reply_data( void *buffer
, size_t size
)
177 if ((ret
= read( NtCurrentTeb()->reply_fd
, buffer
, size
)) > 0)
179 if (!(size
-= ret
)) return;
180 buffer
= (char *)buffer
+ ret
;
184 if (errno
== EINTR
) continue;
185 if (errno
== EPIPE
) break;
186 server_protocol_perror("read");
188 /* the server closed the connection; time to die... */
189 SYSDEPS_AbortThread(0);
193 /***********************************************************************
196 * Wait for a reply from the server.
198 inline static void wait_reply( struct __server_request_info
*req
)
200 read_reply_data( &req
->u
.reply
, sizeof(req
->u
.reply
) );
201 if (req
->u
.reply
.reply_header
.reply_size
)
202 read_reply_data( req
->reply_data
, req
->u
.reply
.reply_header
.reply_size
);
206 /***********************************************************************
207 * wine_server_call (NTDLL.@)
209 * Perform a server call.
211 unsigned int wine_server_call( void *req_ptr
)
213 struct __server_request_info
* const req
= req_ptr
;
216 memset( (char *)&req
->u
.req
+ req
->size
, 0, sizeof(req
->u
.req
) - req
->size
);
217 sigprocmask( SIG_BLOCK
, &block_set
, &old_set
);
220 sigprocmask( SIG_SETMASK
, &old_set
, NULL
);
221 return req
->u
.reply
.reply_header
.error
;
225 /***********************************************************************
226 * wine_server_send_fd
228 * Send a file descriptor to the server.
230 void wine_server_send_fd( int fd
)
232 #ifndef HAVE_MSGHDR_ACCRIGHTS
236 struct msghdr msghdr
;
240 vec
.iov_base
= (void *)&data
;
241 vec
.iov_len
= sizeof(data
);
243 msghdr
.msg_name
= NULL
;
244 msghdr
.msg_namelen
= 0;
245 msghdr
.msg_iov
= &vec
;
246 msghdr
.msg_iovlen
= 1;
248 #ifdef HAVE_MSGHDR_ACCRIGHTS
249 msghdr
.msg_accrights
= (void *)&fd
;
250 msghdr
.msg_accrightslen
= sizeof(fd
);
251 #else /* HAVE_MSGHDR_ACCRIGHTS */
252 cmsg
.len
= sizeof(cmsg
);
253 cmsg
.level
= SOL_SOCKET
;
254 cmsg
.type
= SCM_RIGHTS
;
256 msghdr
.msg_control
= &cmsg
;
257 msghdr
.msg_controllen
= sizeof(cmsg
);
258 msghdr
.msg_flags
= 0;
259 #endif /* HAVE_MSGHDR_ACCRIGHTS */
261 data
.tid
= (void *)GetCurrentThreadId();
266 if ((ret
= sendmsg( fd_socket
, &msghdr
, 0 )) == sizeof(data
)) return;
267 if (ret
>= 0) server_protocol_error( "partial write %d\n", ret
);
268 if (errno
== EINTR
) continue;
269 if (errno
== EPIPE
) SYSDEPS_AbortThread(0);
270 server_protocol_perror( "sendmsg" );
275 /***********************************************************************
278 * Receive a file descriptor passed from the server.
280 static int receive_fd( handle_t
*handle
)
285 #ifdef HAVE_MSGHDR_ACCRIGHTS
286 struct msghdr msghdr
;
289 msghdr
.msg_accrights
= (void *)&fd
;
290 msghdr
.msg_accrightslen
= sizeof(fd
);
291 #else /* HAVE_MSGHDR_ACCRIGHTS */
292 struct msghdr msghdr
;
295 cmsg
.len
= sizeof(cmsg
);
296 cmsg
.level
= SOL_SOCKET
;
297 cmsg
.type
= SCM_RIGHTS
;
299 msghdr
.msg_control
= &cmsg
;
300 msghdr
.msg_controllen
= sizeof(cmsg
);
301 msghdr
.msg_flags
= 0;
302 #endif /* HAVE_MSGHDR_ACCRIGHTS */
304 msghdr
.msg_name
= NULL
;
305 msghdr
.msg_namelen
= 0;
306 msghdr
.msg_iov
= &vec
;
307 msghdr
.msg_iovlen
= 1;
308 vec
.iov_base
= (void *)handle
;
309 vec
.iov_len
= sizeof(*handle
);
313 if ((ret
= recvmsg( fd_socket
, &msghdr
, 0 )) > 0)
315 #ifndef HAVE_MSGHDR_ACCRIGHTS
318 if (fd
== -1) server_protocol_error( "no fd received for handle %d\n", *handle
);
319 fcntl( fd
, F_SETFD
, 1 ); /* set close on exec flag */
323 if (errno
== EINTR
) continue;
324 if (errno
== EPIPE
) break;
325 server_protocol_perror("recvmsg");
327 /* the server closed the connection; time to die... */
328 SYSDEPS_AbortThread(0);
332 /***********************************************************************
335 * Store the cached fd value for a given handle back into the server.
336 * Returns the new fd, which can be different if there was already an
337 * fd in the cache for that handle.
339 inline static int store_cached_fd( int fd
, handle_t handle
)
341 SERVER_START_REQ( set_handle_info
)
343 req
->handle
= handle
;
347 if (!wine_server_call( req
))
349 if (reply
->cur_fd
!= fd
)
351 /* someone was here before us */
367 /***********************************************************************
368 * wine_server_handle_to_fd (NTDLL.@)
370 * Retrieve the Unix fd corresponding to a file handle.
372 int wine_server_handle_to_fd( handle_t handle
, unsigned int access
, int *unix_fd
,
373 enum fd_type
*type
, int *flags
)
381 SERVER_START_REQ( get_handle_fd
)
383 req
->handle
= handle
;
384 req
->access
= access
;
385 if (!(ret
= wine_server_call( req
))) fd
= reply
->fd
;
386 if (type
) *type
= reply
->type
;
387 if (flags
) *flags
= reply
->flags
;
394 /* it wasn't in the cache, get it from the server */
395 fd
= receive_fd( &fd_handle
);
396 /* and store it back into the cache */
397 fd
= store_cached_fd( fd
, fd_handle
);
399 if (fd_handle
== handle
) break;
400 /* if we received a different handle this means there was
401 * a race with another thread; we restart everything from
402 * scratch in this case.
406 if ((fd
!= -1) && ((fd
= dup(fd
)) == -1)) return STATUS_TOO_MANY_OPENED_FILES
;
408 return STATUS_SUCCESS
;
412 /***********************************************************************
415 * Return the configuration directory ($WINEPREFIX or $HOME/.wine)
417 const char *get_config_dir(void)
419 static char *confdir
;
422 const char *prefix
= getenv( "WINEPREFIX" );
425 int len
= strlen(prefix
);
426 if (!(confdir
= strdup( prefix
))) fatal_error( "out of memory\n" );
427 if (len
> 1 && confdir
[len
-1] == '/') confdir
[len
-1] = 0;
431 const char *home
= getenv( "HOME" );
434 struct passwd
*pwd
= getpwuid( getuid() );
435 if (!pwd
) fatal_error( "could not find your home directory\n" );
438 if (!(confdir
= malloc( strlen(home
) + strlen(CONFDIR
) + 1 )))
439 fatal_error( "out of memory\n" );
440 strcpy( confdir
, home
);
441 strcat( confdir
, CONFDIR
);
448 /***********************************************************************
451 * Start a new wine server.
453 static void start_server( const char *oldcwd
)
455 static int started
; /* we only try once */
461 if (pid
== -1) fatal_perror( "fork" );
464 /* if server is explicitly specified, use this */
465 if ((p
= getenv("WINESERVER")))
467 if (p
[0] != '/' && oldcwd
[0] == '/') /* make it an absolute path */
469 if (!(path
= malloc( strlen(oldcwd
) + strlen(p
) + 1 )))
470 fatal_error( "out of memory\n" );
471 sprintf( path
, "%s/%s", oldcwd
, p
);
474 execl( p
, "wineserver", NULL
);
475 fatal_perror( "could not exec the server '%s'\n"
476 " specified in the WINESERVER environment variable", p
);
479 /* first try the installation dir */
480 execl( BINDIR
"/wineserver", "wineserver", NULL
);
482 /* now try the dir we were launched from */
485 if (!(path
= malloc( strlen(full_argv0
) + 20 )))
486 fatal_error( "out of memory\n" );
487 if ((p
= strrchr( strcpy( path
, full_argv0
), '/' )))
489 strcpy( p
, "/wineserver" );
490 execl( path
, "wineserver", NULL
);
495 /* finally try the path */
496 execlp( "wineserver", "wineserver", NULL
);
497 fatal_error( "could not exec wineserver\n" );
500 waitpid( pid
, &status
, 0 );
501 status
= WIFEXITED(status
) ? WEXITSTATUS(status
) : 1;
502 if (status
) exit(status
); /* server failed */
506 /***********************************************************************
509 * Attempt to connect to an existing server socket.
510 * We need to be in the server directory already.
512 static int server_connect( const char *oldcwd
, const char *serverdir
)
514 struct sockaddr_un addr
;
518 /* chdir to the server directory */
519 if (chdir( serverdir
) == -1)
521 if (errno
!= ENOENT
) fatal_perror( "chdir to %s", serverdir
);
523 if (chdir( serverdir
) == -1) fatal_perror( "chdir to %s", serverdir
);
526 /* make sure we are at the right place */
527 if (stat( ".", &st
) == -1) fatal_perror( "stat %s", serverdir
);
528 if (st
.st_uid
!= getuid()) fatal_error( "'%s' is not owned by you\n", serverdir
);
529 if (st
.st_mode
& 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir
);
531 for (retry
= 0; retry
< 3; retry
++)
533 /* if not the first try, wait a bit to leave the server time to exit */
534 if (retry
) usleep( 100000 * retry
* retry
);
536 /* check for an existing socket */
537 if (lstat( SOCKETNAME
, &st
) == -1)
539 if (errno
!= ENOENT
) fatal_perror( "lstat %s/%s", serverdir
, SOCKETNAME
);
540 start_server( oldcwd
);
541 if (lstat( SOCKETNAME
, &st
) == -1) fatal_perror( "lstat %s/%s", serverdir
, SOCKETNAME
);
544 /* make sure the socket is sane (ISFIFO needed for Solaris) */
545 if (!S_ISSOCK(st
.st_mode
) && !S_ISFIFO(st
.st_mode
))
546 fatal_error( "'%s/%s' is not a socket\n", serverdir
, SOCKETNAME
);
547 if (st
.st_uid
!= getuid())
548 fatal_error( "'%s/%s' is not owned by you\n", serverdir
, SOCKETNAME
);
550 /* try to connect to it */
551 addr
.sun_family
= AF_UNIX
;
552 strcpy( addr
.sun_path
, SOCKETNAME
);
553 slen
= sizeof(addr
) - sizeof(addr
.sun_path
) + strlen(addr
.sun_path
) + 1;
554 #ifdef HAVE_SOCKADDR_SUN_LEN
557 if ((s
= socket( AF_UNIX
, SOCK_STREAM
, 0 )) == -1) fatal_perror( "socket" );
558 if (connect( s
, (struct sockaddr
*)&addr
, slen
) != -1)
560 fcntl( s
, F_SETFD
, 1 ); /* set close on exec flag */
565 fatal_error( "file '%s/%s' exists,\n"
566 " but I cannot connect to it; maybe the wineserver has crashed?\n"
567 " If this is the case, you should remove this socket file and try again.\n",
568 serverdir
, SOCKETNAME
);
572 /***********************************************************************
575 * Start the server and create the initial socket pair.
577 void CLIENT_InitServer(void)
581 char *oldcwd
, *serverdir
;
582 const char *configdir
;
583 handle_t dummy_handle
;
585 /* retrieve the current directory */
586 for (size
= 512; ; size
*= 2)
588 if (!(oldcwd
= malloc( size
))) break;
589 if (getcwd( oldcwd
, size
)) break;
591 if (errno
== ERANGE
) continue;
596 /* if argv[0] is a relative path, make it absolute */
598 if (oldcwd
&& argv0
[0] != '/' && strchr( argv0
, '/' ))
600 char *new_argv0
= malloc( strlen(oldcwd
) + strlen(argv0
) + 2 );
603 strcpy( new_argv0
, oldcwd
);
604 strcat( new_argv0
, "/" );
605 strcat( new_argv0
, argv0
);
606 full_argv0
= new_argv0
;
610 /* get the server directory name */
611 if (gethostname( hostname
, sizeof(hostname
) ) == -1) fatal_perror( "gethostname" );
612 configdir
= get_config_dir();
613 serverdir
= malloc( strlen(configdir
) + strlen(SERVERDIR
) + strlen(hostname
) + 1 );
614 if (!serverdir
) fatal_error( "out of memory\n" );
615 strcpy( serverdir
, configdir
);
616 strcat( serverdir
, SERVERDIR
);
617 strcat( serverdir
, hostname
);
619 /* connect to the server */
620 fd_socket
= server_connect( oldcwd
, serverdir
);
622 /* switch back to the starting directory */
629 /* setup the signal mask */
630 sigemptyset( &block_set
);
631 sigaddset( &block_set
, SIGALRM
);
632 sigaddset( &block_set
, SIGIO
);
633 sigaddset( &block_set
, SIGINT
);
634 sigaddset( &block_set
, SIGHUP
);
636 /* receive the first thread request fd on the main socket */
637 NtCurrentTeb()->request_fd
= receive_fd( &dummy_handle
);
643 /***********************************************************************
646 * Send an init thread request. Return 0 if OK.
648 void CLIENT_InitThread(void)
650 TEB
*teb
= NtCurrentTeb();
654 /* ignore SIGPIPE so that we get a EPIPE error instead */
655 signal( SIGPIPE
, SIG_IGN
);
657 /* create the server->client communication pipes */
658 if (pipe( reply_pipe
) == -1) server_protocol_perror( "pipe" );
659 if (pipe( teb
->wait_fd
) == -1) server_protocol_perror( "pipe" );
660 wine_server_send_fd( reply_pipe
[1] );
661 wine_server_send_fd( teb
->wait_fd
[1] );
662 teb
->reply_fd
= reply_pipe
[0];
664 /* set close on exec flag */
665 fcntl( teb
->reply_fd
, F_SETFD
, 1 );
666 fcntl( teb
->wait_fd
[0], F_SETFD
, 1 );
667 fcntl( teb
->wait_fd
[1], F_SETFD
, 1 );
669 SERVER_START_REQ( init_thread
)
671 req
->unix_pid
= getpid();
673 req
->entry
= teb
->entry_point
;
674 req
->reply_fd
= reply_pipe
[1];
675 req
->wait_fd
= teb
->wait_fd
[1];
676 ret
= wine_server_call( req
);
677 teb
->pid
= reply
->pid
;
678 teb
->tid
= reply
->tid
;
679 version
= reply
->version
;
680 if (reply
->boot
) boot_thread_id
= teb
->tid
;
681 else if (boot_thread_id
== teb
->tid
) boot_thread_id
= 0;
682 close( reply_pipe
[1] );
686 if (ret
) server_protocol_error( "init_thread failed with status %x\n", ret
);
687 if (version
!= SERVER_PROTOCOL_VERSION
)
688 server_protocol_error( "version mismatch %d/%d.\n"
689 "Your %s binary was not upgraded correctly,\n"
690 "or you have an older one somewhere in your PATH.\n"
691 "Or maybe the wrong wineserver is still running?\n",
692 version
, SERVER_PROTOCOL_VERSION
,
693 (version
> SERVER_PROTOCOL_VERSION
) ? "wine" : "wineserver" );
697 /***********************************************************************
700 * Signal that we have finished booting, and set debug level.
702 void CLIENT_BootDone( int debug_level
)
704 SERVER_START_REQ( boot_done
)
706 req
->debug_level
= debug_level
;
707 wine_server_call( req
);
713 /***********************************************************************
714 * CLIENT_IsBootThread
716 * Return TRUE if current thread is the boot thread.
718 int CLIENT_IsBootThread(void)
720 return (GetCurrentThreadId() == (DWORD
)boot_thread_id
);