Added FIXMEs for actions with id>=115. These actions were not
[wine.git] / scheduler / client.c
blob0da699a23e57ec6522316bbd76bb89963e131af1
1 /*
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
21 #include "config.h"
22 #include "wine/port.h"
24 #include <assert.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <pwd.h>
29 #include <signal.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #ifdef HAVE_SYS_SOCKET_H
34 # include <sys/socket.h>
35 #endif
36 #ifdef HAVE_SYS_WAIT_H
37 #include <sys/wait.h>
38 #endif
39 #include <sys/un.h>
40 #ifdef HAVE_SYS_MMAN_H
41 #include <sys/mman.h>
42 #endif
43 #include <sys/stat.h>
44 #include <sys/uio.h>
45 #include <unistd.h>
46 #include <stdarg.h>
48 #include "thread.h"
49 #include "wine/server.h"
50 #include "winerror.h"
51 #include "options.h"
53 /* Some versions of glibc don't define this */
54 #ifndef SCM_RIGHTS
55 #define SCM_RIGHTS 1
56 #endif
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 */
64 struct cmsg_fd
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, ... )
81 va_list args;
83 va_start( args, err );
84 fprintf( stderr, "wine: " );
85 vfprintf( stderr, err, args );
86 va_end( args );
87 exit(1);
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, ... )
94 va_list args;
96 va_start( args, err );
97 fprintf( stderr, "wine: " );
98 vfprintf( stderr, err, args );
99 perror( " " );
100 va_end( args );
101 exit(1);
104 /***********************************************************************
105 * server_protocol_error
107 void server_protocol_error( const char *err, ... )
109 va_list args;
111 va_start( args, err );
112 fprintf( stderr, "wine client error:%p: ", NtCurrentTeb()->tid );
113 vfprintf( stderr, err, args );
114 va_end( 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 );
125 perror( err );
126 SYSDEPS_AbortThread(1);
130 /***********************************************************************
131 * send_request
133 * Send a request to the server.
135 static void send_request( const struct __server_request_info *req )
137 int i, ret;
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;
145 else
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 /***********************************************************************
167 * read_reply_data
169 * Read data from the reply buffer; helper for wait_reply.
171 static void read_reply_data( void *buffer, size_t size )
173 int ret;
175 for (;;)
177 if ((ret = read( NtCurrentTeb()->reply_fd, buffer, size )) > 0)
179 if (!(size -= ret)) return;
180 buffer = (char *)buffer + ret;
181 continue;
183 if (!ret) break;
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 /***********************************************************************
194 * wait_reply
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;
214 sigset_t old_set;
216 memset( (char *)&req->u.req + req->size, 0, sizeof(req->u.req) - req->size );
217 sigprocmask( SIG_BLOCK, &block_set, &old_set );
218 send_request( req );
219 wait_reply( req );
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
233 struct cmsg_fd cmsg;
234 #endif
235 struct send_fd data;
236 struct msghdr msghdr;
237 struct iovec vec;
238 int ret;
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;
255 cmsg.fd = fd;
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();
262 data.fd = fd;
264 for (;;)
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 /***********************************************************************
276 * receive_fd
278 * Receive a file descriptor passed from the server.
280 static int receive_fd( handle_t *handle )
282 struct iovec vec;
283 int ret, fd;
285 #ifdef HAVE_MSGHDR_ACCRIGHTS
286 struct msghdr msghdr;
288 fd = -1;
289 msghdr.msg_accrights = (void *)&fd;
290 msghdr.msg_accrightslen = sizeof(fd);
291 #else /* HAVE_MSGHDR_ACCRIGHTS */
292 struct msghdr msghdr;
293 struct cmsg_fd cmsg;
295 cmsg.len = sizeof(cmsg);
296 cmsg.level = SOL_SOCKET;
297 cmsg.type = SCM_RIGHTS;
298 cmsg.fd = -1;
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);
311 for (;;)
313 if ((ret = recvmsg( fd_socket, &msghdr, 0 )) > 0)
315 #ifndef HAVE_MSGHDR_ACCRIGHTS
316 fd = cmsg.fd;
317 #endif
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 */
320 return fd;
322 if (!ret) break;
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 /***********************************************************************
333 * wine_server_recv_fd
335 * Receive a file descriptor passed from the server.
336 * The file descriptor must not be closed.
337 * Return -2 if a race condition stole our file descriptor.
339 int wine_server_recv_fd( handle_t handle )
341 handle_t fd_handle;
343 int fd = receive_fd( &fd_handle );
345 /* now store it in the server fd cache for this handle */
347 SERVER_START_REQ( set_handle_info )
349 req->handle = fd_handle;
350 req->flags = 0;
351 req->mask = 0;
352 req->fd = fd;
353 if (!wine_server_call( req ))
355 if (reply->cur_fd != fd)
357 /* someone was here before us */
358 close( fd );
359 fd = reply->cur_fd;
362 else
364 close( fd );
365 fd = -1;
368 SERVER_END_REQ;
370 if (handle != fd_handle) fd = -2; /* not the one we expected */
371 return fd;
375 /***********************************************************************
376 * get_config_dir
378 * Return the configuration directory ($WINEPREFIX or $HOME/.wine)
380 const char *get_config_dir(void)
382 static char *confdir;
383 if (!confdir)
385 const char *prefix = getenv( "WINEPREFIX" );
386 if (prefix)
388 int len = strlen(prefix);
389 if (!(confdir = strdup( prefix ))) fatal_error( "out of memory\n" );
390 if (len > 1 && confdir[len-1] == '/') confdir[len-1] = 0;
392 else
394 const char *home = getenv( "HOME" );
395 if (!home)
397 struct passwd *pwd = getpwuid( getuid() );
398 if (!pwd) fatal_error( "could not find your home directory\n" );
399 home = pwd->pw_dir;
401 if (!(confdir = malloc( strlen(home) + strlen(CONFDIR) + 1 )))
402 fatal_error( "out of memory\n" );
403 strcpy( confdir, home );
404 strcat( confdir, CONFDIR );
407 return confdir;
411 /***********************************************************************
412 * start_server
414 * Start a new wine server.
416 static void start_server( const char *oldcwd )
418 static int started; /* we only try once */
419 char *path, *p;
420 if (!started)
422 int status;
423 int pid = fork();
424 if (pid == -1) fatal_perror( "fork" );
425 if (!pid)
427 /* if server is explicitly specified, use this */
428 if ((p = getenv("WINESERVER")))
430 if (p[0] != '/' && oldcwd[0] == '/') /* make it an absolute path */
432 if (!(path = malloc( strlen(oldcwd) + strlen(p) + 1 )))
433 fatal_error( "out of memory\n" );
434 sprintf( path, "%s/%s", oldcwd, p );
435 p = path;
437 execl( p, "wineserver", NULL );
438 fatal_perror( "could not exec the server '%s'\n"
439 " specified in the WINESERVER environment variable", p );
442 /* first try the installation dir */
443 execl( BINDIR "/wineserver", "wineserver", NULL );
445 /* now try the dir we were launched from */
446 if (full_argv0)
448 if (!(path = malloc( strlen(full_argv0) + 20 )))
449 fatal_error( "out of memory\n" );
450 if ((p = strrchr( strcpy( path, full_argv0 ), '/' )))
452 strcpy( p, "/wineserver" );
453 execl( path, "wineserver", NULL );
454 strcpy( p, "/server/wineserver" );
455 execl( path, "wineserver", NULL );
457 free(path);
460 /* now try the path */
461 execlp( "wineserver", "wineserver", NULL );
463 /* and finally the current dir */
464 if (!(path = malloc( strlen(oldcwd) + 20 )))
465 fatal_error( "out of memory\n" );
466 p = strcpy( path, oldcwd ) + strlen( oldcwd );
467 strcpy( p, "/wineserver" );
468 execl( path, "wineserver", NULL );
469 strcpy( p, "/server/wineserver" );
470 execl( path, "wineserver", NULL );
471 free(path);
472 fatal_error( "could not exec wineserver\n" );
474 started = 1;
475 waitpid( pid, &status, 0 );
476 status = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
477 if (status) exit(status); /* server failed */
481 /***********************************************************************
482 * server_connect
484 * Attempt to connect to an existing server socket.
485 * We need to be in the server directory already.
487 static int server_connect( const char *oldcwd, const char *serverdir )
489 struct sockaddr_un addr;
490 struct stat st;
491 int s, slen, retry;
493 /* chdir to the server directory */
494 if (chdir( serverdir ) == -1)
496 if (errno != ENOENT) fatal_perror( "chdir to %s", serverdir );
497 start_server( "." );
498 if (chdir( serverdir ) == -1) fatal_perror( "chdir to %s", serverdir );
501 /* make sure we are at the right place */
502 if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
503 if (st.st_uid != getuid()) fatal_error( "'%s' is not owned by you\n", serverdir );
504 if (st.st_mode & 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir );
506 for (retry = 0; retry < 3; retry++)
508 /* if not the first try, wait a bit to leave the server time to exit */
509 if (retry) usleep( 100000 * retry * retry );
511 /* check for an existing socket */
512 if (lstat( SOCKETNAME, &st ) == -1)
514 if (errno != ENOENT) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
515 start_server( oldcwd );
516 if (lstat( SOCKETNAME, &st ) == -1) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
519 /* make sure the socket is sane (ISFIFO needed for Solaris) */
520 if (!S_ISSOCK(st.st_mode) && !S_ISFIFO(st.st_mode))
521 fatal_error( "'%s/%s' is not a socket\n", serverdir, SOCKETNAME );
522 if (st.st_uid != getuid())
523 fatal_error( "'%s/%s' is not owned by you\n", serverdir, SOCKETNAME );
525 /* try to connect to it */
526 addr.sun_family = AF_UNIX;
527 strcpy( addr.sun_path, SOCKETNAME );
528 slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
529 #ifdef HAVE_SOCKADDR_SUN_LEN
530 addr.sun_len = slen;
531 #endif
532 if ((s = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
533 if (connect( s, (struct sockaddr *)&addr, slen ) != -1)
535 fcntl( s, F_SETFD, 1 ); /* set close on exec flag */
536 return s;
538 close( s );
540 fatal_error( "file '%s/%s' exists,\n"
541 " but I cannot connect to it; maybe the wineserver has crashed?\n"
542 " If this is the case, you should remove this socket file and try again.\n",
543 serverdir, SOCKETNAME );
547 /***********************************************************************
548 * CLIENT_InitServer
550 * Start the server and create the initial socket pair.
552 void CLIENT_InitServer(void)
554 int size;
555 char hostname[64];
556 char *oldcwd, *serverdir;
557 const char *configdir;
558 handle_t dummy_handle;
560 /* retrieve the current directory */
561 for (size = 512; ; size *= 2)
563 if (!(oldcwd = malloc( size ))) break;
564 if (getcwd( oldcwd, size )) break;
565 free( oldcwd );
566 if (errno == ERANGE) continue;
567 oldcwd = NULL;
568 break;
571 /* if argv[0] is a relative path, make it absolute */
572 full_argv0 = argv0;
573 if (oldcwd && argv0[0] != '/' && strchr( argv0, '/' ))
575 char *new_argv0 = malloc( strlen(oldcwd) + strlen(argv0) + 2 );
576 if (new_argv0)
578 strcpy( new_argv0, oldcwd );
579 strcat( new_argv0, "/" );
580 strcat( new_argv0, argv0 );
581 full_argv0 = new_argv0;
585 /* get the server directory name */
586 if (gethostname( hostname, sizeof(hostname) ) == -1) fatal_perror( "gethostname" );
587 configdir = get_config_dir();
588 serverdir = malloc( strlen(configdir) + strlen(SERVERDIR) + strlen(hostname) + 1 );
589 if (!serverdir) fatal_error( "out of memory\n" );
590 strcpy( serverdir, configdir );
591 strcat( serverdir, SERVERDIR );
592 strcat( serverdir, hostname );
594 /* connect to the server */
595 fd_socket = server_connect( oldcwd, serverdir );
597 /* switch back to the starting directory */
598 if (oldcwd)
600 chdir( oldcwd );
601 free( oldcwd );
604 /* setup the signal mask */
605 sigemptyset( &block_set );
606 sigaddset( &block_set, SIGALRM );
607 sigaddset( &block_set, SIGIO );
608 sigaddset( &block_set, SIGINT );
609 sigaddset( &block_set, SIGHUP );
611 /* receive the first thread request fd on the main socket */
612 NtCurrentTeb()->request_fd = receive_fd( &dummy_handle );
614 CLIENT_InitThread();
618 /***********************************************************************
619 * CLIENT_InitThread
621 * Send an init thread request. Return 0 if OK.
623 void CLIENT_InitThread(void)
625 TEB *teb = NtCurrentTeb();
626 int version, ret;
627 int reply_pipe[2];
629 /* ignore SIGPIPE so that we get a EPIPE error instead */
630 signal( SIGPIPE, SIG_IGN );
632 /* create the server->client communication pipes */
633 if (pipe( reply_pipe ) == -1) server_protocol_perror( "pipe" );
634 if (pipe( teb->wait_fd ) == -1) server_protocol_perror( "pipe" );
635 wine_server_send_fd( reply_pipe[1] );
636 wine_server_send_fd( teb->wait_fd[1] );
637 teb->reply_fd = reply_pipe[0];
639 /* set close on exec flag */
640 fcntl( teb->reply_fd, F_SETFD, 1 );
641 fcntl( teb->wait_fd[0], F_SETFD, 1 );
642 fcntl( teb->wait_fd[1], F_SETFD, 1 );
644 SERVER_START_REQ( init_thread )
646 req->unix_pid = getpid();
647 req->teb = teb;
648 req->entry = teb->entry_point;
649 req->reply_fd = reply_pipe[1];
650 req->wait_fd = teb->wait_fd[1];
651 ret = wine_server_call( req );
652 teb->pid = reply->pid;
653 teb->tid = reply->tid;
654 version = reply->version;
655 if (reply->boot) boot_thread_id = teb->tid;
656 else if (boot_thread_id == teb->tid) boot_thread_id = 0;
657 close( reply_pipe[1] );
659 SERVER_END_REQ;
661 if (ret) server_protocol_error( "init_thread failed with status %x\n", ret );
662 if (version != SERVER_PROTOCOL_VERSION)
663 server_protocol_error( "version mismatch %d/%d.\n"
664 "Your %s binary was not upgraded correctly,\n"
665 "or you have an older one somewhere in your PATH.\n"
666 "Or maybe the wrong wineserver is still running?\n",
667 version, SERVER_PROTOCOL_VERSION,
668 (version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );
672 /***********************************************************************
673 * CLIENT_BootDone
675 * Signal that we have finished booting, and set debug level.
677 void CLIENT_BootDone( int debug_level )
679 SERVER_START_REQ( boot_done )
681 req->debug_level = debug_level;
682 wine_server_call( req );
684 SERVER_END_REQ;
688 /***********************************************************************
689 * CLIENT_IsBootThread
691 * Return TRUE if current thread is the boot thread.
693 int CLIENT_IsBootThread(void)
695 return (GetCurrentThreadId() == (DWORD)boot_thread_id);