request.c 24.9 KB
Newer Older
Alexandre Julliard's avatar
Alexandre Julliard committed
1 2 3 4
/*
 * Server-side request handling
 *
 * Copyright (C) 1998 Alexandre Julliard
5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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
Alexandre Julliard's avatar
Alexandre Julliard committed
19 20
 */

21
#include "config.h"
22
#include "wine/port.h"
23

24
#include <assert.h>
25 26
#include <errno.h>
#include <fcntl.h>
Steven Edwards's avatar
Steven Edwards committed
27
#ifdef HAVE_PWD_H
28
#include <pwd.h>
Steven Edwards's avatar
Steven Edwards committed
29
#endif
30
#include <signal.h>
Alexandre Julliard's avatar
Alexandre Julliard committed
31 32
#include <stdio.h>
#include <stdlib.h>
33 34
#include <stdarg.h>
#include <string.h>
35
#include <sys/stat.h>
36
#include <sys/time.h>
Alexandre Julliard's avatar
Alexandre Julliard committed
37
#include <sys/types.h>
38 39 40
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
41 42 43
#ifdef HAVE_SYS_WAIT_H
# include <sys/wait.h>
#endif
Steven Edwards's avatar
Steven Edwards committed
44
#ifdef HAVE_SYS_UIO_H
Alexandre Julliard's avatar
Alexandre Julliard committed
45
#include <sys/uio.h>
Steven Edwards's avatar
Steven Edwards committed
46 47
#endif
#ifdef HAVE_SYS_UN_H
48
#include <sys/un.h>
Steven Edwards's avatar
Steven Edwards committed
49
#endif
Alexandre Julliard's avatar
Alexandre Julliard committed
50
#include <unistd.h>
51 52 53
#ifdef HAVE_POLL_H
#include <poll.h>
#endif
Alexandre Julliard's avatar
Alexandre Julliard committed
54

55 56
#include "ntstatus.h"
#define WIN32_NO_STATUS
57
#include "windef.h"
Alexandre Julliard's avatar
Alexandre Julliard committed
58
#include "winbase.h"
59
#include "wincon.h"
60
#include "winternl.h"
61 62
#include "wine/library.h"

63
#include "file.h"
64
#include "process.h"
65 66
#define WANT_REQUEST_HANDLERS
#include "request.h"
67 68 69 70 71 72

/* Some versions of glibc don't define this */
#ifndef SCM_RIGHTS
#define SCM_RIGHTS 1
#endif

73 74 75
/* path names for server master Unix socket */
static const char * const server_socket_name = "socket";   /* name of the socket file */
static const char * const server_lock_name = "lock";       /* name of the server lock file */
76 77 78

struct master_socket
{
79 80
    struct object        obj;        /* object header */
    struct fd           *fd;         /* file descriptor of the master socket */
81
    struct timeout_user *timeout;    /* timeout on last process exit */
82 83 84
};

static void master_socket_dump( struct object *obj, int verbose );
85
static void master_socket_destroy( struct object *obj );
86
static void master_socket_poll_event( struct fd *fd, int event );
87 88 89 90 91 92 93 94 95

static const struct object_ops master_socket_ops =
{
    sizeof(struct master_socket),  /* size */
    master_socket_dump,            /* dump */
    no_add_queue,                  /* add_queue */
    NULL,                          /* remove_queue */
    NULL,                          /* signaled */
    NULL,                          /* satisfied */
96
    no_signal,                     /* signal */
97
    no_get_fd,                     /* get_fd */
98
    no_map_access,                 /* map_access */
99 100
    default_get_sd,                /* get_sd */
    default_set_sd,                /* set_sd */
101
    no_lookup_name,                /* lookup_name */
102
    no_open_file,                  /* open_file */
103
    no_close_handle,               /* close_handle */
104
    master_socket_destroy          /* destroy */
105 106 107 108
};

static const struct fd_ops master_socket_fd_ops =
{
109 110
    NULL,                          /* get_poll_events */
    master_socket_poll_event,      /* poll_event */
111 112
    NULL,                          /* flush */
    NULL,                          /* get_fd_type */
113
    NULL,                          /* ioctl */
114
    NULL,                          /* queue_async */
115
    NULL,                          /* reselect_async */
116
    NULL                           /* cancel_async */
117 118 119
};


