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"
31 #include <sys/types.h>
32 #ifdef HAVE_SYS_SOCKET_H
33 # include <sys/socket.h>
35 #ifdef HAVE_SYS_WAIT_H
39 #ifdef HAVE_SYS_MMAN_H
50 #include "wine/library.h"
51 #include "wine/server.h"
55 /* Some versions of glibc don't define this */
60 #define SOCKETNAME "socket" /* name of the socket file */
61 #define LOCKNAME "lock" /* name of the lock file */
63 #ifndef HAVE_MSGHDR_ACCRIGHTS
64 /* data structure used to pass an fd with sendmsg/recvmsg */
67 int len
; /* sizeof structure */
68 int level
; /* SOL_SOCKET */
69 int type
; /* SCM_RIGHTS */
70 int fd
; /* fd to pass */
72 #endif /* HAVE_MSGHDR_ACCRIGHTS */
74 static DWORD boot_thread_id
;
75 static sigset_t block_set
; /* signals to block during server calls */
76 static int fd_socket
; /* socket to exchange file descriptors with the server */
79 static void fatal_error( const char *err
, ... ) __attribute__((noreturn
, format(printf
,1,2)));
80 static void fatal_perror( const char *err
, ... ) __attribute__((noreturn
, format(printf
,1,2)));
81 static void server_connect_error( const char *serverdir
) __attribute__((noreturn
));
84 /* die on a fatal error; use only during initialization */
85 static void fatal_error( const char *err
, ... )
89 va_start( args
, err
);
90 fprintf( stderr
, "wine: " );
91 vfprintf( stderr
, err
, args
);
96 /* die on a fatal error; use only during initialization */
97 static void fatal_perror( const char *err
, ... )
101 va_start( args
, err
);
102 fprintf( stderr
, "wine: " );
103 vfprintf( stderr
, err
, args
);
109 /***********************************************************************
110 * server_protocol_error
112 void server_protocol_error( const char *err
, ... )
116 va_start( args
, err
);
117 fprintf( stderr
, "wine client error:%lx: ", NtCurrentTeb()->tid
);
118 vfprintf( stderr
, err
, args
);
120 SYSDEPS_AbortThread(1);
124 /***********************************************************************
125 * server_protocol_perror
127 void server_protocol_perror( const char *err
)
129 fprintf( stderr
, "wine client error:%lx: ", NtCurrentTeb()->tid
);
131 SYSDEPS_AbortThread(1);
135 /***********************************************************************
138 * Send a request to the server.
140 static void send_request( const struct __server_request_info
*req
)
144 if (!req
->u
.req
.request_header
.request_size
)
146 if ((ret
= write( NtCurrentTeb()->request_fd
, &req
->u
.req
,
147 sizeof(req
->u
.req
) )) == sizeof(req
->u
.req
)) return;
152 struct iovec vec
[__SERVER_MAX_DATA
+1];
154 vec
[0].iov_base
= (void *)&req
->u
.req
;
155 vec
[0].iov_len
= sizeof(req
->u
.req
);
156 for (i
= 0; i
< req
->data_count
; i
++)
158 vec
[i
+1].iov_base
= (void *)req
->data
[i
].ptr
;
159 vec
[i
+1].iov_len
= req
->data
[i
].size
;
161 if ((ret
= writev( NtCurrentTeb()->request_fd
, vec
, i
+1 )) ==
162 req
->u
.req
.request_header
.request_size
+ sizeof(req
->u
.req
)) return;
165 if (ret
>= 0) server_protocol_error( "partial write %d\n", ret
);
166 if (errno
== EPIPE
) SYSDEPS_AbortThread(0);
167 server_protocol_perror( "sendmsg" );
171 /***********************************************************************
174 * Read data from the reply buffer; helper for wait_reply.
176 static void read_reply_data( void *buffer
, size_t size
)
182 if ((ret
= read( NtCurrentTeb()->reply_fd
, buffer
, size
)) > 0)
184 if (!(size
-= ret
)) return;
185 buffer
= (char *)buffer
+ ret
;
189 if (errno
== EINTR
) continue;
190 if (errno
== EPIPE
) break;
191 server_protocol_perror("read");
193 /* the server closed the connection; time to die... */
194 SYSDEPS_AbortThread(0);
198 /***********************************************************************
201 * Wait for a reply from the server.
203 inline static void wait_reply( struct __server_request_info
*req
)
205 read_reply_data( &req
->u
.reply
, sizeof(req
->u
.reply
) );
206 if (req
->u
.reply
.reply_header
.reply_size
)
207 read_reply_data( req
->reply_data
, req
->u
.reply
.reply_header
.reply_size
);
211 /***********************************************************************
212 * wine_server_call (NTDLL.@)
214 * Perform a server call.
216 unsigned int wine_server_call( void *req_ptr
)
218 struct __server_request_info
* const req
= req_ptr
;
221 memset( (char *)&req
->u
.req
+ req
->size
, 0, sizeof(req
->u
.req
) - req
->size
);
222 sigprocmask( SIG_BLOCK
, &block_set
, &old_set
);
225 sigprocmask( SIG_SETMASK
, &old_set
, NULL
);
226 return req
->u
.reply
.reply_header
.error
;
230 /***********************************************************************
231 * wine_server_send_fd
233 * Send a file descriptor to the server.
235 void wine_server_send_fd( int fd
)
237 #ifndef HAVE_MSGHDR_ACCRIGHTS
241 struct msghdr msghdr
;
245 vec
.iov_base
= (void *)&data
;
246 vec
.iov_len
= sizeof(data
);
248 msghdr
.msg_name
= NULL
;
249 msghdr
.msg_namelen
= 0;
250 msghdr
.msg_iov
= &vec
;
251 msghdr
.msg_iovlen
= 1;
253 #ifdef HAVE_MSGHDR_ACCRIGHTS
254 msghdr
.msg_accrights
= (void *)&fd
;
255 msghdr
.msg_accrightslen
= sizeof(fd
);
256 #else /* HAVE_MSGHDR_ACCRIGHTS */
257 cmsg
.len
= sizeof(cmsg
);
258 cmsg
.level
= SOL_SOCKET
;
259 cmsg
.type
= SCM_RIGHTS
;
261 msghdr
.msg_control
= &cmsg
;
262 msghdr
.msg_controllen
= sizeof(cmsg
);
263 msghdr
.msg_flags
= 0;
264 #endif /* HAVE_MSGHDR_ACCRIGHTS */
266 data
.tid
= GetCurrentThreadId();
271 if ((ret
= sendmsg( fd_socket
, &msghdr
, 0 )) == sizeof(data
)) return;
272 if (ret
>= 0) server_protocol_error( "partial write %d\n", ret
);
273 if (errno
== EINTR
) continue;
274 if (errno
== EPIPE
) SYSDEPS_AbortThread(0);
275 server_protocol_perror( "sendmsg" );
280 /***********************************************************************
283 * Receive a file descriptor passed from the server.
285 static int receive_fd( obj_handle_t
*handle
)
290 #ifdef HAVE_MSGHDR_ACCRIGHTS
291 struct msghdr msghdr
;
294 msghdr
.msg_accrights
= (void *)&fd
;
295 msghdr
.msg_accrightslen
= sizeof(fd
);
296 #else /* HAVE_MSGHDR_ACCRIGHTS */
297 struct msghdr msghdr
;
300 cmsg
.len
= sizeof(cmsg
);
301 cmsg
.level
= SOL_SOCKET
;
302 cmsg
.type
= SCM_RIGHTS
;
304 msghdr
.msg_control
= &cmsg
;
305 msghdr
.msg_controllen
= sizeof(cmsg
);
306 msghdr
.msg_flags
= 0;
307 #endif /* HAVE_MSGHDR_ACCRIGHTS */
309 msghdr
.msg_name
= NULL
;
310 msghdr
.msg_namelen
= 0;
311 msghdr
.msg_iov
= &vec
;
312 msghdr
.msg_iovlen
= 1;
313 vec
.iov_base
= (void *)handle
;
314 vec
.iov_len
= sizeof(*handle
);
318 if ((ret
= recvmsg( fd_socket
, &msghdr
, 0 )) > 0)
320 #ifndef HAVE_MSGHDR_ACCRIGHTS
323 if (fd
== -1) server_protocol_error( "no fd received for handle %d\n", *handle
);
324 fcntl( fd
, F_SETFD
, 1 ); /* set close on exec flag */
328 if (errno
== EINTR
) continue;
329 if (errno
== EPIPE
) break;
330 server_protocol_perror("recvmsg");
332 /* the server closed the connection; time to die... */
333 SYSDEPS_AbortThread(0);
337 /***********************************************************************
340 * Store the cached fd value for a given handle back into the server.
341 * Returns the new fd, which can be different if there was already an
342 * fd in the cache for that handle.
344 inline static int store_cached_fd( int fd
, obj_handle_t handle
)
346 SERVER_START_REQ( set_handle_info
)
348 req
->handle
= handle
;
352 if (!wine_server_call( req
))
354 if (reply
->cur_fd
!= fd
)
356 /* someone was here before us */
372 /***********************************************************************
373 * wine_server_fd_to_handle (NTDLL.@)
375 * Allocate a file handle for a Unix fd.
377 int wine_server_fd_to_handle( int fd
, unsigned int access
, int inherit
, obj_handle_t
*handle
)
382 wine_server_send_fd( fd
);
384 SERVER_START_REQ( alloc_file_handle
)
386 req
->access
= access
;
387 req
->inherit
= inherit
;
389 if (!(ret
= wine_server_call( req
))) *handle
= reply
->handle
;
396 /***********************************************************************
397 * wine_server_handle_to_fd (NTDLL.@)
399 * Retrieve the Unix fd corresponding to a file handle.
401 int wine_server_handle_to_fd( obj_handle_t handle
, unsigned int access
, int *unix_fd
,
402 enum fd_type
*type
, int *flags
)
404 obj_handle_t fd_handle
;
410 SERVER_START_REQ( get_handle_fd
)
412 req
->handle
= handle
;
413 req
->access
= access
;
414 if (!(ret
= wine_server_call( req
))) fd
= reply
->fd
;
415 if (type
) *type
= reply
->type
;
416 if (flags
) *flags
= reply
->flags
;
423 /* it wasn't in the cache, get it from the server */
424 fd
= receive_fd( &fd_handle
);
425 /* and store it back into the cache */
426 fd
= store_cached_fd( fd
, fd_handle
);
428 if (fd_handle
== handle
) break;
429 /* if we received a different handle this means there was
430 * a race with another thread; we restart everything from
431 * scratch in this case.
435 if ((fd
!= -1) && ((fd
= dup(fd
)) == -1)) return STATUS_TOO_MANY_OPENED_FILES
;
437 return STATUS_SUCCESS
;
441 /***********************************************************************
444 * Start a new wine server.
446 static void start_server( const char *oldcwd
)
448 static int started
; /* we only try once */
454 if (pid
== -1) fatal_perror( "fork" );
457 /* if server is explicitly specified, use this */
458 if ((p
= getenv("WINESERVER")))
460 if (p
[0] != '/' && oldcwd
[0] == '/') /* make it an absolute path */
462 if (!(path
= malloc( strlen(oldcwd
) + strlen(p
) + 1 )))
463 fatal_error( "out of memory\n" );
464 sprintf( path
, "%s/%s", oldcwd
, p
);
468 fatal_perror( "could not exec the server '%s'\n"
469 " specified in the WINESERVER environment variable", p
);
472 /* first try the installation dir */
473 execl( BINDIR
"/wineserver", "wineserver", NULL
);
475 /* now try the dir we were launched from */
478 if (!(path
= malloc( strlen(full_argv0
) + 20 )))
479 fatal_error( "out of memory\n" );
480 if ((p
= strrchr( strcpy( path
, full_argv0
), '/' )))
482 strcpy( p
, "/wineserver" );
483 execl( path
, path
, NULL
);
488 /* finally try the path */
489 execlp( "wineserver", "wineserver", NULL
);
490 fatal_error( "could not exec wineserver\n" );
492 waitpid( pid
, &status
, 0 );
493 status
= WIFEXITED(status
) ? WEXITSTATUS(status
) : 1;
494 if (status
== 2) return; /* server lock held by someone else, will retry later */
495 if (status
) exit(status
); /* server failed */
501 /***********************************************************************
502 * server_connect_error
504 * Try to display a meaningful explanation of why we couldn't connect
507 static void server_connect_error( const char *serverdir
)
512 if ((fd
= open( LOCKNAME
, O_WRONLY
)) == -1)
513 fatal_error( "for some mysterious reason, the wine server never started.\n" );
516 fl
.l_whence
= SEEK_SET
;
519 if (fcntl( fd
, F_GETLK
, &fl
) != -1)
521 if (fl
.l_type
== F_WRLCK
) /* the file is locked */
522 fatal_error( "a wine server seems to be running, but I cannot connect to it.\n"
523 " You probably need to kill that process (it might be pid %d).\n",
525 fatal_error( "for some mysterious reason, the wine server failed to run.\n" );
527 fatal_error( "the file system of '%s' doesn't support locks,\n"
528 " and there is a 'socket' file in that directory that prevents wine from starting.\n"
529 " You should make sure no wine server is running, remove that file and try again.\n",
534 /***********************************************************************
537 * Attempt to connect to an existing server socket.
538 * We need to be in the server directory already.
540 static int server_connect( const char *oldcwd
, const char *serverdir
)
542 struct sockaddr_un addr
;
546 /* chdir to the server directory */
547 if (chdir( serverdir
) == -1)
549 if (errno
!= ENOENT
) fatal_perror( "chdir to %s", serverdir
);
551 if (chdir( serverdir
) == -1) fatal_perror( "chdir to %s", serverdir
);
554 /* make sure we are at the right place */
555 if (stat( ".", &st
) == -1) fatal_perror( "stat %s", serverdir
);
556 if (st
.st_uid
!= getuid()) fatal_error( "'%s' is not owned by you\n", serverdir
);
557 if (st
.st_mode
& 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir
);
559 for (retry
= 0; retry
< 6; retry
++)
561 /* if not the first try, wait a bit to leave the previous server time to exit */
564 usleep( 100000 * retry
* retry
);
565 start_server( oldcwd
);
566 if (lstat( SOCKETNAME
, &st
) == -1) continue; /* still no socket, wait a bit more */
568 else if (lstat( SOCKETNAME
, &st
) == -1) /* check for an already existing socket */
570 if (errno
!= ENOENT
) fatal_perror( "lstat %s/%s", serverdir
, SOCKETNAME
);
571 start_server( oldcwd
);
572 if (lstat( SOCKETNAME
, &st
) == -1) continue; /* still no socket, wait a bit more */
575 /* make sure the socket is sane (ISFIFO needed for Solaris) */
576 if (!S_ISSOCK(st
.st_mode
) && !S_ISFIFO(st
.st_mode
))
577 fatal_error( "'%s/%s' is not a socket\n", serverdir
, SOCKETNAME
);
578 if (st
.st_uid
!= getuid())
579 fatal_error( "'%s/%s' is not owned by you\n", serverdir
, SOCKETNAME
);
581 /* try to connect to it */
582 addr
.sun_family
= AF_UNIX
;
583 strcpy( addr
.sun_path
, SOCKETNAME
);
584 slen
= sizeof(addr
) - sizeof(addr
.sun_path
) + strlen(addr
.sun_path
) + 1;
585 #ifdef HAVE_SOCKADDR_SUN_LEN
588 if ((s
= socket( AF_UNIX
, SOCK_STREAM
, 0 )) == -1) fatal_perror( "socket" );
589 if (connect( s
, (struct sockaddr
*)&addr
, slen
) != -1)
591 fcntl( s
, F_SETFD
, 1 ); /* set close on exec flag */
596 server_connect_error( serverdir
);
600 /***********************************************************************
603 * Start the server and create the initial socket pair.
605 void CLIENT_InitServer(void)
609 obj_handle_t dummy_handle
;
611 /* retrieve the current directory */
612 for (size
= 512; ; size
*= 2)
614 if (!(oldcwd
= malloc( size
))) break;
615 if (getcwd( oldcwd
, size
)) break;
617 if (errno
== ERANGE
) continue;
622 /* if argv[0] is a relative path, make it absolute */
624 if (oldcwd
&& argv0
[0] != '/' && strchr( argv0
, '/' ))
626 char *new_argv0
= malloc( strlen(oldcwd
) + strlen(argv0
) + 2 );
629 strcpy( new_argv0
, oldcwd
);
630 strcat( new_argv0
, "/" );
631 strcat( new_argv0
, argv0
);
632 full_argv0
= new_argv0
;
636 /* connect to the server */
637 fd_socket
= server_connect( oldcwd
, wine_get_server_dir() );
639 /* switch back to the starting directory */
646 /* setup the signal mask */
647 sigemptyset( &block_set
);
648 sigaddset( &block_set
, SIGALRM
);
649 sigaddset( &block_set
, SIGIO
);
650 sigaddset( &block_set
, SIGINT
);
651 sigaddset( &block_set
, SIGHUP
);
653 /* receive the first thread request fd on the main socket */
654 NtCurrentTeb()->request_fd
= receive_fd( &dummy_handle
);
660 /***********************************************************************
663 * Send an init thread request. Return 0 if OK.
665 void CLIENT_InitThread(void)
667 TEB
*teb
= NtCurrentTeb();
671 /* ignore SIGPIPE so that we get a EPIPE error instead */
672 signal( SIGPIPE
, SIG_IGN
);
673 /* automatic child reaping to avoid zombies */
674 signal( SIGCHLD
, SIG_IGN
);
676 /* create the server->client communication pipes */
677 if (pipe( reply_pipe
) == -1) server_protocol_perror( "pipe" );
678 if (pipe( teb
->wait_fd
) == -1) server_protocol_perror( "pipe" );
679 wine_server_send_fd( reply_pipe
[1] );
680 wine_server_send_fd( teb
->wait_fd
[1] );
681 teb
->reply_fd
= reply_pipe
[0];
682 close( reply_pipe
[1] );
684 /* set close on exec flag */
685 fcntl( teb
->reply_fd
, F_SETFD
, 1 );
686 fcntl( teb
->wait_fd
[0], F_SETFD
, 1 );
687 fcntl( teb
->wait_fd
[1], F_SETFD
, 1 );
689 SERVER_START_REQ( init_thread
)
691 req
->unix_pid
= getpid();
693 req
->entry
= teb
->entry_point
;
694 req
->reply_fd
= reply_pipe
[1];
695 req
->wait_fd
= teb
->wait_fd
[1];
696 ret
= wine_server_call( req
);
697 teb
->pid
= reply
->pid
;
698 teb
->tid
= reply
->tid
;
699 version
= reply
->version
;
700 if (reply
->boot
) boot_thread_id
= teb
->tid
;
701 else if (boot_thread_id
== teb
->tid
) boot_thread_id
= 0;
705 if (ret
) server_protocol_error( "init_thread failed with status %x\n", ret
);
706 if (version
!= SERVER_PROTOCOL_VERSION
)
707 server_protocol_error( "version mismatch %d/%d.\n"
708 "Your %s binary was not upgraded correctly,\n"
709 "or you have an older one somewhere in your PATH.\n"
710 "Or maybe the wrong wineserver is still running?\n",
711 version
, SERVER_PROTOCOL_VERSION
,
712 (version
> SERVER_PROTOCOL_VERSION
) ? "wine" : "wineserver" );
716 /***********************************************************************
719 * Signal that we have finished booting, and set debug level.
721 void CLIENT_BootDone( int debug_level
)
723 SERVER_START_REQ( boot_done
)
725 req
->debug_level
= debug_level
;
726 wine_server_call( req
);
732 /***********************************************************************
733 * CLIENT_IsBootThread
735 * Return TRUE if current thread is the boot thread.
737 int CLIENT_IsBootThread(void)
739 return (GetCurrentThreadId() == (DWORD
)boot_thread_id
);