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
33 #include "wine/port.h"
39 /* Some versions of glibc don't define this */
44 #define CONFDIR "/.wine" /* directory for Wine config relative to $HOME */
45 #define SERVERDIR "/wineserver-" /* server socket directory (hostname appended) */
46 #define SOCKETNAME "socket" /* name of the socket file */
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 */
57 static void *boot_thread_id
;
58 static sigset_t block_set
; /* signals to block during server calls */
59 static int fd_socket
; /* socket to exchange file descriptors with the server */
61 /* die on a fatal error; use only during initialization */
62 static void fatal_error( const char *err
, ... ) WINE_NORETURN
;
63 static void fatal_error( const char *err
, ... )
67 va_start( args
, err
);
68 fprintf( stderr
, "wine: " );
69 vfprintf( stderr
, err
, args
);
74 /* die on a fatal error; use only during initialization */
75 static void fatal_perror( const char *err
, ... ) WINE_NORETURN
;
76 static void fatal_perror( const char *err
, ... )
80 va_start( args
, err
);
81 fprintf( stderr
, "wine: " );
82 vfprintf( stderr
, err
, args
);
88 /***********************************************************************
89 * server_protocol_error
91 void server_protocol_error( const char *err
, ... )
95 va_start( args
, err
);
96 fprintf( stderr
, "wine client error:%p: ", NtCurrentTeb()->tid
);
97 vfprintf( stderr
, err
, args
);
99 SYSDEPS_ExitThread(1);
103 /***********************************************************************
104 * server_protocol_perror
106 void server_protocol_perror( const char *err
)
108 fprintf( stderr
, "wine client error:%p: ", NtCurrentTeb()->tid
);
110 SYSDEPS_ExitThread(1);
114 /***********************************************************************
115 * __wine_server_exception_handler (NTDLL.@)
117 DWORD
__wine_server_exception_handler( PEXCEPTION_RECORD record
, EXCEPTION_FRAME
*frame
,
118 CONTEXT
*context
, EXCEPTION_FRAME
**pdispatcher
)
120 struct __server_exception_frame
*server_frame
= (struct __server_exception_frame
*)frame
;
121 if ((record
->ExceptionFlags
& (EH_UNWINDING
| EH_EXIT_UNWIND
)))
122 NtCurrentTeb()->buffer_pos
= server_frame
->buffer_pos
;
123 return ExceptionContinueSearch
;
127 /***********************************************************************
128 * wine_server_alloc_req (NTDLL.@)
130 void wine_server_alloc_req( union generic_request
*req
, size_t size
)
132 unsigned int pos
= NtCurrentTeb()->buffer_pos
;
134 assert( size
<= REQUEST_MAX_VAR_SIZE
);
136 if (pos
+ size
> NtCurrentTeb()->buffer_size
)
137 server_protocol_error( "buffer overflow %d bytes\n",
138 pos
+ size
- NtCurrentTeb()->buffer_pos
);
140 NtCurrentTeb()->buffer_pos
= pos
+ size
;
141 req
->header
.var_offset
= pos
;
142 req
->header
.var_size
= size
;
146 /***********************************************************************
149 * Send a request to the server.
151 static void send_request( union generic_request
*request
)
155 if ((ret
= write( NtCurrentTeb()->request_fd
, request
, sizeof(*request
) )) == sizeof(*request
))
157 if (ret
>= 0) server_protocol_error( "partial write %d\n", ret
);
158 if (errno
== EPIPE
) SYSDEPS_ExitThread(0);
159 server_protocol_perror( "sendmsg" );
162 /***********************************************************************
165 * Wait for a reply from the server.
167 static void wait_reply( union generic_request
*req
)
173 if ((ret
= read( NtCurrentTeb()->reply_fd
, req
, sizeof(*req
) )) == sizeof(*req
))
176 if (ret
> 0) server_protocol_error( "partial read %d\n", ret
);
177 if (errno
== EINTR
) continue;
178 if (errno
== EPIPE
) break;
179 server_protocol_perror("read");
181 /* the server closed the connection; time to die... */
182 SYSDEPS_ExitThread(0);
186 /***********************************************************************
187 * wine_server_call (NTDLL.@)
189 * Perform a server call.
191 unsigned int wine_server_call( union generic_request
*req
, size_t size
)
195 memset( (char *)req
+ size
, 0, sizeof(*req
) - size
);
196 sigprocmask( SIG_BLOCK
, &block_set
, &old_set
);
199 sigprocmask( SIG_SETMASK
, &old_set
, NULL
);
200 return req
->header
.error
;
204 /***********************************************************************
205 * wine_server_send_fd
207 * Send a file descriptor to the server.
209 void wine_server_send_fd( int fd
)
211 #ifndef HAVE_MSGHDR_ACCRIGHTS
215 struct msghdr msghdr
;
219 vec
.iov_base
= (void *)&data
;
220 vec
.iov_len
= sizeof(data
);
222 msghdr
.msg_name
= NULL
;
223 msghdr
.msg_namelen
= 0;
224 msghdr
.msg_iov
= &vec
;
225 msghdr
.msg_iovlen
= 1;
227 #ifdef HAVE_MSGHDR_ACCRIGHTS
228 msghdr
.msg_accrights
= (void *)&fd
;
229 msghdr
.msg_accrightslen
= sizeof(fd
);
230 #else /* HAVE_MSGHDR_ACCRIGHTS */
231 cmsg
.len
= sizeof(cmsg
);
232 cmsg
.level
= SOL_SOCKET
;
233 cmsg
.type
= SCM_RIGHTS
;
235 msghdr
.msg_control
= &cmsg
;
236 msghdr
.msg_controllen
= sizeof(cmsg
);
237 msghdr
.msg_flags
= 0;
238 #endif /* HAVE_MSGHDR_ACCRIGHTS */
240 data
.tid
= (void *)GetCurrentThreadId();
245 if ((ret
= sendmsg( fd_socket
, &msghdr
, 0 )) == sizeof(data
)) return;
246 if (ret
>= 0) server_protocol_error( "partial write %d\n", ret
);
247 if (errno
== EINTR
) continue;
248 if (errno
== EPIPE
) SYSDEPS_ExitThread(0);
249 server_protocol_perror( "sendmsg" );
254 /***********************************************************************
257 * Receive a file descriptor passed from the server.
259 static int receive_fd( handle_t
*handle
)
264 #ifdef HAVE_MSGHDR_ACCRIGHTS
265 struct msghdr msghdr
;
268 msghdr
.msg_accrights
= (void *)&fd
;
269 msghdr
.msg_accrightslen
= sizeof(fd
);
270 #else /* HAVE_MSGHDR_ACCRIGHTS */
271 struct msghdr msghdr
;
274 cmsg
.len
= sizeof(cmsg
);
275 cmsg
.level
= SOL_SOCKET
;
276 cmsg
.type
= SCM_RIGHTS
;
278 msghdr
.msg_control
= &cmsg
;
279 msghdr
.msg_controllen
= sizeof(cmsg
);
280 msghdr
.msg_flags
= 0;
281 #endif /* HAVE_MSGHDR_ACCRIGHTS */
283 msghdr
.msg_name
= NULL
;
284 msghdr
.msg_namelen
= 0;
285 msghdr
.msg_iov
= &vec
;
286 msghdr
.msg_iovlen
= 1;
287 vec
.iov_base
= (void *)handle
;
288 vec
.iov_len
= sizeof(*handle
);
292 if ((ret
= recvmsg( fd_socket
, &msghdr
, 0 )) > 0)
294 #ifndef HAVE_MSGHDR_ACCRIGHTS
297 if (fd
== -1) server_protocol_error( "no fd received for handle %d\n", *handle
);
298 fcntl( fd
, F_SETFD
, 1 ); /* set close on exec flag */
302 if (errno
== EINTR
) continue;
303 if (errno
== EPIPE
) break;
304 server_protocol_perror("recvmsg");
306 /* the server closed the connection; time to die... */
307 SYSDEPS_ExitThread(0);
311 /***********************************************************************
312 * wine_server_recv_fd
314 * Receive a file descriptor passed from the server.
315 * The file descriptor must not be closed.
316 * Return -2 if a race condition stole our file descriptor.
318 int wine_server_recv_fd( handle_t handle
)
322 int fd
= receive_fd( &fd_handle
);
324 /* now store it in the server fd cache for this handle */
326 SERVER_START_REQ( set_handle_info
)
328 req
->handle
= fd_handle
;
334 if (req
->cur_fd
!= fd
)
336 /* someone was here before us */
349 if (handle
!= fd_handle
) fd
= -2; /* not the one we expected */
354 /***********************************************************************
357 * Return the configuration directory ($WINEPREFIX or $HOME/.wine)
359 const char *get_config_dir(void)
361 static char *confdir
;
364 const char *prefix
= getenv( "WINEPREFIX" );
367 int len
= strlen(prefix
);
368 if (!(confdir
= strdup( prefix
))) fatal_error( "out of memory\n" );
369 if (len
> 1 && confdir
[len
-1] == '/') confdir
[len
-1] = 0;
373 const char *home
= getenv( "HOME" );
376 struct passwd
*pwd
= getpwuid( getuid() );
377 if (!pwd
) fatal_error( "could not find your home directory\n" );
380 if (!(confdir
= malloc( strlen(home
) + strlen(CONFDIR
) + 1 )))
381 fatal_error( "out of memory\n" );
382 strcpy( confdir
, home
);
383 strcat( confdir
, CONFDIR
);
385 mkdir( confdir
, 0755 ); /* just in case */
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 execl( p
, "wineserver", NULL
);
411 fatal_perror( "could not exec the server '%s'\n"
412 " specified in the WINESERVER environment variable", p
);
415 /* first try the installation dir */
416 execl( BINDIR
"/wineserver", "wineserver", NULL
);
418 /* now try the dir we were launched from */
421 if (!(path
= malloc( strlen(full_argv0
) + 20 )))
422 fatal_error( "out of memory\n" );
423 if ((p
= strrchr( strcpy( path
, full_argv0
), '/' )))
425 strcpy( p
, "/wineserver" );
426 execl( path
, "wineserver", NULL
);
427 strcpy( p
, "/server/wineserver" );
428 execl( path
, "wineserver", NULL
);
433 /* now try the path */
434 execlp( "wineserver", "wineserver", NULL
);
436 /* and finally the current dir */
437 if (!(path
= malloc( strlen(oldcwd
) + 20 )))
438 fatal_error( "out of memory\n" );
439 p
= strcpy( path
, oldcwd
) + strlen( oldcwd
);
440 strcpy( p
, "/wineserver" );
441 execl( path
, "wineserver", NULL
);
442 strcpy( p
, "/server/wineserver" );
443 execl( path
, "wineserver", NULL
);
445 fatal_error( "could not exec wineserver\n" );
448 waitpid( pid
, &status
, 0 );
449 status
= WIFEXITED(status
) ? WEXITSTATUS(status
) : 1;
450 if (status
) exit(status
); /* server failed */
454 /***********************************************************************
457 * Attempt to connect to an existing server socket.
458 * We need to be in the server directory already.
460 static int server_connect( const char *oldcwd
, const char *serverdir
)
462 struct sockaddr_un addr
;
466 /* chdir to the server directory */
467 if (chdir( serverdir
) == -1)
469 if (errno
!= ENOENT
) fatal_perror( "chdir to %s", serverdir
);
471 if (chdir( serverdir
) == -1) fatal_perror( "chdir to %s", serverdir
);
474 /* make sure we are at the right place */
475 if (stat( ".", &st
) == -1) fatal_perror( "stat %s", serverdir
);
476 if (st
.st_uid
!= getuid()) fatal_error( "'%s' is not owned by you\n", serverdir
);
477 if (st
.st_mode
& 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir
);
479 for (retry
= 0; retry
< 3; retry
++)
481 /* if not the first try, wait a bit to leave the server time to exit */
482 if (retry
) usleep( 100000 * retry
* retry
);
484 /* check for an existing socket */
485 if (lstat( SOCKETNAME
, &st
) == -1)
487 if (errno
!= ENOENT
) fatal_perror( "lstat %s/%s", serverdir
, SOCKETNAME
);
488 start_server( oldcwd
);
489 if (lstat( SOCKETNAME
, &st
) == -1) fatal_perror( "lstat %s/%s", serverdir
, SOCKETNAME
);
492 /* make sure the socket is sane (ISFIFO needed for Solaris) */
493 if (!S_ISSOCK(st
.st_mode
) && !S_ISFIFO(st
.st_mode
))
494 fatal_error( "'%s/%s' is not a socket\n", serverdir
, SOCKETNAME
);
495 if (st
.st_uid
!= getuid())
496 fatal_error( "'%s/%s' is not owned by you\n", serverdir
, SOCKETNAME
);
498 /* try to connect to it */
499 addr
.sun_family
= AF_UNIX
;
500 strcpy( addr
.sun_path
, SOCKETNAME
);
501 slen
= sizeof(addr
) - sizeof(addr
.sun_path
) + strlen(addr
.sun_path
) + 1;
502 #ifdef HAVE_SOCKADDR_SUN_LEN
505 if ((s
= socket( AF_UNIX
, SOCK_STREAM
, 0 )) == -1) fatal_perror( "socket" );
506 if (connect( s
, (struct sockaddr
*)&addr
, slen
) != -1)
508 fcntl( s
, F_SETFD
, 1 ); /* set close on exec flag */
513 fatal_error( "file '%s/%s' exists,\n"
514 " but I cannot connect to it; maybe the wineserver has crashed?\n"
515 " If this is the case, you should remove this socket file and try again.\n",
516 serverdir
, SOCKETNAME
);
520 /***********************************************************************
523 * Start the server and create the initial socket pair.
525 void CLIENT_InitServer(void)
529 char *oldcwd
, *serverdir
;
530 const char *configdir
;
531 handle_t dummy_handle
;
533 /* retrieve the current directory */
534 for (size
= 512; ; size
*= 2)
536 if (!(oldcwd
= malloc( size
))) break;
537 if (getcwd( oldcwd
, size
)) break;
539 if (errno
== ERANGE
) continue;
544 /* if argv[0] is a relative path, make it absolute */
546 if (oldcwd
&& argv0
[0] != '/' && strchr( argv0
, '/' ))
548 char *new_argv0
= malloc( strlen(oldcwd
) + strlen(argv0
) + 2 );
551 strcpy( new_argv0
, oldcwd
);
552 strcat( new_argv0
, "/" );
553 strcat( new_argv0
, argv0
);
554 full_argv0
= new_argv0
;
558 /* get the server directory name */
559 if (gethostname( hostname
, sizeof(hostname
) ) == -1) fatal_perror( "gethostname" );
560 configdir
= get_config_dir();
561 serverdir
= malloc( strlen(configdir
) + strlen(SERVERDIR
) + strlen(hostname
) + 1 );
562 if (!serverdir
) fatal_error( "out of memory\n" );
563 strcpy( serverdir
, configdir
);
564 strcat( serverdir
, SERVERDIR
);
565 strcat( serverdir
, hostname
);
567 /* connect to the server */
568 fd_socket
= server_connect( oldcwd
, serverdir
);
570 /* switch back to the starting directory */
577 /* setup the signal mask */
578 sigemptyset( &block_set
);
579 sigaddset( &block_set
, SIGALRM
);
580 sigaddset( &block_set
, SIGIO
);
581 sigaddset( &block_set
, SIGINT
);
582 sigaddset( &block_set
, SIGHUP
);
584 /* receive the first thread request fd on the main socket */
585 NtCurrentTeb()->request_fd
= receive_fd( &dummy_handle
);
591 /***********************************************************************
594 inline static void set_request_buffer(void)
598 unsigned int offset
, size
;
600 /* create a temporary file */
603 if (!(name
= tmpnam(NULL
))) server_protocol_perror( "tmpnam" );
604 fd
= open( name
, O_CREAT
| O_EXCL
| O_RDWR
, 0600 );
605 } while ((fd
== -1) && (errno
== EEXIST
));
607 if (fd
== -1) server_protocol_perror( "create" );
610 wine_server_send_fd( fd
);
612 SERVER_START_REQ( set_thread_buffer
)
616 offset
= req
->offset
;
620 if (ret
) server_protocol_error( "set_thread_buffer failed with status %x\n", ret
);
622 if ((NtCurrentTeb()->buffer
= mmap( 0, size
, PROT_READ
| PROT_WRITE
,
623 MAP_SHARED
, fd
, offset
)) == (void*)-1)
624 server_protocol_perror( "mmap" );
627 NtCurrentTeb()->buffer_pos
= 0;
628 NtCurrentTeb()->buffer_size
= size
;
632 /***********************************************************************
635 * Send an init thread request. Return 0 if OK.
637 void CLIENT_InitThread(void)
639 TEB
*teb
= NtCurrentTeb();
643 /* ignore SIGPIPE so that we get a EPIPE error instead */
644 signal( SIGPIPE
, SIG_IGN
);
646 /* create the server->client communication pipes */
647 if (pipe( reply_pipe
) == -1) server_protocol_perror( "pipe" );
648 if (pipe( teb
->wait_fd
) == -1) server_protocol_perror( "pipe" );
649 wine_server_send_fd( reply_pipe
[1] );
650 wine_server_send_fd( teb
->wait_fd
[1] );
651 teb
->reply_fd
= reply_pipe
[0];
653 /* set close on exec flag */
654 fcntl( teb
->reply_fd
, F_SETFD
, 1 );
655 fcntl( teb
->wait_fd
[0], F_SETFD
, 1 );
656 fcntl( teb
->wait_fd
[1], F_SETFD
, 1 );
658 SERVER_START_REQ( init_thread
)
660 req
->unix_pid
= getpid();
662 req
->entry
= teb
->entry_point
;
663 req
->reply_fd
= reply_pipe
[1];
664 req
->wait_fd
= teb
->wait_fd
[1];
668 version
= req
->version
;
669 if (req
->boot
) boot_thread_id
= teb
->tid
;
670 else if (boot_thread_id
== teb
->tid
) boot_thread_id
= 0;
671 close( reply_pipe
[1] );
675 if (ret
) server_protocol_error( "init_thread failed with status %x\n", ret
);
676 if (version
!= SERVER_PROTOCOL_VERSION
)
677 server_protocol_error( "version mismatch %d/%d.\n"
678 "Your %s binary was not upgraded correctly,\n"
679 "or you have an older one somewhere in your PATH.\n"
680 "Or maybe the wrong wineserver is still running?\n",
681 version
, SERVER_PROTOCOL_VERSION
,
682 (version
> SERVER_PROTOCOL_VERSION
) ? "wine" : "wineserver" );
683 set_request_buffer();
687 /***********************************************************************
690 * Signal that we have finished booting, and set debug level.
692 void CLIENT_BootDone( int debug_level
)
694 SERVER_START_REQ( boot_done
)
696 req
->debug_level
= debug_level
;
703 /***********************************************************************
704 * CLIENT_IsBootThread
706 * Return TRUE if current thread is the boot thread.
708 int CLIENT_IsBootThread(void)
710 return (GetCurrentThreadId() == (DWORD
)boot_thread_id
);