Alexandre Julliard's avatar
Alexandre Julliard committed
120
struct thread *current = NULL;  /* thread handling the current request */
121
unsigned int global_error = 0;  /* global error code for when no thread is current */
122
timeout_t server_start_time = 0;  /* server startup time */
Alexandre Julliard's avatar
Alexandre Julliard committed
123

124
static struct master_socket *master_socket;  /* the master socket object */
125
static int force_shutdown;
126 127 128

/* socket communication static structures */
static struct iovec myiovec;
129
static struct msghdr msghdr;
130
#ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
131 132
struct cmsg_fd
{
133 134 135 136 137 138 139
    struct
    {
        size_t len;   /* size of structure */
        int    level; /* SOL_SOCKET */
        int    type;  /* SCM_RIGHTS */
    } header;
    int fd;           /* fd to pass */
140
};
141
static struct cmsg_fd cmsg = { { sizeof(cmsg.header) + sizeof(cmsg.fd), SOL_SOCKET, SCM_RIGHTS }, -1 };
142
#endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
143

Alexandre Julliard's avatar
Alexandre Julliard committed
144
/* complain about a protocol error and terminate the client connection */
145
void fatal_protocol_error( struct thread *thread, const char *err, ... )
Alexandre Julliard's avatar
Alexandre Julliard committed
146
{
147
    va_list args;
Alexandre Julliard's avatar
Alexandre Julliard committed
148

149
    va_start( args, err );
150
    fprintf( stderr, "Protocol error:%04x: ", thread->id );
151 152
    vfprintf( stderr, err, args );
    va_end( args );
153 154
    thread->exit_code = 1;
    kill_thread( thread, 1 );
Alexandre Julliard's avatar
Alexandre Julliard committed
155 156
}

157 158 159 160 161 162
/* complain about a protocol error and terminate the client connection */
void fatal_protocol_perror( struct thread *thread, const char *err, ... )
{
    va_list args;

    va_start( args, err );
163
    fprintf( stderr, "Protocol error:%04x: ", thread->id );
164 165 166 167 168 169 170
    vfprintf( stderr, err, args );
    perror( " " );
    va_end( args );
    thread->exit_code = 1;
    kill_thread( thread, 1 );
}

171
/* die on a fatal error */
172
void fatal_error( const char *err, ... )
173 174 175 176 177 178 179 180 181 182 183
{
    va_list args;

    va_start( args, err );
    fprintf( stderr, "wineserver: " );
    vfprintf( stderr, err, args );
    va_end( args );
    exit(1);
}

/* die on a fatal error */
184
void fatal_perror( const char *err, ... )
185 186 187 188 189 190 191 192 193 194 195
{
    va_list args;

    va_start( args, err );
    fprintf( stderr, "wineserver: " );
    vfprintf( stderr, err, args );
    perror( " " );
    va_end( args );
    exit(1);
}

196
/* allocate the reply data */
197
void *set_reply_data_size( data_size_t size )
Alexandre Julliard's avatar
Alexandre Julliard committed
198
{
199 200 201 202 203
    assert( size <= get_reply_max_size() );
    if (size && !(current->reply_data = mem_alloc( size ))) size = 0;
    current->reply_size = size;
    return current->reply_data;
}
204

205 206 207 208
/* write the remaining part of the reply */
void write_reply( struct thread *thread )
{
    int ret;
209

210
    if ((ret = write( get_unix_fd( thread->reply_fd ),
211 212 213 214 215 216 217 218
                      (char *)thread->reply_data + thread->reply_size - thread->reply_towrite,
                      thread->reply_towrite )) >= 0)
    {
        if (!(thread->reply_towrite -= ret))
        {
            free( thread->reply_data );
            thread->reply_data = NULL;
            /* sent everything, can go back to waiting for requests */
219 220
            set_fd_events( thread->request_fd, POLLIN );
            set_fd_events( thread->reply_fd, 0 );
221 222 223 224 225 226 227 228
        }
        return;
    }
    if (errno == EPIPE)
        kill_thread( thread, 0 );  /* normal death */
    else if (errno != EWOULDBLOCK && errno != EAGAIN)
        fatal_protocol_perror( thread, "reply write" );
}
Alexandre Julliard's avatar
Alexandre Julliard committed
229

