dplayx: Fix the definition of DirectPlayCreate.
[wine] / dlls / ntdll / server.c
1 /*
2  * Wine server communication
3  *
4  * Copyright (C) 1998 Alexandre Julliard
5  *
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.
10  *
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.
15  *
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <ctype.h>
26 #include <dirent.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <signal.h>
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <string.h>
33 #include <sys/types.h>
34 #ifdef HAVE_SYS_SOCKET_H
35 # include <sys/socket.h>
36 #endif
37 #ifdef HAVE_SYS_WAIT_H
38 #include <sys/wait.h>
39 #endif
40 #ifdef HAVE_SYS_UN_H
41 #include <sys/un.h>
42 #endif
43 #ifdef HAVE_SYS_MMAN_H
44 #include <sys/mman.h>
45 #endif
46 #ifdef HAVE_SYS_STAT_H
47 # include <sys/stat.h>
48 #endif
49 #ifdef HAVE_SYS_UIO_H
50 #include <sys/uio.h>
51 #endif
52 #ifdef HAVE_UNISTD_H
53 # include <unistd.h>
54 #endif
55
56 #include "ntstatus.h"
57 #define WIN32_NO_STATUS
58 #include "wine/library.h"
59 #include "wine/pthread.h"
60 #include "wine/server.h"
61 #include "wine/debug.h"
62 #include "ntdll_misc.h"
63
64 WINE_DEFAULT_DEBUG_CHANNEL(server);
65
66 /* Some versions of glibc don't define this */
67 #ifndef SCM_RIGHTS
68 #define SCM_RIGHTS 1
69 #endif
70
71 #define SOCKETNAME "socket"        /* name of the socket file */
72 #define LOCKNAME   "lock"          /* name of the lock file */
73
74 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
75 /* data structure used to pass an fd with sendmsg/recvmsg */
76 struct cmsg_fd
77 {
78     struct
79     {
80         size_t len;   /* size of structure */
81         int    level; /* SOL_SOCKET */
82         int    type;  /* SCM_RIGHTS */
83     } header;
84     int fd;          /* fd to pass */
85 };
86 #endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
87
88 timeout_t server_start_time = 0;  /* time of server startup */
89
90 extern struct wine_pthread_functions pthread_functions;
91
92 sigset_t server_block_set;  /* signals to block during server calls */
93 static int fd_socket = -1;  /* socket to exchange file descriptors with the server */
94
95 static RTL_CRITICAL_SECTION fd_cache_section;
96 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
97 {
98     0, 0, &fd_cache_section,
99     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
100       0, 0, { (DWORD_PTR)(__FILE__ ": fd_cache_section") }
101 };
102 static RTL_CRITICAL_SECTION fd_cache_section = { &critsect_debug, -1, 0, 0, 0, 0 };
103
104
105 #ifdef __GNUC__
106 static void fatal_error( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
107 static void fatal_perror( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
108 static void server_connect_error( const char *serverdir ) __attribute__((noreturn));
109 #endif
110
111 /* die on a fatal error; use only during initialization */
112 static void fatal_error( const char *err, ... )
113 {
114     va_list args;
115
116     va_start( args, err );
117     fprintf( stderr, "wine: " );
118     vfprintf( stderr, err, args );
119     va_end( args );
120     exit(1);
121 }
122
123 /* die on a fatal error; use only during initialization */
124 static void fatal_perror( const char *err, ... )
125 {
126     va_list args;
127
128     va_start( args, err );
129     fprintf( stderr, "wine: " );
130     vfprintf( stderr, err, args );
131     perror( " " );
132     va_end( args );
133     exit(1);
134 }
135
136
137 /***********************************************************************
138  *           server_exit_thread
139  */
140 void server_exit_thread( int status )
141 {
142     struct wine_pthread_thread_info info;
143     SIZE_T size;
144     int fds[4];
145
146     RtlAcquirePebLock();
147     RemoveEntryList( &NtCurrentTeb()->TlsLinks );
148     RtlReleasePebLock();
149     RtlFreeHeap( GetProcessHeap(), 0, NtCurrentTeb()->FlsSlots );
150     RtlFreeHeap( GetProcessHeap(), 0, NtCurrentTeb()->TlsExpansionSlots );
151
152     info.stack_base  = NtCurrentTeb()->DeallocationStack;
153     info.teb_base    = NtCurrentTeb();
154     info.teb_sel     = wine_get_fs();
155     info.exit_status = status;
156
157     fds[0] = ntdll_get_thread_data()->wait_fd[0];
158     fds[1] = ntdll_get_thread_data()->wait_fd[1];
159     fds[2] = ntdll_get_thread_data()->reply_fd;
160     fds[3] = ntdll_get_thread_data()->request_fd;
161     pthread_functions.sigprocmask( SIG_BLOCK, &server_block_set, NULL );
162
163     size = 0;
164     NtFreeVirtualMemory( GetCurrentProcess(), &info.stack_base, &size, MEM_RELEASE | MEM_SYSTEM );
165     info.stack_size = size;
166
167     size = 0;
168     NtFreeVirtualMemory( GetCurrentProcess(), &info.teb_base, &size, MEM_RELEASE | MEM_SYSTEM );
169     info.teb_size = size;
170
171     close( fds[0] );
172     close( fds[1] );
173     close( fds[2] );
174     close( fds[3] );
175     pthread_functions.exit_thread( &info );
176 }
177
178
179 /***********************************************************************
180  *           server_abort_thread
181  */
182 void server_abort_thread( int status )
183 {
184     pthread_functions.sigprocmask( SIG_BLOCK, &server_block_set, NULL );
185     close( ntdll_get_thread_data()->wait_fd[0] );
186     close( ntdll_get_thread_data()->wait_fd[1] );
187     close( ntdll_get_thread_data()->reply_fd );
188     close( ntdll_get_thread_data()->request_fd );
189     pthread_functions.abort_thread( status );
190 }
191
192
193 /***********************************************************************
194  *           server_protocol_error
195  */
196 void server_protocol_error( const char *err, ... )
197 {
198     va_list args;
199
200     va_start( args, err );
201     fprintf( stderr, "wine client error:%x: ", GetCurrentThreadId() );
202     vfprintf( stderr, err, args );
203     va_end( args );
204     server_abort_thread(1);
205 }
206
207
208 /***********************************************************************
209  *           server_protocol_perror
210  */
211 void server_protocol_perror( const char *err )
212 {
213     fprintf( stderr, "wine client error:%x: ", GetCurrentThreadId() );
214     perror( err );
215     server_abort_thread(1);
216 }
217
218
219 /***********************************************************************
220  *           send_request
221  *
222  * Send a request to the server.
223  */
224 static unsigned int send_request( const struct __server_request_info *req )
225 {
226     unsigned int i;
227     int ret;
228
229     if (!req->u.req.request_header.request_size)
230     {
231         if ((ret = write( ntdll_get_thread_data()->request_fd, &req->u.req,
232                           sizeof(req->u.req) )) == sizeof(req->u.req)) return STATUS_SUCCESS;
233
234     }
235     else
236     {
237         struct iovec vec[__SERVER_MAX_DATA+1];
238
239         vec[0].iov_base = (void *)&req->u.req;
240         vec[0].iov_len = sizeof(req->u.req);
241         for (i = 0; i < req->data_count; i++)
242         {
243             vec[i+1].iov_base = (void *)req->data[i].ptr;
244             vec[i+1].iov_len = req->data[i].size;
245         }
246         if ((ret = writev( ntdll_get_thread_data()->request_fd, vec, i+1 )) ==
247             req->u.req.request_header.request_size + sizeof(req->u.req)) return STATUS_SUCCESS;
248     }
249
250     if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
251     if (errno == EPIPE) server_abort_thread(0);
252     if (errno == EFAULT) return STATUS_ACCESS_VIOLATION;
253     server_protocol_perror( "write" );
254 }
255
256
257 /***********************************************************************
258  *           read_reply_data
259  *
260  * Read data from the reply buffer; helper for wait_reply.
261  */
262 static void read_reply_data( void *buffer, size_t size )
263 {
264     int ret;
265
266     for (;;)
267     {
268         if ((ret = read( ntdll_get_thread_data()->reply_fd, buffer, size )) > 0)
269         {
270             if (!(size -= ret)) return;
271             buffer = (char *)buffer + ret;
272             continue;
273         }
274         if (!ret) break;
275         if (errno == EINTR) continue;
276         if (errno == EPIPE) break;
277         server_protocol_perror("read");
278     }
279     /* the server closed the connection; time to die... */
280     server_abort_thread(0);
281 }
282
283
284 /***********************************************************************
285  *           wait_reply
286  *
287  * Wait for a reply from the server.
288  */
289 static inline unsigned int wait_reply( struct __server_request_info *req )
290 {
291     read_reply_data( &req->u.reply, sizeof(req->u.reply) );
292     if (req->u.reply.reply_header.reply_size)
293         read_reply_data( req->reply_data, req->u.reply.reply_header.reply_size );
294     return req->u.reply.reply_header.error;
295 }
296
297
298 /***********************************************************************
299  *           wine_server_call (NTDLL.@)
300  *
301  * Perform a server call.
302  *
303  * PARAMS
304  *     req_ptr [I/O] Function dependent data
305  *
306  * RETURNS
307  *     Depends on server function being called, but usually an NTSTATUS code.
308  *
309  * NOTES
310  *     Use the SERVER_START_REQ and SERVER_END_REQ to help you fill out the
311  *     server request structure for the particular call. E.g:
312  *|     SERVER_START_REQ( event_op )
313  *|     {
314  *|         req->handle = handle;
315  *|         req->op     = SET_EVENT;
316  *|         ret = wine_server_call( req );
317  *|     }
318  *|     SERVER_END_REQ;
319  */
320 unsigned int wine_server_call( void *req_ptr )
321 {
322     struct __server_request_info * const req = req_ptr;
323     sigset_t old_set;
324     unsigned int ret;
325
326     pthread_functions.sigprocmask( SIG_BLOCK, &server_block_set, &old_set );
327     ret = send_request( req );
328     if (!ret) ret = wait_reply( req );
329     pthread_functions.sigprocmask( SIG_SETMASK, &old_set, NULL );
330     return ret;
331 }
332
333
334 /***********************************************************************
335  *           server_enter_uninterrupted_section
336  */
337 void server_enter_uninterrupted_section( RTL_CRITICAL_SECTION *cs, sigset_t *sigset )
338 {
339     pthread_functions.sigprocmask( SIG_BLOCK, &server_block_set, sigset );
340     RtlEnterCriticalSection( cs );
341 }
342
343
344 /***********************************************************************
345  *           server_leave_uninterrupted_section
346  */
347 void server_leave_uninterrupted_section( RTL_CRITICAL_SECTION *cs, sigset_t *sigset )
348 {
349     RtlLeaveCriticalSection( cs );
350     pthread_functions.sigprocmask( SIG_SETMASK, sigset, NULL );
351 }
352
353
354 /***********************************************************************
355  *           wine_server_send_fd   (NTDLL.@)
356  *
357  * Send a file descriptor to the server.
358  *
359  * PARAMS
360  *     fd [I] file descriptor to send
361  *
362  * RETURNS
363  *     nothing
364  */
365 void wine_server_send_fd( int fd )
366 {
367 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
368     struct cmsg_fd cmsg;
369 #endif
370     struct send_fd data;
371     struct msghdr msghdr;
372     struct iovec vec;
373     int ret;
374
375     vec.iov_base = (void *)&data;
376     vec.iov_len  = sizeof(data);
377
378     msghdr.msg_name    = NULL;
379     msghdr.msg_namelen = 0;
380     msghdr.msg_iov     = &vec;
381     msghdr.msg_iovlen  = 1;
382
383 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
384     msghdr.msg_accrights    = (void *)&fd;
385     msghdr.msg_accrightslen = sizeof(fd);
386 #else  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
387     cmsg.header.len   = sizeof(cmsg.header) + sizeof(fd);
388     cmsg.header.level = SOL_SOCKET;
389     cmsg.header.type  = SCM_RIGHTS;
390     cmsg.fd           = fd;
391     msghdr.msg_control    = &cmsg;
392     msghdr.msg_controllen = sizeof(cmsg.header) + sizeof(fd);
393     msghdr.msg_flags      = 0;
394 #endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
395
396     data.tid = GetCurrentThreadId();
397     data.fd  = fd;
398
399     for (;;)
400     {
401         if ((ret = sendmsg( fd_socket, &msghdr, 0 )) == sizeof(data)) return;
402         if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
403         if (errno == EINTR) continue;
404         if (errno == EPIPE) server_abort_thread(0);
405         server_protocol_perror( "sendmsg" );
406     }
407 }
408
409
410 /***********************************************************************
411  *           receive_fd
412  *
413  * Receive a file descriptor passed from the server.
414  */
415 static int receive_fd( obj_handle_t *handle )
416 {
417     struct iovec vec;
418     int ret, fd;
419
420 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
421     struct msghdr msghdr;
422
423     fd = -1;
424     msghdr.msg_accrights    = (void *)&fd;
425     msghdr.msg_accrightslen = sizeof(fd);
426 #else  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
427     struct msghdr msghdr;
428     struct cmsg_fd cmsg;
429
430     cmsg.header.len   = sizeof(cmsg.header) + sizeof(fd);
431     cmsg.header.level = SOL_SOCKET;
432     cmsg.header.type  = SCM_RIGHTS;
433     cmsg.fd           = -1;
434     msghdr.msg_control    = &cmsg;
435     msghdr.msg_controllen = sizeof(cmsg.header) + sizeof(fd);
436     msghdr.msg_flags      = 0;
437 #endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
438
439     msghdr.msg_name    = NULL;
440     msghdr.msg_namelen = 0;
441     msghdr.msg_iov     = &vec;
442     msghdr.msg_iovlen  = 1;
443     vec.iov_base = (void *)handle;
444     vec.iov_len  = sizeof(*handle);
445
446     for (;;)
447     {
448         if ((ret = recvmsg( fd_socket, &msghdr, 0 )) > 0)
449         {
450 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
451             fd = cmsg.fd;
452 #endif
453             if (fd != -1) fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
454             return fd;
455         }
456         if (!ret) break;
457         if (errno == EINTR) continue;
458         if (errno == EPIPE) break;
459         server_protocol_perror("recvmsg");
460     }
461     /* the server closed the connection; time to die... */
462     server_abort_thread(0);
463 }
464
465
466 /***********************************************************************/
467 /* fd cache support */
468
469 struct fd_cache_entry
470 {
471     int fd;
472     enum server_fd_type type : 6;
473     unsigned int        access : 2;
474     unsigned int        options : 24;
475 };
476
477 #define FD_CACHE_BLOCK_SIZE  (65536 / sizeof(struct fd_cache_entry))
478 #define FD_CACHE_ENTRIES     128
479
480 static struct fd_cache_entry *fd_cache[FD_CACHE_ENTRIES];
481 static struct fd_cache_entry fd_cache_initial_block[FD_CACHE_BLOCK_SIZE];
482
483 static inline unsigned int handle_to_index( obj_handle_t handle, unsigned int *entry )
484 {
485     unsigned long idx = ((unsigned long)handle >> 2) - 1;
486     *entry = idx / FD_CACHE_BLOCK_SIZE;
487     return idx % FD_CACHE_BLOCK_SIZE;
488 }
489
490
491 /***********************************************************************
492  *           add_fd_to_cache
493  *
494  * Caller must hold fd_cache_section.
495  */
496 static int add_fd_to_cache( obj_handle_t handle, int fd, enum server_fd_type type,
497                             unsigned int access, unsigned int options )
498 {
499     unsigned int entry, idx = handle_to_index( handle, &entry );
500     int prev_fd;
501
502     if (entry >= FD_CACHE_ENTRIES)
503     {
504         FIXME( "too many allocated handles, not caching %p\n", handle );
505         return 0;
506     }
507
508     if (!fd_cache[entry])  /* do we need to allocate a new block of entries? */
509     {
510         if (!entry) fd_cache[0] = fd_cache_initial_block;
511         else
512         {
513             void *ptr = wine_anon_mmap( NULL, FD_CACHE_BLOCK_SIZE * sizeof(struct fd_cache_entry),
514                                         PROT_READ | PROT_WRITE, 0 );
515             if (ptr == MAP_FAILED) return 0;
516             fd_cache[entry] = ptr;
517         }
518     }
519     /* store fd+1 so that 0 can be used as the unset value */
520     prev_fd = interlocked_xchg( &fd_cache[entry][idx].fd, fd + 1 ) - 1;
521     fd_cache[entry][idx].type = type;
522     fd_cache[entry][idx].access = access;
523     fd_cache[entry][idx].options = options;
524     if (prev_fd != -1) close( prev_fd );
525     return 1;
526 }
527
528
529 /***********************************************************************
530  *           get_cached_fd
531  *
532  * Caller must hold fd_cache_section.
533  */
534 static inline int get_cached_fd( obj_handle_t handle, enum server_fd_type *type,
535                                  unsigned int *access, unsigned int *options )
536 {
537     unsigned int entry, idx = handle_to_index( handle, &entry );
538     int fd = -1;
539
540     if (entry < FD_CACHE_ENTRIES && fd_cache[entry])
541     {
542         fd = fd_cache[entry][idx].fd - 1;
543         if (type) *type = fd_cache[entry][idx].type;
544         if (access) *access = fd_cache[entry][idx].access;
545         if (options) *options = fd_cache[entry][idx].options;
546     }
547     return fd;
548 }
549
550
551 /***********************************************************************
552  *           server_remove_fd_from_cache
553  */
554 int server_remove_fd_from_cache( obj_handle_t handle )
555 {
556     unsigned int entry, idx = handle_to_index( handle, &entry );
557     int fd = -1;
558
559     if (entry < FD_CACHE_ENTRIES && fd_cache[entry])
560         fd = interlocked_xchg( &fd_cache[entry][idx].fd, 0 ) - 1;
561
562     return fd;
563 }
564
565
566 /***********************************************************************
567  *           server_get_unix_fd
568  *
569  * The returned unix_fd should be closed iff needs_close is non-zero.
570  */
571 int server_get_unix_fd( obj_handle_t handle, unsigned int wanted_access, int *unix_fd,
572                         int *needs_close, enum server_fd_type *type, unsigned int *options )
573 {
574     sigset_t sigset;
575     obj_handle_t fd_handle;
576     int ret = 0, fd;
577     unsigned int access = 0;
578
579     *unix_fd = -1;
580     *needs_close = 0;
581     wanted_access &= FILE_READ_DATA | FILE_WRITE_DATA;
582
583     server_enter_uninterrupted_section( &fd_cache_section, &sigset );
584
585     fd = get_cached_fd( handle, type, &access, options );
586     if (fd != -1) goto done;
587
588     SERVER_START_REQ( get_handle_fd )
589     {
590         req->handle = handle;
591         if (!(ret = wine_server_call( req )))
592         {
593             if (type) *type = reply->type;
594             if (options) *options = reply->options;
595             access = reply->access;
596             if ((fd = receive_fd( &fd_handle )) != -1)
597             {
598                 assert( fd_handle == handle );
599                 *needs_close = (reply->removable ||
600                                 !add_fd_to_cache( handle, fd, reply->type,
601                                                   reply->access, reply->options ));
602             }
603             else ret = STATUS_TOO_MANY_OPENED_FILES;
604         }
605     }
606     SERVER_END_REQ;
607
608 done:
609     server_leave_uninterrupted_section( &fd_cache_section, &sigset );
610     if (!ret && ((access & wanted_access) != wanted_access))
611     {
612         ret = STATUS_ACCESS_DENIED;
613         if (*needs_close) close( fd );
614     }
615     if (!ret) *unix_fd = fd;
616     return ret;
617 }
618
619
620 /***********************************************************************
621  *           wine_server_fd_to_handle   (NTDLL.@)
622  *
623  * Allocate a file handle for a Unix file descriptor.
624  *
625  * PARAMS
626  *     fd      [I] Unix file descriptor.
627  *     access  [I] Win32 access flags.
628  *     attributes [I] Object attributes.
629  *     handle  [O] Address where Wine file handle will be stored.
630  *
631  * RETURNS
632  *     NTSTATUS code
633  */
634 int wine_server_fd_to_handle( int fd, unsigned int access, unsigned int attributes, obj_handle_t *handle )
635 {
636     int ret;
637
638     *handle = 0;
639     wine_server_send_fd( fd );
640
641     SERVER_START_REQ( alloc_file_handle )
642     {
643         req->access     = access;
644         req->attributes = attributes;
645         req->fd         = fd;
646         if (!(ret = wine_server_call( req ))) *handle = reply->handle;
647     }
648     SERVER_END_REQ;
649     return ret;
650 }
651
652
653 /***********************************************************************
654  *           wine_server_handle_to_fd   (NTDLL.@)
655  *
656  * Retrieve the file descriptor corresponding to a file handle.
657  *
658  * PARAMS
659  *     handle  [I] Wine file handle.
660  *     access  [I] Win32 file access rights requested.
661  *     unix_fd [O] Address where Unix file descriptor will be stored.
662  *     options [O] Address where the file open options will be stored. Optional.
663  *
664  * RETURNS
665  *     NTSTATUS code
666  */
667 int wine_server_handle_to_fd( obj_handle_t handle, unsigned int access, int *unix_fd,
668                               unsigned int *options )
669 {
670     int needs_close, ret = server_get_unix_fd( handle, access, unix_fd, &needs_close, NULL, options );
671
672     if (!ret && !needs_close)
673     {
674         if ((*unix_fd = dup(*unix_fd)) == -1) ret = FILE_GetNtStatus();
675     }
676     return ret;
677 }
678
679
680 /***********************************************************************
681  *           wine_server_release_fd   (NTDLL.@)
682  *
683  * Release the Unix file descriptor returned by wine_server_handle_to_fd.
684  *
685  * PARAMS
686  *     handle  [I] Wine file handle.
687  *     unix_fd [I] Unix file descriptor to release.
688  *
689  * RETURNS
690  *     nothing
691  */
692 void wine_server_release_fd( obj_handle_t handle, int unix_fd )
693 {
694     close( unix_fd );
695 }
696
697
698 /***********************************************************************
699  *           start_server
700  *
701  * Start a new wine server.
702  */
703 static void start_server(void)
704 {
705     static int started;  /* we only try once */
706     char *argv[3];
707     static char wineserver[] = "server/wineserver";
708     static char debug[] = "-d";
709
710     if (!started)
711     {
712         int status;
713         int pid = fork();
714         if (pid == -1) fatal_perror( "fork" );
715         if (!pid)
716         {
717             argv[0] = wineserver;
718             argv[1] = TRACE_ON(server) ? debug : NULL;
719             argv[2] = NULL;
720             wine_exec_wine_binary( argv[0], argv, getenv("WINESERVER") );
721             fatal_error( "could not exec wineserver\n" );
722         }
723         waitpid( pid, &status, 0 );
724         status = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
725         if (status == 2) return;  /* server lock held by someone else, will retry later */
726         if (status) exit(status);  /* server failed */
727         started = 1;
728     }
729 }
730
731
732 /***********************************************************************
733  *           setup_config_dir
734  *
735  * Setup the wine configuration dir.
736  */
737 static void setup_config_dir(void)
738 {
739     const char *p, *config_dir = wine_get_config_dir();
740
741     if (chdir( config_dir ) == -1)
742     {
743         if (errno != ENOENT) fatal_perror( "chdir to %s\n", config_dir );
744
745         if ((p = strrchr( config_dir, '/' )) && p != config_dir)
746         {
747             struct stat st;
748             char *tmp_dir;
749
750             if (!(tmp_dir = malloc( p + 1 - config_dir ))) fatal_error( "out of memory\n" );
751             memcpy( tmp_dir, config_dir, p - config_dir );
752             tmp_dir[p - config_dir] = 0;
753             if (!stat( tmp_dir, &st ) && st.st_uid != getuid())
754                 fatal_error( "'%s' is not owned by you, refusing to create a configuration directory there\n",
755                              tmp_dir );
756             free( tmp_dir );
757         }
758
759         mkdir( config_dir, 0777 );
760         if (chdir( config_dir ) == -1) fatal_perror( "chdir to %s\n", config_dir );
761         MESSAGE( "wine: created the configuration directory '%s'\n", config_dir );
762     }
763
764     if (mkdir( "dosdevices", 0777 ) == -1)
765     {
766         if (errno == EEXIST) return;
767         fatal_perror( "cannot create %s/dosdevices\n", config_dir );
768     }
769
770     /* create the drive symlinks */
771
772     mkdir( "drive_c", 0777 );
773     symlink( "../drive_c", "dosdevices/c:" );
774     symlink( "/", "dosdevices/z:" );
775 }
776
777
778 /***********************************************************************
779  *           server_connect_error
780  *
781  * Try to display a meaningful explanation of why we couldn't connect
782  * to the server.
783  */
784 static void server_connect_error( const char *serverdir )
785 {
786     int fd;
787     struct flock fl;
788
789     if ((fd = open( LOCKNAME, O_WRONLY )) == -1)
790         fatal_error( "for some mysterious reason, the wine server never started.\n" );
791
792     fl.l_type   = F_WRLCK;
793     fl.l_whence = SEEK_SET;
794     fl.l_start  = 0;
795     fl.l_len    = 1;
796     if (fcntl( fd, F_GETLK, &fl ) != -1)
797     {
798         if (fl.l_type == F_WRLCK)  /* the file is locked */
799             fatal_error( "a wine server seems to be running, but I cannot connect to it.\n"
800                          "   You probably need to kill that process (it might be pid %d).\n",
801                          (int)fl.l_pid );
802         fatal_error( "for some mysterious reason, the wine server failed to run.\n" );
803     }
804     fatal_error( "the file system of '%s' doesn't support locks,\n"
805           "   and there is a 'socket' file in that directory that prevents wine from starting.\n"
806           "   You should make sure no wine server is running, remove that file and try again.\n",
807                  serverdir );
808 }
809
810
811 /***********************************************************************
812  *           server_connect
813  *
814  * Attempt to connect to an existing server socket.
815  * We need to be in the server directory already.
816  */
817 static int server_connect(void)
818 {
819     const char *serverdir;
820     struct sockaddr_un addr;
821     struct stat st;
822     int s, slen, retry, fd_cwd;
823
824     /* retrieve the current directory */
825     fd_cwd = open( ".", O_RDONLY );
826     if (fd_cwd != -1) fcntl( fd_cwd, F_SETFD, 1 ); /* set close on exec flag */
827
828     setup_config_dir();
829     serverdir = wine_get_server_dir();
830
831     /* chdir to the server directory */
832     if (chdir( serverdir ) == -1)
833     {
834         if (errno != ENOENT) fatal_perror( "chdir to %s", serverdir );
835         start_server();
836         if (chdir( serverdir ) == -1) fatal_perror( "chdir to %s", serverdir );
837     }
838
839     /* make sure we are at the right place */
840     if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
841     if (st.st_uid != getuid()) fatal_error( "'%s' is not owned by you\n", serverdir );
842     if (st.st_mode & 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir );
843
844     for (retry = 0; retry < 6; retry++)
845     {
846         /* if not the first try, wait a bit to leave the previous server time to exit */
847         if (retry)
848         {
849             usleep( 100000 * retry * retry );
850             start_server();
851             if (lstat( SOCKETNAME, &st ) == -1) continue;  /* still no socket, wait a bit more */
852         }
853         else if (lstat( SOCKETNAME, &st ) == -1) /* check for an already existing socket */
854         {
855             if (errno != ENOENT) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
856             start_server();
857             if (lstat( SOCKETNAME, &st ) == -1) continue;  /* still no socket, wait a bit more */
858         }
859
860         /* make sure the socket is sane (ISFIFO needed for Solaris) */
861         if (!S_ISSOCK(st.st_mode) && !S_ISFIFO(st.st_mode))
862             fatal_error( "'%s/%s' is not a socket\n", serverdir, SOCKETNAME );
863         if (st.st_uid != getuid())
864             fatal_error( "'%s/%s' is not owned by you\n", serverdir, SOCKETNAME );
865
866         /* try to connect to it */
867         addr.sun_family = AF_UNIX;
868         strcpy( addr.sun_path, SOCKETNAME );
869         slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
870 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
871         addr.sun_len = slen;
872 #endif
873         if ((s = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
874         if (connect( s, (struct sockaddr *)&addr, slen ) != -1)
875         {
876             /* switch back to the starting directory */
877             if (fd_cwd != -1)
878             {
879                 fchdir( fd_cwd );
880                 close( fd_cwd );
881             }
882             fcntl( s, F_SETFD, 1 ); /* set close on exec flag */
883             return s;
884         }
885         close( s );
886     }
887     server_connect_error( serverdir );
888 }
889
890
891 #ifdef __APPLE__
892 #include <mach/mach.h>
893 #include <mach/mach_error.h>
894 #include <servers/bootstrap.h>
895
896 /* send our task port to the server */
897 static void send_server_task_port(void)
898 {
899     mach_port_t bootstrap_port, wineserver_port;
900     kern_return_t kret;
901
902     struct {
903         mach_msg_header_t           header;
904         mach_msg_body_t             body;
905         mach_msg_port_descriptor_t  task_port;
906     } msg;
907
908     if (task_get_bootstrap_port(mach_task_self(), &bootstrap_port) != KERN_SUCCESS) return;
909
910     kret = bootstrap_look_up(bootstrap_port, (char*)wine_get_server_dir(), &wineserver_port);
911     if (kret != KERN_SUCCESS)
912         fatal_error( "cannot find the server port: 0x%08x\n", kret );
913
914     mach_port_deallocate(mach_task_self(), bootstrap_port);
915
916     msg.header.msgh_bits        = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) | MACH_MSGH_BITS_COMPLEX;
917     msg.header.msgh_size        = sizeof(msg);
918     msg.header.msgh_remote_port = wineserver_port;
919     msg.header.msgh_local_port  = MACH_PORT_NULL;
920
921     msg.body.msgh_descriptor_count  = 1;
922     msg.task_port.name              = mach_task_self();
923     msg.task_port.disposition       = MACH_MSG_TYPE_COPY_SEND;
924     msg.task_port.type              = MACH_MSG_PORT_DESCRIPTOR;
925
926     kret = mach_msg_send(&msg.header);
927     if (kret != KERN_SUCCESS)
928         server_protocol_error( "mach_msg_send failed: 0x%08x\n", kret );
929
930     mach_port_deallocate(mach_task_self(), wineserver_port);
931 }
932 #endif  /* __APPLE__ */
933
934 /***********************************************************************
935  *           server_init_process
936  *
937  * Start the server and create the initial socket pair.
938  */
939 void server_init_process(void)
940 {
941     obj_handle_t dummy_handle;
942     const char *env_socket = getenv( "WINESERVERSOCKET" );
943
944     if (env_socket)
945     {
946         fd_socket = atoi( env_socket );
947         if (fcntl( fd_socket, F_SETFD, 1 ) == -1)
948             fatal_perror( "Bad server socket %d", fd_socket );
949         unsetenv( "WINESERVERSOCKET" );
950     }
951     else fd_socket = server_connect();
952
953     /* setup the signal mask */
954     sigemptyset( &server_block_set );
955     sigaddset( &server_block_set, SIGALRM );
956     sigaddset( &server_block_set, SIGIO );
957     sigaddset( &server_block_set, SIGINT );
958     sigaddset( &server_block_set, SIGHUP );
959     sigaddset( &server_block_set, SIGUSR1 );
960     sigaddset( &server_block_set, SIGUSR2 );
961     sigaddset( &server_block_set, SIGCHLD );
962     pthread_functions.sigprocmask( SIG_BLOCK, &server_block_set, NULL );
963
964     /* receive the first thread request fd on the main socket */
965     ntdll_get_thread_data()->request_fd = receive_fd( &dummy_handle );
966
967 #ifdef __APPLE__
968     send_server_task_port();
969 #endif
970 }
971
972
973 /***********************************************************************
974  *           server_init_process_done
975  */
976 NTSTATUS server_init_process_done(void)
977 {
978     PEB *peb = NtCurrentTeb()->Peb;
979     IMAGE_NT_HEADERS *nt = RtlImageNtHeader( peb->ImageBaseAddress );
980     NTSTATUS status;
981
982     /* Install signal handlers; this cannot be done earlier, since we cannot
983      * send exceptions to the debugger before the create process event that
984      * is sent by REQ_INIT_PROCESS_DONE.
985      * We do need the handlers in place by the time the request is over, so
986      * we set them up here. If we segfault between here and the server call
987      * something is very wrong... */
988     signal_init_process();
989
990     /* Signal the parent process to continue */
991     SERVER_START_REQ( init_process_done )
992     {
993         req->module = peb->ImageBaseAddress;
994         req->entry  = (char *)peb->ImageBaseAddress + nt->OptionalHeader.AddressOfEntryPoint;
995         req->gui    = (nt->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_CUI);
996         status = wine_server_call( req );
997     }
998     SERVER_END_REQ;
999
1000     return status;
1001 }
1002
1003
1004 /***********************************************************************
1005  *           server_init_thread
1006  *
1007  * Send an init thread request. Return 0 if OK.
1008  */
1009 size_t server_init_thread( int unix_pid, int unix_tid, void *entry_point )
1010 {
1011     int version, ret;
1012     int reply_pipe[2];
1013     struct sigaction sig_act;
1014     size_t info_size;
1015
1016     sig_act.sa_handler = SIG_IGN;
1017     sig_act.sa_flags   = 0;
1018     sigemptyset( &sig_act.sa_mask );
1019
1020     /* ignore SIGPIPE so that we get an EPIPE error instead  */
1021     sigaction( SIGPIPE, &sig_act, NULL );
1022     /* automatic child reaping to avoid zombies */
1023 #ifdef SA_NOCLDWAIT
1024     sig_act.sa_flags |= SA_NOCLDWAIT;
1025 #endif
1026     sigaction( SIGCHLD, &sig_act, NULL );
1027
1028     /* create the server->client communication pipes */
1029     if (pipe( reply_pipe ) == -1) server_protocol_perror( "pipe" );
1030     if (pipe( ntdll_get_thread_data()->wait_fd ) == -1) server_protocol_perror( "pipe" );
1031     wine_server_send_fd( reply_pipe[1] );
1032     wine_server_send_fd( ntdll_get_thread_data()->wait_fd[1] );
1033     ntdll_get_thread_data()->reply_fd = reply_pipe[0];
1034     close( reply_pipe[1] );
1035
1036     /* set close on exec flag */
1037     fcntl( ntdll_get_thread_data()->reply_fd, F_SETFD, 1 );
1038     fcntl( ntdll_get_thread_data()->wait_fd[0], F_SETFD, 1 );
1039     fcntl( ntdll_get_thread_data()->wait_fd[1], F_SETFD, 1 );
1040
1041     SERVER_START_REQ( init_thread )
1042     {
1043         req->unix_pid    = unix_pid;
1044         req->unix_tid    = unix_tid;
1045         req->teb         = NtCurrentTeb();
1046         req->peb         = NtCurrentTeb()->Peb;
1047         req->entry       = entry_point;
1048         req->ldt_copy    = &wine_ldt_copy;
1049         req->reply_fd    = reply_pipe[1];
1050         req->wait_fd     = ntdll_get_thread_data()->wait_fd[1];
1051         req->debug_level = (TRACE_ON(server) != 0);
1052         ret = wine_server_call( req );
1053         NtCurrentTeb()->ClientId.UniqueProcess = ULongToHandle(reply->pid);
1054         NtCurrentTeb()->ClientId.UniqueThread  = ULongToHandle(reply->tid);
1055         info_size         = reply->info_size;
1056         version           = reply->version;
1057         server_start_time = reply->server_start;
1058     }
1059     SERVER_END_REQ;
1060
1061     if (ret) server_protocol_error( "init_thread failed with status %x\n", ret );
1062     if (version != SERVER_PROTOCOL_VERSION)
1063         server_protocol_error( "version mismatch %d/%d.\n"
1064                                "Your %s binary was not upgraded correctly,\n"
1065                                "or you have an older one somewhere in your PATH.\n"
1066                                "Or maybe the wrong wineserver is still running?\n",
1067                                version, SERVER_PROTOCOL_VERSION,
1068                                (version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );
1069     return info_size;
1070 }