Added stub implementations for NtDeleteFile and NtCancelIoFile.
[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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #include <sys/stat.h>
47 #ifdef HAVE_SYS_UIO_H
48 #include <sys/uio.h>
49 #endif
50 #ifdef HAVE_UNISTD_H
51 # include <unistd.h>
52 #endif
53
54 #include "ntstatus.h"
55 #include "thread.h"
56 #include "wine/library.h"
57 #include "wine/pthread.h"
58 #include "wine/server.h"
59 #include "wine/debug.h"
60 #include "winerror.h"
61 #include "ntdll_misc.h"
62
63 WINE_DEFAULT_DEBUG_CHANNEL(server);
64
65 /* Some versions of glibc don't define this */
66 #ifndef SCM_RIGHTS
67 #define SCM_RIGHTS 1
68 #endif
69
70 #define SOCKETNAME "socket"        /* name of the socket file */
71 #define LOCKNAME   "lock"          /* name of the lock file */
72
73 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
74 /* data structure used to pass an fd with sendmsg/recvmsg */
75 struct cmsg_fd
76 {
77     int len;   /* size of structure */
78     int level; /* SOL_SOCKET */
79     int type;  /* SCM_RIGHTS */
80     int fd;    /* fd to pass */
81 };
82 #endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
83
84 static sigset_t block_set;  /* signals to block during server calls */
85 static int fd_socket = -1;  /* socket to exchange file descriptors with the server */
86
87 #ifdef __GNUC__
88 static void fatal_error( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
89 static void fatal_perror( const char *err, ... ) __attribute__((noreturn, format(printf,1,2)));
90 static void server_connect_error( const char *serverdir ) __attribute__((noreturn));
91 #endif
92
93 /* die on a fatal error; use only during initialization */
94 static void fatal_error( const char *err, ... )
95 {
96     va_list args;
97
98     va_start( args, err );
99     fprintf( stderr, "wine: " );
100     vfprintf( stderr, err, args );
101     va_end( args );
102     exit(1);
103 }
104
105 /* die on a fatal error; use only during initialization */
106 static void fatal_perror( const char *err, ... )
107 {
108     va_list args;
109
110     va_start( args, err );
111     fprintf( stderr, "wine: " );
112     vfprintf( stderr, err, args );
113     perror( " " );
114     va_end( args );
115     exit(1);
116 }
117
118
119 /***********************************************************************
120  *           server_abort_thread
121  */
122 void server_abort_thread( int status )
123 {
124     sigprocmask( SIG_BLOCK, &block_set, NULL );
125     close( NtCurrentTeb()->wait_fd[0] );
126     close( NtCurrentTeb()->wait_fd[1] );
127     close( NtCurrentTeb()->reply_fd );
128     close( NtCurrentTeb()->request_fd );
129     wine_pthread_abort_thread( status );
130 }
131
132
133 /***********************************************************************
134  *           server_protocol_error
135  */
136 void server_protocol_error( const char *err, ... )
137 {
138     va_list args;
139
140     va_start( args, err );
141     fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
142     vfprintf( stderr, err, args );
143     va_end( args );
144     server_abort_thread(1);
145 }
146
147
148 /***********************************************************************
149  *           server_protocol_perror
150  */
151 void server_protocol_perror( const char *err )
152 {
153     fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
154     perror( err );
155     server_abort_thread(1);
156 }
157
158
159 /***********************************************************************
160  *           send_request
161  *
162  * Send a request to the server.
163  */
164 static void send_request( const struct __server_request_info *req )
165 {
166     unsigned int i;
167     int ret;
168
169     if (!req->u.req.request_header.request_size)
170     {
171         if ((ret = write( NtCurrentTeb()->request_fd, &req->u.req,
172                           sizeof(req->u.req) )) == sizeof(req->u.req)) return;
173
174     }
175     else
176     {
177         struct iovec vec[__SERVER_MAX_DATA+1];
178
179         vec[0].iov_base = (void *)&req->u.req;
180         vec[0].iov_len = sizeof(req->u.req);
181         for (i = 0; i < req->data_count; i++)
182         {
183             vec[i+1].iov_base = (void *)req->data[i].ptr;
184             vec[i+1].iov_len = req->data[i].size;
185         }
186         if ((ret = writev( NtCurrentTeb()->request_fd, vec, i+1 )) ==
187             req->u.req.request_header.request_size + sizeof(req->u.req)) return;
188     }
189
190     if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
191     if (errno == EPIPE) server_abort_thread(0);
192     server_protocol_perror( "write" );
193 }
194
195
196 /***********************************************************************
197  *           read_reply_data
198  *
199  * Read data from the reply buffer; helper for wait_reply.
200  */
201 static void read_reply_data( void *buffer, size_t size )
202 {
203     int ret;
204
205     for (;;)
206     {
207         if ((ret = read( NtCurrentTeb()->reply_fd, buffer, size )) > 0)
208         {
209             if (!(size -= ret)) return;
210             buffer = (char *)buffer + ret;
211             continue;
212         }
213         if (!ret) break;
214         if (errno == EINTR) continue;
215         if (errno == EPIPE) break;
216         server_protocol_perror("read");
217     }
218     /* the server closed the connection; time to die... */
219     server_abort_thread(0);
220 }
221
222
223 /***********************************************************************
224  *           wait_reply
225  *
226  * Wait for a reply from the server.
227  */
228 inline static void wait_reply( struct __server_request_info *req )
229 {
230     read_reply_data( &req->u.reply, sizeof(req->u.reply) );
231     if (req->u.reply.reply_header.reply_size)
232         read_reply_data( req->reply_data, req->u.reply.reply_header.reply_size );
233 }
234
235
236 /***********************************************************************
237  *           wine_server_call (NTDLL.@)
238  *
239  * Perform a server call.
240  *
241  * PARAMS
242  *     req_ptr [I/O] Function dependent data
243  *
244  * RETURNS
245  *     Depends on server function being called, but usually an NTSTATUS code.
246  *
247  * NOTES
248  *     Use the SERVER_START_REQ and SERVER_END_REQ to help you fill out the
249  *     server request structure for the particular call. E.g:
250  *|     SERVER_START_REQ( event_op )
251  *|     {
252  *|         req->handle = handle;
253  *|         req->op     = SET_EVENT;
254  *|         ret = wine_server_call( req );
255  *|     }
256  *|     SERVER_END_REQ;
257  */
258 unsigned int wine_server_call( void *req_ptr )
259 {
260     struct __server_request_info * const req = req_ptr;
261     sigset_t old_set;
262
263     sigprocmask( SIG_BLOCK, &block_set, &old_set );
264     send_request( req );
265     wait_reply( req );
266     sigprocmask( SIG_SETMASK, &old_set, NULL );
267     return req->u.reply.reply_header.error;
268 }
269
270
271 /***********************************************************************
272  *           wine_server_send_fd   (NTDLL.@)
273  *
274  * Send a file descriptor to the server.
275  *
276  * PARAMS
277  *     fd [I] file descriptor to send
278  *
279  * RETURNS
280  *     nothing
281  */
282 void wine_server_send_fd( int fd )
283 {
284 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
285     struct cmsg_fd cmsg;
286 #endif
287     struct send_fd data;
288     struct msghdr msghdr;
289     struct iovec vec;
290     int ret;
291
292     vec.iov_base = (void *)&data;
293     vec.iov_len  = sizeof(data);
294
295     msghdr.msg_name    = NULL;
296     msghdr.msg_namelen = 0;
297     msghdr.msg_iov     = &vec;
298     msghdr.msg_iovlen  = 1;
299
300 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
301     msghdr.msg_accrights    = (void *)&fd;
302     msghdr.msg_accrightslen = sizeof(fd);
303 #else  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
304     cmsg.len   = sizeof(cmsg);
305     cmsg.level = SOL_SOCKET;
306     cmsg.type  = SCM_RIGHTS;
307     cmsg.fd    = fd;
308     msghdr.msg_control    = &cmsg;
309     msghdr.msg_controllen = sizeof(cmsg);
310     msghdr.msg_flags      = 0;
311 #endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
312
313     data.tid = GetCurrentThreadId();
314     data.fd  = fd;
315
316     for (;;)
317     {
318         if ((ret = sendmsg( fd_socket, &msghdr, 0 )) == sizeof(data)) return;
319         if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
320         if (errno == EINTR) continue;
321         if (errno == EPIPE) server_abort_thread(0);
322         server_protocol_perror( "sendmsg" );
323     }
324 }
325
326
327 /***********************************************************************
328  *           receive_fd
329  *
330  * Receive a file descriptor passed from the server.
331  */
332 static int receive_fd( obj_handle_t *handle )
333 {
334     struct iovec vec;
335     int ret, fd;
336
337 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
338     struct msghdr msghdr;
339
340     fd = -1;
341     msghdr.msg_accrights    = (void *)&fd;
342     msghdr.msg_accrightslen = sizeof(fd);
343 #else  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
344     struct msghdr msghdr;
345     struct cmsg_fd cmsg;
346
347     cmsg.len   = sizeof(cmsg);
348     cmsg.level = SOL_SOCKET;
349     cmsg.type  = SCM_RIGHTS;
350     cmsg.fd    = -1;
351     msghdr.msg_control    = &cmsg;
352     msghdr.msg_controllen = sizeof(cmsg);
353     msghdr.msg_flags      = 0;
354 #endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
355
356     msghdr.msg_name    = NULL;
357     msghdr.msg_namelen = 0;
358     msghdr.msg_iov     = &vec;
359     msghdr.msg_iovlen  = 1;
360     vec.iov_base = (void *)handle;
361     vec.iov_len  = sizeof(*handle);
362
363     for (;;)
364     {
365         if ((ret = recvmsg( fd_socket, &msghdr, 0 )) > 0)
366         {
367 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
368             fd = cmsg.fd;
369 #endif
370             if (fd == -1) server_protocol_error( "no fd received for handle %d\n", *handle );
371             fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
372             return fd;
373         }
374         if (!ret) break;
375         if (errno == EINTR) continue;
376         if (errno == EPIPE) break;
377         server_protocol_perror("recvmsg");
378     }
379     /* the server closed the connection; time to die... */
380     server_abort_thread(0);
381 }
382
383
384 /***********************************************************************
385  *           store_cached_fd
386  *
387  * Store the cached fd value for a given handle back into the server.
388  * Returns the new fd, which can be different if there was already an
389  * fd in the cache for that handle.
390  */
391 inline static int store_cached_fd( int *fd, obj_handle_t handle )
392 {
393     int ret;
394
395     SERVER_START_REQ( set_handle_info )
396     {
397         req->handle = handle;
398         req->flags  = 0;
399         req->mask   = 0;
400         req->fd     = *fd;
401         if (!(ret = wine_server_call( req )))
402         {
403             if (reply->cur_fd != *fd)
404             {
405                 /* someone was here before us */
406                 close( *fd );
407                 *fd = reply->cur_fd;
408             }
409         }
410         else
411         {
412             close( *fd );
413             *fd = -1;
414         }
415     }
416     SERVER_END_REQ;
417     return ret;
418 }
419
420
421 /***********************************************************************
422  *           wine_server_fd_to_handle   (NTDLL.@)
423  *
424  * Allocate a file handle for a Unix file descriptor.
425  *
426  * PARAMS
427  *     fd      [I] Unix file descriptor.
428  *     access  [I] Win32 access flags.
429  *     inherit [I] Indicates whether this handle is inherited by child processes.
430  *     handle  [O] Address where Wine file handle will be stored.
431  *
432  * RETURNS
433  *     NTSTATUS code
434  */
435 int wine_server_fd_to_handle( int fd, unsigned int access, int inherit, obj_handle_t *handle )
436 {
437     int ret;
438
439     *handle = 0;
440     wine_server_send_fd( fd );
441
442     SERVER_START_REQ( alloc_file_handle )
443     {
444         req->access  = access;
445         req->inherit = inherit;
446         req->fd      = fd;
447         if (!(ret = wine_server_call( req ))) *handle = reply->handle;
448     }
449     SERVER_END_REQ;
450     return ret;
451 }
452
453
454 /***********************************************************************
455  *           wine_server_handle_to_fd   (NTDLL.@)
456  *
457  * Retrieve the file descriptor corresponding to a file handle.
458  *
459  * PARAMS
460  *     handle  [I] Wine file handle.
461  *     access  [I] Win32 file access rights requested.
462  *     unix_fd [O] Address where Unix file descriptor will be stored.
463  *     flags   [O] Address where the Unix flags associated with file will be stored. Optional.
464  *
465  * RETURNS
466  *     NTSTATUS code
467  */
468 int wine_server_handle_to_fd( obj_handle_t handle, unsigned int access, int *unix_fd, int *flags )
469 {
470     obj_handle_t fd_handle;
471     int ret, fd = -1;
472
473     *unix_fd = -1;
474     for (;;)
475     {
476         SERVER_START_REQ( get_handle_fd )
477         {
478             req->handle = handle;
479             req->access = access;
480             if (!(ret = wine_server_call( req ))) fd = reply->fd;
481             if (flags) *flags = reply->flags;
482         }
483         SERVER_END_REQ;
484         if (ret) return ret;
485
486         if (fd != -1) break;
487
488         /* it wasn't in the cache, get it from the server */
489         fd = receive_fd( &fd_handle );
490         /* and store it back into the cache */
491         ret = store_cached_fd( &fd, fd_handle );
492         if (ret) return ret;
493
494         if (fd_handle == handle) break;
495         /* if we received a different handle this means there was
496          * a race with another thread; we restart everything from
497          * scratch in this case.
498          */
499     }
500
501     if ((fd != -1) && ((fd = dup(fd)) == -1)) return STATUS_TOO_MANY_OPENED_FILES;
502     *unix_fd = fd;
503     return STATUS_SUCCESS;
504 }
505
506
507 /***********************************************************************
508  *           wine_server_release_fd   (NTDLL.@)
509  *
510  * Release the Unix file descriptor returned by wine_server_handle_to_fd.
511  *
512  * PARAMS
513  *     handle  [I] Wine file handle.
514  *     unix_fd [I] Unix file descriptor to release.
515  *
516  * RETURNS
517  *     nothing
518  */
519 void wine_server_release_fd( obj_handle_t handle, int unix_fd )
520 {
521     close( unix_fd );
522 }
523
524
525 /***********************************************************************
526  *           start_server
527  *
528  * Start a new wine server.
529  */
530 static void start_server( const char *oldcwd )
531 {
532     static int started;  /* we only try once */
533     char *path, *p;
534     char *argv[3];
535
536     if (!started)
537     {
538         int status;
539         int pid = fork();
540         if (pid == -1) fatal_perror( "fork" );
541         if (!pid)
542         {
543             argv[0] = "wineserver";
544             argv[1] = TRACE_ON(server) ? "-d" : NULL;
545             argv[2] = NULL;
546             /* if server is explicitly specified, use this */
547             if ((p = getenv("WINESERVER")))
548             {
549                 if (p[0] != '/' && oldcwd[0] == '/')  /* make it an absolute path */
550                 {
551                     if (!(path = malloc( strlen(oldcwd) + strlen(p) + 1 )))
552                         fatal_error( "out of memory\n" );
553                     sprintf( path, "%s/%s", oldcwd, p );
554                     p = path;
555                 }
556                 wine_exec_wine_binary( p, argv, NULL, FALSE );
557                 fatal_perror( "could not exec the server '%s'\n"
558                               "    specified in the WINESERVER environment variable", p );
559             }
560             /* now use the standard search strategy */
561             wine_exec_wine_binary( argv[0], argv, NULL, FALSE );
562             fatal_error( "could not exec wineserver\n" );
563         }
564         waitpid( pid, &status, 0 );
565         status = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
566         if (status == 2) return;  /* server lock held by someone else, will retry later */
567         if (status) exit(status);  /* server failed */
568         started = 1;
569     }
570 }
571
572
573 /***********************************************************************
574  *           server_connect_error
575  *
576  * Try to display a meaningful explanation of why we couldn't connect
577  * to the server.
578  */
579 static void server_connect_error( const char *serverdir )
580 {
581     int fd;
582     struct flock fl;
583
584     if ((fd = open( LOCKNAME, O_WRONLY )) == -1)
585         fatal_error( "for some mysterious reason, the wine server never started.\n" );
586
587     fl.l_type   = F_WRLCK;
588     fl.l_whence = SEEK_SET;
589     fl.l_start  = 0;
590     fl.l_len    = 1;
591     if (fcntl( fd, F_GETLK, &fl ) != -1)
592     {
593         if (fl.l_type == F_WRLCK)  /* the file is locked */
594             fatal_error( "a wine server seems to be running, but I cannot connect to it.\n"
595                          "   You probably need to kill that process (it might be pid %d).\n",
596                          (int)fl.l_pid );
597         fatal_error( "for some mysterious reason, the wine server failed to run.\n" );
598     }
599     fatal_error( "the file system of '%s' doesn't support locks,\n"
600           "   and there is a 'socket' file in that directory that prevents wine from starting.\n"
601           "   You should make sure no wine server is running, remove that file and try again.\n",
602                  serverdir );
603 }
604
605
606 /***********************************************************************
607  *           server_connect
608  *
609  * Attempt to connect to an existing server socket.
610  * We need to be in the server directory already.
611  */
612 static int server_connect( const char *oldcwd, const char *serverdir )
613 {
614     struct sockaddr_un addr;
615     struct stat st;
616     int s, slen, retry;
617
618     /* chdir to the server directory */
619     if (chdir( serverdir ) == -1)
620     {
621         if (errno != ENOENT) fatal_perror( "chdir to %s", serverdir );
622         start_server( "." );
623         if (chdir( serverdir ) == -1) fatal_perror( "chdir to %s", serverdir );
624     }
625
626     /* make sure we are at the right place */
627     if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
628     if (st.st_uid != getuid()) fatal_error( "'%s' is not owned by you\n", serverdir );
629     if (st.st_mode & 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir );
630
631     for (retry = 0; retry < 6; retry++)
632     {
633         /* if not the first try, wait a bit to leave the previous server time to exit */
634         if (retry)
635         {
636             usleep( 100000 * retry * retry );
637             start_server( oldcwd );
638             if (lstat( SOCKETNAME, &st ) == -1) continue;  /* still no socket, wait a bit more */
639         }
640         else if (lstat( SOCKETNAME, &st ) == -1) /* check for an already existing socket */
641         {
642             if (errno != ENOENT) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
643             start_server( oldcwd );
644             if (lstat( SOCKETNAME, &st ) == -1) continue;  /* still no socket, wait a bit more */
645         }
646
647         /* make sure the socket is sane (ISFIFO needed for Solaris) */
648         if (!S_ISSOCK(st.st_mode) && !S_ISFIFO(st.st_mode))
649             fatal_error( "'%s/%s' is not a socket\n", serverdir, SOCKETNAME );
650         if (st.st_uid != getuid())
651             fatal_error( "'%s/%s' is not owned by you\n", serverdir, SOCKETNAME );
652
653         /* try to connect to it */
654         addr.sun_family = AF_UNIX;
655         strcpy( addr.sun_path, SOCKETNAME );
656         slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
657 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
658         addr.sun_len = slen;
659 #endif
660         if ((s = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
661         if (connect( s, (struct sockaddr *)&addr, slen ) != -1)
662         {
663             fcntl( s, F_SETFD, 1 ); /* set close on exec flag */
664             return s;
665         }
666         close( s );
667     }
668     server_connect_error( serverdir );
669 }
670
671
672 /***********************************************************************
673  *           rm_rf
674  *
675  * Remove a directory and all its contents; helper for create_config_dir.
676  */
677 static void rm_rf( const char *path )
678 {
679     int err = errno;  /* preserve errno */
680     DIR *dir;
681     char *buffer, *p;
682     struct stat st;
683     struct dirent *de;
684
685     if (!(buffer = malloc( strlen(path) + 256 + 1 ))) goto done;
686     strcpy( buffer, path );
687     p = buffer + strlen(buffer);
688     *p++ = '/';
689
690     if ((dir = opendir( path )))
691     {
692         while ((de = readdir( dir )))
693         {
694             if (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." )) continue;
695             strcpy( p, de->d_name );
696             if (unlink( buffer ) != -1) continue;
697             if (errno == EISDIR ||
698                 (errno == EPERM && !lstat( buffer, &st ) && S_ISDIR(st.st_mode)))
699             {
700                 /* recurse in the sub-directory */
701                 rm_rf( buffer );
702             }
703         }
704         closedir( dir );
705     }
706     free( buffer );
707     rmdir( path );
708 done:
709     errno = err;
710 }
711
712
713 /***********************************************************************
714  *           create_config_dir
715  *
716  * Create the wine configuration dir (~/.wine).
717  */
718 static void create_config_dir(void)
719 {
720     const char *config_dir = wine_get_config_dir();
721     char *tmp_dir;
722     int fd;
723     pid_t pid, wret;
724
725     if (!(tmp_dir = malloc( strlen(config_dir) + sizeof("-XXXXXX") )))
726         fatal_error( "out of memory\n" );
727     strcpy( tmp_dir, config_dir );
728     strcat( tmp_dir, "-XXXXXX" );
729     if ((fd = mkstemps( tmp_dir, 0 )) == -1)
730         fatal_perror( "can't get temp file name for %s", config_dir );
731     close( fd );
732     unlink( tmp_dir );
733     if (mkdir( tmp_dir, 0777 ) == -1)
734         fatal_perror( "cannot create temp dir %s", tmp_dir );
735
736     MESSAGE( "wine: creating configuration directory '%s'...\n", config_dir );
737     pid = fork();
738     if (pid == -1)
739     {
740         rmdir( tmp_dir );
741         fatal_perror( "fork" );
742     }
743     if (!pid)
744     {
745         const char *argv[5];
746
747         argv[0] = "wineprefixcreate";
748         argv[1] = "--quiet";
749         argv[2] = "--prefix";
750         argv[3] = tmp_dir;
751         argv[4] = NULL;
752         wine_exec_wine_binary( argv[0], (char **)argv, NULL, FALSE );
753         rmdir( tmp_dir );
754         fatal_perror( "could not exec wineprefixcreate" );
755     }
756     else
757     {
758         int status;
759
760         while ((wret = waitpid( pid, &status, 0 )) != pid)
761         {
762             if (wret == -1 && errno != EINTR) fatal_perror( "wait4" );
763         }
764         if (!WIFEXITED(status) || WEXITSTATUS(status))
765         {
766             rm_rf( tmp_dir );
767             fatal_error( "wineprefixcreate failed while creating '%s'.\n", config_dir );
768         }
769     }
770     if (rename( tmp_dir, config_dir ) == -1)
771     {
772         rm_rf( tmp_dir );
773         if (errno != EEXIST && errno != ENOTEMPTY)
774             fatal_perror( "rename '%s' to '%s'", tmp_dir, config_dir );
775         /* else it was probably created by a concurrent wine process */
776     }
777     free( tmp_dir );
778     MESSAGE( "wine: '%s' created successfully.\n", config_dir );
779 }
780
781
782 /***********************************************************************
783  *           server_init_process
784  *
785  * Start the server and create the initial socket pair.
786  */
787 void server_init_process(void)
788 {
789     int size;
790     char *oldcwd;
791     obj_handle_t dummy_handle;
792     const char *server_dir = wine_get_server_dir();
793
794     if (!server_dir)  /* this means the config dir doesn't exist */
795     {
796         create_config_dir();
797         server_dir = wine_get_server_dir();
798     }
799
800     /* retrieve the current directory */
801     for (size = 512; ; size *= 2)
802     {
803         if (!(oldcwd = malloc( size ))) break;
804         if (getcwd( oldcwd, size )) break;
805         free( oldcwd );
806         if (errno == ERANGE) continue;
807         oldcwd = NULL;
808         break;
809     }
810
811     /* connect to the server */
812     fd_socket = server_connect( oldcwd, server_dir );
813
814     /* switch back to the starting directory */
815     if (oldcwd)
816     {
817         chdir( oldcwd );
818         free( oldcwd );
819     }
820
821     /* setup the signal mask */
822     sigemptyset( &block_set );
823     sigaddset( &block_set, SIGALRM );
824     sigaddset( &block_set, SIGIO );
825     sigaddset( &block_set, SIGINT );
826     sigaddset( &block_set, SIGHUP );
827     sigaddset( &block_set, SIGUSR1 );
828     sigaddset( &block_set, SIGUSR2 );
829
830     /* receive the first thread request fd on the main socket */
831     NtCurrentTeb()->request_fd = receive_fd( &dummy_handle );
832 }
833
834
835 /***********************************************************************
836  *           server_init_thread
837  *
838  * Send an init thread request. Return 0 if OK.
839  */
840 void server_init_thread( int unix_pid, int unix_tid, void *entry_point )
841 {
842     TEB *teb = NtCurrentTeb();
843     int version, ret;
844     int reply_pipe[2];
845     struct sigaction sig_act;
846
847     sig_act.sa_handler = SIG_IGN;
848     sig_act.sa_flags   = 0;
849     sigemptyset( &sig_act.sa_mask );
850
851     /* ignore SIGPIPE so that we get a EPIPE error instead  */
852     sigaction( SIGPIPE, &sig_act, NULL );
853     /* automatic child reaping to avoid zombies */
854 #ifdef SA_NOCLDWAIT
855     sig_act.sa_flags |= SA_NOCLDWAIT;
856 #endif
857     sigaction( SIGCHLD, &sig_act, NULL );
858
859     /* create the server->client communication pipes */
860     if (pipe( reply_pipe ) == -1) server_protocol_perror( "pipe" );
861     if (pipe( teb->wait_fd ) == -1) server_protocol_perror( "pipe" );
862     wine_server_send_fd( reply_pipe[1] );
863     wine_server_send_fd( teb->wait_fd[1] );
864     teb->reply_fd = reply_pipe[0];
865     close( reply_pipe[1] );
866
867     /* set close on exec flag */
868     fcntl( teb->reply_fd, F_SETFD, 1 );
869     fcntl( teb->wait_fd[0], F_SETFD, 1 );
870     fcntl( teb->wait_fd[1], F_SETFD, 1 );
871
872     SERVER_START_REQ( init_thread )
873     {
874         req->unix_pid    = unix_pid;
875         req->unix_tid    = unix_tid;
876         req->teb         = teb;
877         req->entry       = entry_point;
878         req->reply_fd    = reply_pipe[1];
879         req->wait_fd     = teb->wait_fd[1];
880         ret = wine_server_call( req );
881         teb->ClientId.UniqueProcess = (HANDLE)reply->pid;
882         teb->ClientId.UniqueThread  = (HANDLE)reply->tid;
883         version  = reply->version;
884     }
885     SERVER_END_REQ;
886
887     if (ret) server_protocol_error( "init_thread failed with status %x\n", ret );
888     if (version != SERVER_PROTOCOL_VERSION)
889         server_protocol_error( "version mismatch %d/%d.\n"
890                                "Your %s binary was not upgraded correctly,\n"
891                                "or you have an older one somewhere in your PATH.\n"
892                                "Or maybe the wrong wineserver is still running?\n",
893                                version, SERVER_PROTOCOL_VERSION,
894                                (version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );
895 }