230 231 232 233 234 235 236
/* send a reply to the current thread */
static void send_reply( union generic_reply *reply )
{
    int ret;

    if (!current->reply_size)
    {
237 238
        if ((ret = write( get_unix_fd( current->reply_fd ),
                          reply, sizeof(*reply) )) != sizeof(*reply)) goto error;
239 240
    }
    else
241
    {
242 243
        struct iovec vec[2];

244
        vec[0].iov_base = (void *)reply;
245 246 247 248
        vec[0].iov_len  = sizeof(*reply);
        vec[1].iov_base = current->reply_data;
        vec[1].iov_len  = current->reply_size;

249
        if ((ret = writev( get_unix_fd( current->reply_fd ), vec, 2 )) < sizeof(*reply)) goto error;
250 251

        if ((current->reply_towrite = current->reply_size - (ret - sizeof(*reply))))
252
        {
253
            /* couldn't write it all, wait for POLLOUT */
254 255
            set_fd_events( current->reply_fd, POLLOUT );
            set_fd_events( current->request_fd, 0 );
256 257
            return;
        }
258
    }
259 260
    free( current->reply_data );
    current->reply_data = NULL;
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
    return;

 error:
    if (ret >= 0)
        fatal_protocol_error( current, "partial write %d\n", ret );
    else if (errno == EPIPE)
        kill_thread( current, 0 );  /* normal death */
    else
        fatal_protocol_perror( current, "reply write" );
}

/* call a request handler */
static void call_req_handler( struct thread *thread )
{
    union generic_reply reply;
    enum request req = thread->req.request_header.req;

    current = thread;
    current->reply_size = 0;
    clear_error();
    memset( &reply, 0, sizeof(reply) );

    if (debug_level) trace_request();
284 285

    if (req < REQ_NB_REQUESTS)
286
        req_handlers[req]( &current->req, &reply );
287 288 289 290 291 292
    else
        set_error( STATUS_NOT_IMPLEMENTED );

    if (current)
    {
        if (current->reply_fd)
293
        {
294 295 296 297
            reply.reply_header.error = current->error;
            reply.reply_header.reply_size = current->reply_size;
            if (debug_level) trace_reply( req, &reply );
            send_reply( &reply );
298
        }
299 300 301 302 303
        else
        {
            current->exit_code = 1;
            kill_thread( current, 1 );  /* no way to continue without reply fd */
        }
304
    }
305
    current = NULL;
Alexandre Julliard's avatar
Alexandre Julliard committed
306 307
}

308 309 310 311 312
/* read a request from a thread */
void read_request( struct thread *thread )
{
    int ret;

313
    if (!thread->req_toread)  /* no pending request */
314
    {
315
        if ((ret = read( get_unix_fd( thread->request_fd ), &thread->req,
316 317 318 319 320 321 322 323
                         sizeof(thread->req) )) != sizeof(thread->req)) goto error;
        if (!(thread->req_toread = thread->req.request_header.request_size))
        {
            /* no data, handle request at once */
            call_req_handler( thread );
            return;
        }
        if (!(thread->req_data = malloc( thread->req_toread )))
324 325 326 327 328
        {
            fatal_protocol_error( thread, "no memory for %u bytes request %d\n",
                                  thread->req_toread, thread->req.request_header.req );
            return;
        }
329
    }
330 331 332 333

    /* read the variable sized data */
    for (;;)
    {
334 335 336
        ret = read( get_unix_fd( thread->request_fd ),
                    (char *)thread->req_data + thread->req.request_header.request_size
                      - thread->req_toread,
337 338 339 340 341 342 343 344 345 346 347 348
                    thread->req_toread );
        if (ret <= 0) break;
        if (!(thread->req_toread -= ret))
        {
            call_req_handler( thread );
            free( thread->req_data );
            thread->req_data = NULL;
            return;
        }
    }

error:
349 350 351 352
    if (!ret)  /* closed pipe */
        kill_thread( thread, 0 );
    else if (ret > 0)
        fatal_protocol_error( thread, "partial read %d\n", ret );
353
    else if (errno != EWOULDBLOCK && errno != EAGAIN)
354 355 356
        fatal_protocol_perror( thread, "read" );
}

