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
;
60 /* die on a fatal error; use only during initialization */
61 static void fatal_error( const char *err
, ... ) WINE_NORETURN
;
62 static void fatal_error( const char *err
, ... )
66 va_start( args
, err
);
67 fprintf( stderr
, "wine: " );
68 vfprintf( stderr
, err
, args
);
73 /* die on a fatal error; use only during initialization */
74 static void fatal_perror( const char *err
, ... ) WINE_NORETURN
;
75 static void fatal_perror( const char *err
, ... )
79 va_start( args
, err
);
80 fprintf( stderr
, "wine: " );
81 vfprintf( stderr
, err
, args
);
87 /***********************************************************************
88 * server_protocol_error
90 void server_protocol_error( const char *err
, ... )
94 va_start( args
, err
);
95 fprintf( stderr
, "Client protocol error:%p: ", NtCurrentTeb()->tid
);
96 vfprintf( stderr
, err
, args
);
98 SYSDEPS_ExitThread(1);
102 /***********************************************************************
103 * server_protocol_perror
105 void server_protocol_perror( const char *err
)
107 fprintf( stderr
, "Client protocol error:%p: ", NtCurrentTeb()->tid
);
109 SYSDEPS_ExitThread(1);
113 /***********************************************************************
114 * __wine_server_exception_handler (NTDLL.@)
116 DWORD
__wine_server_exception_handler( PEXCEPTION_RECORD record
, EXCEPTION_FRAME
*frame
,
117 CONTEXT
*context
, EXCEPTION_FRAME
**pdispatcher
)
119 struct __server_exception_frame
*server_frame
= (struct __server_exception_frame
*)frame
;
120 if ((record
->ExceptionFlags
& (EH_UNWINDING
| EH_EXIT_UNWIND
)))
121 NtCurrentTeb()->buffer_pos
= server_frame
->buffer_pos
;
122 return ExceptionContinueSearch
;
126 /***********************************************************************
127 * wine_server_alloc_req (NTDLL.@)
129 void wine_server_alloc_req( union generic_request
*req
, size_t size
)
131 unsigned int pos
= NtCurrentTeb()->buffer_pos
;
133 assert( size
<= REQUEST_MAX_VAR_SIZE
);
135 if (pos
+ size
> NtCurrentTeb()->buffer_size
)
136 server_protocol_error( "buffer overflow %d bytes\n",
137 pos
+ size
- NtCurrentTeb()->buffer_pos
);
139 NtCurrentTeb()->buffer_pos
= pos
+ size
;
140 req
->header
.var_offset
= pos
;
141 req
->header
.var_size
= size
;
145 /***********************************************************************
148 * Send a request to the server.
150 static void send_request( union generic_request
*request
)
154 if ((ret
= write( NtCurrentTeb()->request_fd
, request
, sizeof(*request
) )) == sizeof(*request
))
156 if (ret
>= 0) server_protocol_error( "partial write %d\n", ret
);
157 if (errno
== EPIPE
) SYSDEPS_ExitThread(0);
158 server_protocol_perror( "sendmsg" );
161 /***********************************************************************
164 * Send a request to the server, passing a file descriptor.
166 static void send_request_fd( union generic_request
*request
, int fd
)
168 #ifndef HAVE_MSGHDR_ACCRIGHTS
171 struct msghdr msghdr
;
175 vec
.iov_base
= (void *)request
;
176 vec
.iov_len
= sizeof(*request
);
178 msghdr
.msg_name
= NULL
;
179 msghdr
.msg_namelen
= 0;
180 msghdr
.msg_iov
= &vec
;
181 msghdr
.msg_iovlen
= 1;
183 #ifdef HAVE_MSGHDR_ACCRIGHTS
184 msghdr
.msg_accrights
= (void *)&fd
;
185 msghdr
.msg_accrightslen
= sizeof(fd
);
186 #else /* HAVE_MSGHDR_ACCRIGHTS */
187 cmsg
.len
= sizeof(cmsg
);
188 cmsg
.level
= SOL_SOCKET
;
189 cmsg
.type
= SCM_RIGHTS
;
191 msghdr
.msg_control
= &cmsg
;
192 msghdr
.msg_controllen
= sizeof(cmsg
);
193 msghdr
.msg_flags
= 0;
194 #endif /* HAVE_MSGHDR_ACCRIGHTS */
196 if ((ret
= sendmsg( NtCurrentTeb()->socket
, &msghdr
, 0 )) == sizeof(*request
)) return;
197 if (ret
>= 0) server_protocol_error( "partial write %d\n", ret
);
198 if (errno
== EPIPE
) SYSDEPS_ExitThread(0);
199 server_protocol_perror( "sendmsg" );
202 /***********************************************************************
205 * Wait for a reply from the server.
207 static void wait_reply( union generic_request
*req
)
213 if ((ret
= read( NtCurrentTeb()->reply_fd
, req
, sizeof(*req
) )) == sizeof(*req
))
216 if (ret
> 0) server_protocol_error( "partial read %d\n", ret
);
217 if (errno
== EINTR
) continue;
218 if (errno
== EPIPE
) break;
219 server_protocol_perror("read");
221 /* the server closed the connection; time to die... */
222 SYSDEPS_ExitThread(0);
226 /***********************************************************************
227 * wine_server_call (NTDLL.@)
229 * Perform a server call.
231 unsigned int wine_server_call( union generic_request
*req
, size_t size
)
233 memset( (char *)req
+ size
, 0, sizeof(*req
) - size
);
236 return req
->header
.error
;
240 /***********************************************************************
241 * wine_server_call_fd
243 * Perform a server call, passing a file descriptor.
245 unsigned int wine_server_call_fd( union generic_request
*req
, size_t size
, int fd
)
247 memset( (char *)req
+ size
, 0, sizeof(*req
) - size
);
248 send_request_fd( req
, fd
);
250 return req
->header
.error
;
254 /***********************************************************************
257 * Store the fd for a given handle in the server
259 static int set_handle_fd( int handle
, int fd
)
261 SERVER_START_REQ( set_handle_info
)
263 req
->handle
= handle
;
269 if (req
->cur_fd
!= fd
)
271 /* someone was here before us */
275 else fcntl( fd
, F_SETFD
, 1 ); /* set close on exec flag */
288 /***********************************************************************
289 * wine_server_recv_fd
291 * Receive a file descriptor passed from the server.
292 * The file descriptor must be closed after use.
294 int wine_server_recv_fd( int handle
, int cache
)
297 int ret
, fd
, server_handle
;
299 #ifdef HAVE_MSGHDR_ACCRIGHTS
300 struct msghdr msghdr
;
303 msghdr
.msg_accrights
= (void *)&fd
;
304 msghdr
.msg_accrightslen
= sizeof(fd
);
305 #else /* HAVE_MSGHDR_ACCRIGHTS */
306 struct msghdr msghdr
;
309 cmsg
.len
= sizeof(cmsg
);
310 cmsg
.level
= SOL_SOCKET
;
311 cmsg
.type
= SCM_RIGHTS
;
313 msghdr
.msg_control
= &cmsg
;
314 msghdr
.msg_controllen
= sizeof(cmsg
);
315 msghdr
.msg_flags
= 0;
316 #endif /* HAVE_MSGHDR_ACCRIGHTS */
318 msghdr
.msg_name
= NULL
;
319 msghdr
.msg_namelen
= 0;
320 msghdr
.msg_iov
= &vec
;
321 msghdr
.msg_iovlen
= 1;
322 vec
.iov_base
= (void *)&server_handle
;
323 vec
.iov_len
= sizeof(server_handle
);
327 if ((ret
= recvmsg( NtCurrentTeb()->socket
, &msghdr
, 0 )) > 0)
329 #ifndef HAVE_MSGHDR_ACCRIGHTS
332 if (handle
!= server_handle
)
333 server_protocol_error( "recv_fd: got handle %d, expected %d\n",
334 server_handle
, handle
);
337 fd
= set_handle_fd( handle
, fd
);
338 if (fd
!= -1) fd
= dup(fd
);
343 if (errno
== EINTR
) continue;
344 if (errno
== EPIPE
) break;
345 server_protocol_perror("recvmsg");
347 /* the server closed the connection; time to die... */
348 SYSDEPS_ExitThread(0);
352 /***********************************************************************
355 * Return the configuration directory ($WINEPREFIX or $HOME/.wine)
357 const char *get_config_dir(void)
359 static char *confdir
;
362 const char *prefix
= getenv( "WINEPREFIX" );
365 int len
= strlen(prefix
);
366 if (!(confdir
= strdup( prefix
))) fatal_error( "out of memory\n" );
367 if (len
> 1 && confdir
[len
-1] == '/') confdir
[len
-1] = 0;
371 const char *home
= getenv( "HOME" );
374 struct passwd
*pwd
= getpwuid( getuid() );
375 if (!pwd
) fatal_error( "could not find your home directory\n" );
378 if (!(confdir
= malloc( strlen(home
) + strlen(CONFDIR
) + 1 )))
379 fatal_error( "out of memory\n" );
380 strcpy( confdir
, home
);
381 strcat( confdir
, CONFDIR
);
383 mkdir( confdir
, 0755 ); /* just in case */
389 /***********************************************************************
392 * Start a new wine server.
394 static void start_server( const char *oldcwd
)
396 static int started
; /* we only try once */
402 if (pid
== -1) fatal_perror( "fork" );
405 /* if server is explicitly specified, use this */
406 if ((p
= getenv("WINESERVER")))
408 execl( p
, "wineserver", NULL
);
409 fatal_perror( "could not exec the server '%s'\n"
410 " specified in the WINESERVER environment variable", p
);
413 /* first try the installation dir */
414 execl( BINDIR
"/wineserver", "wineserver", NULL
);
416 /* now try the dir we were launched from */
419 if (!(path
= malloc( strlen(full_argv0
) + 20 )))
420 fatal_error( "out of memory\n" );
421 if ((p
= strrchr( strcpy( path
, full_argv0
), '/' )))
423 strcpy( p
, "/wineserver" );
424 execl( path
, "wineserver", NULL
);
425 strcpy( p
, "/server/wineserver" );
426 execl( path
, "wineserver", NULL
);
431 /* now try the path */
432 execlp( "wineserver", "wineserver", NULL
);
434 /* and finally the current dir */
435 if (!(path
= malloc( strlen(oldcwd
) + 20 )))
436 fatal_error( "out of memory\n" );
437 p
= strcpy( path
, oldcwd
) + strlen( oldcwd
);
438 strcpy( p
, "/wineserver" );
439 execl( path
, "wineserver", NULL
);
440 strcpy( p
, "/server/wineserver" );
441 execl( path
, "wineserver", NULL
);
443 fatal_error( "could not exec wineserver\n" );
446 waitpid( pid
, &status
, 0 );
447 status
= WIFEXITED(status
) ? WEXITSTATUS(status
) : 1;
448 if (status
) exit(status
); /* server failed */
452 /***********************************************************************
455 * Attempt to connect to an existing server socket.
456 * We need to be in the server directory already.
458 static int server_connect( const char *oldcwd
, const char *serverdir
)
460 struct sockaddr_un addr
;
464 /* chdir to the server directory */
465 if (chdir( serverdir
) == -1)
467 if (errno
!= ENOENT
) fatal_perror( "chdir to %s", serverdir
);
469 if (chdir( serverdir
) == -1) fatal_perror( "chdir to %s", serverdir
);
472 /* make sure we are at the right place */
473 if (stat( ".", &st
) == -1) fatal_perror( "stat %s", serverdir
);
474 if (st
.st_uid
!= getuid()) fatal_error( "'%s' is not owned by you\n", serverdir
);
475 if (st
.st_mode
& 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir
);
477 for (retry
= 0; retry
< 3; retry
++)
479 /* if not the first try, wait a bit to leave the server time to exit */
480 if (retry
) usleep( 100000 * retry
* retry
);
482 /* check for an existing socket */
483 if (lstat( SOCKETNAME
, &st
) == -1)
485 if (errno
!= ENOENT
) fatal_perror( "lstat %s/%s", serverdir
, SOCKETNAME
);
486 start_server( oldcwd
);
487 if (lstat( SOCKETNAME
, &st
) == -1) fatal_perror( "lstat %s/%s", serverdir
, SOCKETNAME
);
490 /* make sure the socket is sane (ISFIFO needed for Solaris) */
491 if (!S_ISSOCK(st
.st_mode
) && !S_ISFIFO(st
.st_mode
))
492 fatal_error( "'%s/%s' is not a socket\n", serverdir
, SOCKETNAME
);
493 if (st
.st_uid
!= getuid())
494 fatal_error( "'%s/%s' is not owned by you\n", serverdir
, SOCKETNAME
);
496 /* try to connect to it */
497 addr
.sun_family
= AF_UNIX
;
498 strcpy( addr
.sun_path
, SOCKETNAME
);
499 slen
= sizeof(addr
) - sizeof(addr
.sun_path
) + strlen(addr
.sun_path
) + 1;
500 #ifdef HAVE_SOCKADDR_SUN_LEN
503 if ((s
= socket( AF_UNIX
, SOCK_STREAM
, 0 )) == -1) fatal_perror( "socket" );
504 if (connect( s
, (struct sockaddr
*)&addr
, slen
) != -1)
506 fcntl( s
, F_SETFD
, 1 ); /* set close on exec flag */
511 fatal_error( "file '%s/%s' exists,\n"
512 " but I cannot connect to it; maybe the wineserver has crashed?\n"
513 " If this is the case, you should remove this socket file and try again.\n",
514 serverdir
, SOCKETNAME
);
518 /***********************************************************************
521 * Start the server and create the initial socket pair.
523 int CLIENT_InitServer(void)
527 char *oldcwd
, *serverdir
;
528 const char *configdir
;
530 /* retrieve the current directory */
531 for (size
= 512; ; size
*= 2)
533 if (!(oldcwd
= malloc( size
))) break;
534 if (getcwd( oldcwd
, size
)) break;
536 if (errno
== ERANGE
) continue;
541 /* if argv[0] is a relative path, make it absolute */
543 if (oldcwd
&& argv0
[0] != '/' && strchr( argv0
, '/' ))
545 char *new_argv0
= malloc( strlen(oldcwd
) + strlen(argv0
) + 2 );
548 strcpy( new_argv0
, oldcwd
);
549 strcat( new_argv0
, "/" );
550 strcat( new_argv0
, argv0
);
551 full_argv0
= new_argv0
;
555 /* get the server directory name */
556 if (gethostname( hostname
, sizeof(hostname
) ) == -1) fatal_perror( "gethostname" );
557 configdir
= get_config_dir();
558 serverdir
= malloc( strlen(configdir
) + strlen(SERVERDIR
) + strlen(hostname
) + 1 );
559 if (!serverdir
) fatal_error( "out of memory\n" );
560 strcpy( serverdir
, configdir
);
561 strcat( serverdir
, SERVERDIR
);
562 strcat( serverdir
, hostname
);
564 /* connect to the server */
565 fd
= server_connect( oldcwd
, serverdir
);
567 /* switch back to the starting directory */
577 /***********************************************************************
580 * Send an init thread request. Return 0 if OK.
582 int CLIENT_InitThread(void)
584 struct get_thread_buffer_request
*req
;
585 TEB
*teb
= NtCurrentTeb();
588 /* ignore SIGPIPE so that we get a EPIPE error instead */
589 signal( SIGPIPE
, SIG_IGN
);
591 teb
->request_fd
= wine_server_recv_fd( 0, 0 );
592 if (teb
->request_fd
== -1) server_protocol_error( "no request fd passed on first request\n" );
593 fcntl( teb
->request_fd
, F_SETFD
, 1 ); /* set close on exec flag */
595 teb
->reply_fd
= wine_server_recv_fd( 0, 0 );
596 if (teb
->reply_fd
== -1) server_protocol_error( "no reply fd passed on first request\n" );
597 fcntl( teb
->reply_fd
, F_SETFD
, 1 ); /* set close on exec flag */
599 teb
->wait_fd
= wine_server_recv_fd( 0, 0 );
600 if (teb
->wait_fd
== -1) server_protocol_error( "no wait fd passed on first request\n" );
601 fcntl( teb
->wait_fd
, F_SETFD
, 1 ); /* set close on exec flag */
603 fd
= wine_server_recv_fd( 0, 0 );
604 if (fd
== -1) server_protocol_error( "no fd received for thread buffer\n" );
606 if ((teb
->buffer_size
= lseek( fd
, 0, SEEK_END
)) == -1) server_protocol_perror( "lseek" );
607 teb
->buffer
= mmap( 0, teb
->buffer_size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
, fd
, 0 );
610 if (teb
->buffer
== (void*)-1) server_protocol_perror( "mmap" );
612 req
= (struct get_thread_buffer_request
*)teb
->buffer
;
613 wait_reply( (union generic_request
*)req
);
617 if (req
->version
!= SERVER_PROTOCOL_VERSION
)
618 server_protocol_error( "version mismatch %d/%d.\n"
619 "Your %s binary was not upgraded correctly,\n"
620 "or you have an older one somewhere in your PATH.\n"
621 "Or maybe the wrong wineserver is still running?\n",
622 req
->version
, SERVER_PROTOCOL_VERSION
,
623 (req
->version
> SERVER_PROTOCOL_VERSION
) ? "wine" : "wineserver" );
624 if (req
->boot
) boot_thread_id
= teb
->tid
;
625 else if (boot_thread_id
== teb
->tid
) boot_thread_id
= 0;
627 SERVER_START_REQ( init_thread
)
629 req
->unix_pid
= getpid();
631 req
->entry
= teb
->entry_point
;
639 /***********************************************************************
642 * Signal that we have finished booting, and set debug level.
644 int CLIENT_BootDone( int debug_level
)
647 SERVER_START_REQ( boot_done
)
649 req
->debug_level
= debug_level
;
657 /***********************************************************************
658 * CLIENT_IsBootThread
660 * Return TRUE if current thread is the boot thread.
662 int CLIENT_IsBootThread(void)
664 return (GetCurrentThreadId() == (DWORD
)boot_thread_id
);