357 358
/* receive a file descriptor on the process socket */
int receive_fd( struct process *process )
359
{
360 361
    struct send_fd data;
    int fd, ret;
362

363
#ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
364
    msghdr.msg_accrightslen = sizeof(int);
365
    msghdr.msg_accrights = (void *)&fd;
366
#else  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
367
    msghdr.msg_control    = &cmsg;
368
    msghdr.msg_controllen = sizeof(cmsg.header) + sizeof(fd);
369
    cmsg.fd = -1;
370
#endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
371

372
    myiovec.iov_base = (void *)&data;
373
    myiovec.iov_len  = sizeof(data);
374

375
    ret = recvmsg( get_unix_fd( process->msg_fd ), &msghdr, 0 );
376
#ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
377
    fd = cmsg.fd;
378 379
#endif

380
    if (ret == sizeof(data))
381
    {
382 383 384
        struct thread *thread;

        if (data.tid) thread = get_thread_from_id( data.tid );
385
        else thread = (struct thread *)grab_object( get_process_first_thread( process ));
386

387
        if (!thread || thread->process != process || thread->state == TERMINATED)
388 389
        {
            if (debug_level)
390 391
                fprintf( stderr, "%04x: *fd* %d <- %d bad thread id\n",
                         data.tid, data.fd, fd );
392 393 394 395 396
            close( fd );
        }
        else
        {
            if (debug_level)
397 398
                fprintf( stderr, "%04x: *fd* %d <- %d\n",
                         thread->id, data.fd, fd );
399 400
            thread_add_inflight_fd( thread, data.fd, fd );
        }
401
        if (thread) release_object( thread );
402 403 404
        return 0;
    }

405 406
    if (!ret)
    {
407
        kill_process( process, 0 );
408 409
    }
    else if (ret > 0)
410
    {
411 412
        fprintf( stderr, "Protocol error: process %04x: partial recvmsg %d for fd\n",
                 process->id, ret );
413
        kill_process( process, 1 );
414
    }
415
    else
416 417 418
    {
        if (errno != EWOULDBLOCK && errno != EAGAIN)
        {
419
            fprintf( stderr, "Protocol error: process %04x: ", process->id );
420
            perror( "recvmsg" );
421
            kill_process( process, 1 );
422 423 424
        }
    }
    return -1;
425 426
}

427
/* send an fd to a client */
428
int send_client_fd( struct process *process, int fd, obj_handle_t handle )
429 430 431
{
    int ret;

432
    if (debug_level)
433 434
        fprintf( stderr, "%04x: *fd* %p -> %d\n",
                 current ? current->id : process->id, handle, fd );
435

436
#ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
437 438
    msghdr.msg_accrightslen = sizeof(fd);
    msghdr.msg_accrights = (void *)&fd;
439
#else  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
440
    msghdr.msg_control    = &cmsg;
441
    msghdr.msg_controllen = sizeof(cmsg.header) + sizeof(fd);
442
    cmsg.fd = fd;
443
#endif  /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
444

445 446
    myiovec.iov_base = (void *)&handle;
    myiovec.iov_len  = sizeof(handle);
447

448
    ret = sendmsg( get_unix_fd( process->msg_fd ), &msghdr, 0 );
449

450 451 452
    if (ret == sizeof(handle)) return 0;

    if (ret >= 0)
453
    {
454
        fprintf( stderr, "Protocol error: process %04x: partial sendmsg %d\n", process->id, ret );
455
        kill_process( process, 1 );
456
    }
457 458
    else if (errno == EPIPE)
    {
459
        kill_process( process, 0 );
460
    }
461 462
    else
    {
463
        fprintf( stderr, "Protocol error: process %04x: ", process->id );
464
        perror( "sendmsg" );
465
        kill_process( process, 1 );
466 467
    }
    return -1;
468 469
}

470 471 472
/* get current tick count to return to client */
unsigned int get_tick_count(void)
{
473
    return (current_time - server_start_time) / 10000;
474 475
}

476 477 478 479
static void master_socket_dump( struct object *obj, int verbose )
{
    struct master_socket *sock = (struct master_socket *)obj;
    assert( obj->ops == &master_socket_ops );
480 481 482 483 484 485 486 487
    fprintf( stderr, "Master socket fd=%p\n", sock->fd );
}

static void master_socket_destroy( struct object *obj )
{
    struct master_socket *sock = (struct master_socket *)obj;
    assert( obj->ops == &master_socket_ops );
    release_object( sock->fd );
488 489 490
}

/* handle a socket event */
491
static void master_socket_poll_event( struct fd *fd, int event )
492
{
493 494
    struct master_socket *sock = get_fd_user( fd );
    assert( master_socket->obj.ops == &master_socket_ops );
495 496 497 498 499 500 501

    assert( sock == master_socket );  /* there is only one master socket */

    if (event & (POLLERR | POLLHUP))
    {
        /* this is not supposed to happen */
        fprintf( stderr, "wineserver: Error on master socket\n" );
502
        set_fd_events( sock->fd, -1 );
503 504 505 506
    }
    else if (event & POLLIN)
    {
        struct sockaddr_un dummy;
507
        unsigned int len = sizeof(dummy);
508
        int client = accept( get_unix_fd( master_socket->fd ), (struct sockaddr *) &dummy, &len );
509
        if (client == -1) return;
510 511 512 513 514
        if (sock->timeout)
        {
            remove_timeout_user( sock->timeout );
            sock->timeout = NULL;
        }
515
        fcntl( client, F_SETFL, O_NONBLOCK );
516
        create_process( client, NULL, 0 );
517 518 519 520 521 522
    }
}

/* remove the socket upon exit */
static void socket_cleanup(void)
{
523
    static int do_it_once;
524
    if (!do_it_once++) unlink( server_socket_name );
525 526
}

527 528
/* create a directory and check its permissions */
static void create_dir( const char *name, struct stat *st )
529
{
530
    if (lstat( name, st ) == -1)
531
    {
532
        if (errno != ENOENT) fatal_perror( "lstat %s", name );
533
        if (mkdir( name, 0700 ) == -1 && errno != EEXIST) fatal_perror( "mkdir %s", name );
534
        if (lstat( name, st ) == -1) fatal_perror( "lstat %s", name );
535
    }
536 537 538
    if (!S_ISDIR(st->st_mode)) fatal_error( "%s is not a directory\n", name );
    if (st->st_uid != getuid()) fatal_error( "%s is not owned by you\n", name );
    if (st->st_mode & 077) fatal_error( "%s must not be accessible by other users\n", name );
539 540 541
}

/* create the server directory and chdir to it */
542
static void create_server_dir( const char *dir )
543
{
544 545
    char *p, *server_dir;
    struct stat st, st2;
546

547
    if (!(server_dir = strdup( dir ))) fatal_error( "out of memory\n" );
548

549
    /* first create the base directory if needed */
550

551 552 553
    p = strrchr( server_dir, '/' );
    *p = 0;
    create_dir( server_dir, &st );
554

555
    /* now create the server directory */
556

557 558 559 560 561 562 563 564 565
    *p = '/';
    create_dir( server_dir, &st );

    if (chdir( server_dir ) == -1) fatal_perror( "chdir %s", server_dir );
    if (stat( ".", &st2 ) == -1) fatal_perror( "stat %s", server_dir );
    if (st.st_dev != st2.st_dev || st.st_ino != st2.st_ino)
        fatal_error( "chdir did not end up in %s\n", server_dir );

    free( server_dir );
566 567
}

568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
/* create the lock file and return its file descriptor */
static int create_server_lock(void)
{
    struct stat st;
    int fd;

    if (lstat( server_lock_name, &st ) == -1)
    {
        if (errno != ENOENT)
            fatal_perror( "lstat %s/%s", wine_get_server_dir(), server_lock_name );
    }
    else
    {
        if (!S_ISREG(st.st_mode))
            fatal_error( "%s/%s is not a regular file\n", wine_get_server_dir(), server_lock_name );
    }

    if ((fd = open( server_lock_name, O_CREAT|O_TRUNC|O_WRONLY, 0600 )) == -1)
        fatal_perror( "error creating %s/%s", wine_get_server_dir(), server_lock_name );
    return fd;
}

590 591
/* wait for the server lock */
int wait_for_lock(void)
592
{
593
    const char *server_dir = wine_get_server_dir();
594 595 596
    int fd, r;
    struct flock fl;

597 598 599
    if (!server_dir) return 0;  /* no server dir, so no lock to wait on */

    create_server_dir( server_dir );
600
    fd = create_server_lock();
601 602 603 604 605 606 607 608 609 610 611

    fl.l_type   = F_WRLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start  = 0;
    fl.l_len    = 1;
    r = fcntl( fd, F_SETLKW, &fl );
    close(fd);

    return r;
}

612 613 614
/* kill the wine server holding the lock */
int kill_lock_owner( int sig )
{
615
    const char *server_dir = wine_get_server_dir();
616 617 618 619
    int fd, i, ret = 0;
    pid_t pid = 0;
    struct flock fl;

620 621 622
    if (!server_dir) return 0;  /* no server dir, nothing to do */

    create_server_dir( server_dir );
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
    fd = create_server_lock();

    for (i = 0; i < 10; i++)
    {
        fl.l_type   = F_WRLCK;
        fl.l_whence = SEEK_SET;
        fl.l_start  = 0;
        fl.l_len    = 1;
        if (fcntl( fd, F_GETLK, &fl ) == -1) goto done;
        if (fl.l_type != F_WRLCK) goto done;  /* the file is not locked */
        if (!pid)  /* first time around */
        {
            if (!(pid = fl.l_pid)) goto done;  /* shouldn't happen */
            if (sig == -1)
            {
                if (kill( pid, SIGINT ) == -1) goto done;
                kill( pid, SIGCONT );
                ret = 1;
            }
            else  /* just send the specified signal and return */
            {
                ret = (kill( pid, sig ) != -1);
                goto done;
            }
        }
        else if (fl.l_pid != pid) goto done;  /* no longer the same process */
        sleep( 1 );
    }
    /* waited long enough, now kill it */
    kill( pid, SIGKILL );

 done:
    close( fd );
    return ret;
}

659 660 661
/* acquire the main server lock */
static void acquire_lock(void)
{
662
    struct sockaddr_un addr;
663 664 665
    struct stat st;
    struct flock fl;
    int fd, slen, got_lock = 0;
666

667
    fd = create_server_lock();
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682

    fl.l_type   = F_WRLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start  = 0;
    fl.l_len    = 1;
    if (fcntl( fd, F_SETLK, &fl ) != -1)
    {
        /* check for crashed server */
        if (stat( server_socket_name, &st ) != -1 &&   /* there is a leftover socket */
            stat( "core", &st ) != -1 && st.st_size)   /* and there is a non-empty core file */
        {
            fprintf( stderr,
                     "Warning: a previous instance of the wine server seems to have crashed.\n"
                     "Please run 'gdb %s %s/core',\n"
                     "type 'backtrace' at the gdb prompt and report the results. Thanks.\n\n",
683
                     server_argv0, wine_get_server_dir() );
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
        }
        unlink( server_socket_name ); /* we got the lock, we can safely remove the socket */
        got_lock = 1;
        /* in that case we reuse fd without closing it, this ensures
         * that we hold the lock until the process exits */
    }
    else
    {
        switch(errno)
        {
        case ENOLCK:
            break;
        case EACCES:
            /* check whether locks work at all on this file system */
            if (fcntl( fd, F_GETLK, &fl ) == -1) break;
            /* fall through */
        case EAGAIN:
            exit(2); /* we didn't get the lock, exit with special status */
        default:
703
            fatal_perror( "fcntl %s/%s", wine_get_server_dir(), server_lock_name );
704 705 706 707
        }
        /* it seems we can't use locks on this fs, so we will use the socket existence as lock */
        close( fd );
    }
708

709 710
    if ((fd = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
    addr.sun_family = AF_UNIX;
711
    strcpy( addr.sun_path, server_socket_name );
712
    slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
713
#ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
714 715 716
    addr.sun_len = slen;
#endif
    if (bind( fd, (struct sockaddr *)&addr, slen ) == -1)
717 718
    {
        if ((errno == EEXIST) || (errno == EADDRINUSE))
719 720 721 722 723 724
        {
            if (got_lock)
                fatal_error( "couldn't bind to the socket even though we hold the lock\n" );
            exit(2); /* we didn't get the lock, exit with special status */
        }
        fatal_perror( "bind" );
725 726
    }
    atexit( socket_cleanup );
727
    chmod( server_socket_name, 0600 );  /* make sure no other user can connect */
728 729
    if (listen( fd, 5 ) == -1) fatal_perror( "listen" );

730
    if (!(master_socket = alloc_object( &master_socket_ops )) ||
731
        !(master_socket->fd = create_anonymous_fd( &master_socket_fd_ops, fd, &master_socket->obj, 0 )))
732
        fatal_error( "out of memory\n" );
733
    master_socket->timeout = NULL;
734
    set_fd_events( master_socket->fd, POLLIN );
735
    make_object_static( &master_socket->obj );
736 737 738 739 740
}

/* open the master server socket and start waiting for new clients */
void open_master_socket(void)
{
741
    const char *server_dir = wine_get_server_dir();
742
    int fd, pid, status, sync_pipe[2];
743 744 745 746 747 748
    char dummy;

    /* make sure no request is larger than the maximum size */
    assert( sizeof(union generic_request) == sizeof(struct request_max_size) );
    assert( sizeof(union generic_reply) == sizeof(struct request_max_size) );

749 750
    if (!server_dir) fatal_error( "directory %s cannot be accessed\n", wine_get_config_dir() );
    create_server_dir( server_dir );
751

752
    if (!foreground)
753
    {
754 755 756 757 758 759 760
        if (pipe( sync_pipe ) == -1) fatal_perror( "pipe" );
        pid = fork();
        switch( pid )
        {
        case 0:  /* child */
            setsid();
            close( sync_pipe[0] );
761

762
            acquire_lock();
763

764 765 766 767 768 769 770
            /* close stdin and stdout */
            if ((fd = open( "/dev/null", O_RDWR )) != -1)
            {
                dup2( fd, 0 );
                dup2( fd, 1 );
                close( fd );
            }
771

772
            /* signal parent */
773
            dummy = 0;
774 775 776
            write( sync_pipe[1], &dummy, 1 );
            close( sync_pipe[1] );
            break;
777

778 779 780
        case -1:
            fatal_perror( "fork" );
            break;
781

782 783
        default:  /* parent */
            close( sync_pipe[1] );
784

785 786 787 788 789 790 791 792 793 794 795 796
            /* wait for child to signal us and then exit */
            if (read( sync_pipe[0], &dummy, 1 ) == 1) _exit(0);

            /* child terminated, propagate exit status */
            wait4( pid, &status, 0, NULL );
            if (WIFEXITED(status)) _exit( WEXITSTATUS(status) );
            _exit(1);
        }
    }
    else  /* remain in the foreground */
    {
        acquire_lock();
797
    }
798

799 800 801 802 803 804
    /* setup msghdr structure constant fields */
    msghdr.msg_name    = NULL;
    msghdr.msg_namelen = 0;
    msghdr.msg_iov     = &myiovec;
    msghdr.msg_iovlen  = 1;

805 806
    /* init the process tracing mechanism */
    init_tracing_mechanism();
807 808
}

809 810
/* master socket timer expiration handler */
static void close_socket_timeout( void *arg )
811
{
812 813 814
    master_socket->timeout = NULL;
    flush_registry();

815
    /* if a new client is waiting, we keep on running */
816
    if (!force_shutdown && check_fd_events( master_socket->fd, POLLIN )) return;
817 818 819 820

    if (debug_level) fprintf( stderr, "wineserver: exiting (pid=%ld)\n", (long) getpid() );

#ifdef DEBUG_OBJECTS
821
    close_objects();  /* shut down everything properly */
822
#endif
823
    exit( force_shutdown );
824 825
}

826 827 828
/* close the master socket and stop waiting for new clients */
void close_master_socket(void)
{
829
    if (master_socket_timeout == TIMEOUT_INFINITE) return;  /* just keep running forever */
830 831

    if (master_socket_timeout)
832 833 834
        master_socket->timeout = add_timeout_user( master_socket_timeout, close_socket_timeout, NULL );
    else
        close_socket_timeout( NULL );  /* close it right away */
835 836
}

837 838
/* forced shutdown, used for wineserver -k */
void shutdown_master_socket(void)
839
{
840 841 842 843 844 845 846 847
    force_shutdown = 1;
    master_socket_timeout = 0;
    if (master_socket->timeout)
    {
        remove_timeout_user( master_socket->timeout );
        close_socket_timeout( NULL );
    }
    set_fd_events( master_socket->fd, -1 ); /* stop waiting for new clients */
848
}