2 * Server-side request handling
4 * Copyright (C) 1998 Alexandre Julliard
20 #include <sys/types.h>
21 #ifdef HAVE_SYS_SOCKET_H
22 # include <sys/socket.h>
34 #define WANT_REQUEST_HANDLERS
36 #include "wine/port.h"
38 /* Some versions of glibc don't define this */
43 /* path names for server master Unix socket */
44 #define CONFDIR "/.wine" /* directory for Wine config relative to $HOME */
45 #define SERVERDIR "/wineserver-" /* server socket directory (hostname appended) */
46 #define SOCKETNAME "socket" /* name of the socket file */
50 struct object obj
; /* object header */
53 static void master_socket_dump( struct object
*obj
, int verbose
);
54 static void master_socket_poll_event( struct object
*obj
, int event
);
55 static void master_socket_destroy( struct object
*obj
);
57 static const struct object_ops master_socket_ops
=
59 sizeof(struct master_socket
), /* size */
60 master_socket_dump
, /* dump */
61 no_add_queue
, /* add_queue */
62 NULL
, /* remove_queue */
65 NULL
, /* get_poll_events */
66 master_socket_poll_event
, /* poll_event */
67 no_get_fd
, /* get_fd */
69 no_get_file_info
, /* get_file_info */
70 master_socket_destroy
/* destroy */
74 struct thread
*current
= NULL
; /* thread handling the current request */
75 unsigned int global_error
= 0; /* global error code for when no thread is current */
77 static struct master_socket
*master_socket
; /* the master socket object */
79 /* socket communication static structures */
80 static struct iovec myiovec
;
81 static struct msghdr msghdr
;
82 #ifndef HAVE_MSGHDR_ACCRIGHTS
85 int len
; /* sizeof structure */
86 int level
; /* SOL_SOCKET */
87 int type
; /* SCM_RIGHTS */
88 int fd
; /* fd to pass */
90 static struct cmsg_fd cmsg
= { sizeof(cmsg
), SOL_SOCKET
, SCM_RIGHTS
, -1 };
91 #endif /* HAVE_MSGHDR_ACCRIGHTS */
93 /* complain about a protocol error and terminate the client connection */
94 void fatal_protocol_error( struct thread
*thread
, const char *err
, ... )
98 va_start( args
, err
);
99 fprintf( stderr
, "Protocol error:%p: ", thread
);
100 vfprintf( stderr
, err
, args
);
102 thread
->exit_code
= 1;
103 kill_thread( thread
, 1 );
106 /* complain about a protocol error and terminate the client connection */
107 void fatal_protocol_perror( struct thread
*thread
, const char *err
, ... )
111 va_start( args
, err
);
112 fprintf( stderr
, "Protocol error:%p: ", thread
);
113 vfprintf( stderr
, err
, args
);
116 thread
->exit_code
= 1;
117 kill_thread( thread
, 1 );
120 /* die on a fatal error */
121 void fatal_error( const char *err
, ... )
125 va_start( args
, err
);
126 fprintf( stderr
, "wineserver: " );
127 vfprintf( stderr
, err
, args
);
132 /* die on a fatal error */
133 void fatal_perror( const char *err
, ... )
137 va_start( args
, err
);
138 fprintf( stderr
, "wineserver: " );
139 vfprintf( stderr
, err
, args
);
145 /* call a request handler */
146 static inline void call_req_handler( struct thread
*thread
, union generic_request
*request
)
148 enum request req
= request
->header
.req
;
153 if (debug_level
) trace_request( thread
, request
);
155 if (request
->header
.var_size
)
157 if ((unsigned int)request
->header
.var_offset
+
158 request
->header
.var_size
> MAX_REQUEST_LENGTH
)
160 fatal_protocol_error( current
, "bad request offset/size %d/%d\n",
161 request
->header
.var_offset
, request
->header
.var_size
);
166 if (req
< REQ_NB_REQUESTS
)
168 req_handlers
[req
]( request
);
169 if (current
) send_reply( current
, request
);
173 fatal_protocol_error( current
, "bad request %d\n", req
);
176 /* read a request from a thread */
177 void read_request( struct thread
*thread
)
179 union generic_request req
;
182 if ((ret
= read( thread
->obj
.fd
, &req
, sizeof(req
) )) == sizeof(req
))
184 call_req_handler( thread
, &req
);
187 if (!ret
) /* closed pipe */
188 kill_thread( thread
, 0 );
190 fatal_protocol_error( thread
, "partial read %d\n", ret
);
192 fatal_protocol_perror( thread
, "read" );
195 /* send a reply to a thread */
196 void send_reply( struct thread
*thread
, union generic_request
*request
)
200 if (debug_level
) trace_reply( thread
, request
);
202 request
->header
.error
= thread
->error
;
204 if ((ret
= write( thread
->reply_fd
, request
, sizeof(*request
) )) != sizeof(*request
))
207 fatal_protocol_error( thread
, "partial write %d\n", ret
);
208 else if (errno
== EPIPE
)
209 kill_thread( thread
, 0 ); /* normal death */
211 fatal_protocol_perror( thread
, "reply write" );
215 /* receive a file descriptor on the process socket */
216 int receive_fd( struct process
*process
)
221 #ifdef HAVE_MSGHDR_ACCRIGHTS
222 msghdr
.msg_accrightslen
= sizeof(int);
223 msghdr
.msg_accrights
= (void *)&fd
;
224 #else /* HAVE_MSGHDR_ACCRIGHTS */
225 msghdr
.msg_control
= &cmsg
;
226 msghdr
.msg_controllen
= sizeof(cmsg
);
228 #endif /* HAVE_MSGHDR_ACCRIGHTS */
230 myiovec
.iov_base
= &data
;
231 myiovec
.iov_len
= sizeof(data
);
233 ret
= recvmsg( process
->obj
.fd
, &msghdr
, 0 );
234 #ifndef HAVE_MSGHDR_ACCRIGHTS
238 if (ret
== sizeof(data
))
240 struct thread
*thread
;
242 if (data
.tid
) thread
= get_thread_from_id( data
.tid
);
243 else thread
= (struct thread
*)grab_object( process
->thread_list
);
245 if (!thread
|| thread
->process
!= process
)
248 fprintf( stderr
, "%08x: *fd* %d <- %d bad thread id\n",
249 (unsigned int)data
.tid
, data
.fd
, fd
);
255 fprintf( stderr
, "%08x: *fd* %d <- %d\n",
256 (unsigned int)thread
, data
.fd
, fd
);
257 thread_add_inflight_fd( thread
, data
.fd
, fd
);
259 if (thread
) release_object( thread
);
265 fprintf( stderr
, "Protocol error: process %p: partial recvmsg %d for fd\n", process
, ret
);
266 kill_process( process
, NULL
, 1 );
270 if (errno
!= EWOULDBLOCK
&& errno
!= EAGAIN
)
272 fprintf( stderr
, "Protocol error: process %p: ", process
);
274 kill_process( process
, NULL
, 1 );
280 /* send an fd to a client */
281 int send_client_fd( struct process
*process
, int fd
, handle_t handle
)
286 fprintf( stderr
, "%08x: *fd* %d -> %d\n", (unsigned int)current
, handle
, fd
);
288 #ifdef HAVE_MSGHDR_ACCRIGHTS
289 msghdr
.msg_accrightslen
= sizeof(fd
);
290 msghdr
.msg_accrights
= (void *)&fd
;
291 #else /* HAVE_MSGHDR_ACCRIGHTS */
292 msghdr
.msg_control
= &cmsg
;
293 msghdr
.msg_controllen
= sizeof(cmsg
);
295 #endif /* HAVE_MSGHDR_ACCRIGHTS */
297 myiovec
.iov_base
= (void *)&handle
;
298 myiovec
.iov_len
= sizeof(handle
);
300 ret
= sendmsg( process
->obj
.fd
, &msghdr
, 0 );
302 if (ret
== sizeof(handle
)) return 0;
306 fprintf( stderr
, "Protocol error: process %p: partial sendmsg %d\n", process
, ret
);
307 kill_process( process
, NULL
, 1 );
311 fprintf( stderr
, "Protocol error: process %p: ", process
);
313 kill_process( process
, NULL
, 1 );
318 static void master_socket_dump( struct object
*obj
, int verbose
)
320 struct master_socket
*sock
= (struct master_socket
*)obj
;
321 assert( obj
->ops
== &master_socket_ops
);
322 fprintf( stderr
, "Master socket fd=%d\n", sock
->obj
.fd
);
325 /* handle a socket event */
326 static void master_socket_poll_event( struct object
*obj
, int event
)
328 struct master_socket
*sock
= (struct master_socket
*)obj
;
329 assert( obj
->ops
== &master_socket_ops
);
331 assert( sock
== master_socket
); /* there is only one master socket */
333 if (event
& (POLLERR
| POLLHUP
))
335 /* this is not supposed to happen */
336 fprintf( stderr
, "wineserver: Error on master socket\n" );
337 release_object( obj
);
339 else if (event
& POLLIN
)
341 struct sockaddr_un dummy
;
342 int len
= sizeof(dummy
);
343 int client
= accept( master_socket
->obj
.fd
, (struct sockaddr
*) &dummy
, &len
);
344 if (client
!= -1) create_process( client
);
348 /* remove the socket upon exit */
349 static void socket_cleanup(void)
351 static int do_it_once
;
352 if (!do_it_once
++) unlink( SOCKETNAME
);
355 static void master_socket_destroy( struct object
*obj
)
360 /* return the configuration directory ($WINEPREFIX or $HOME/.wine) */
361 const char *get_config_dir(void)
363 static char *confdir
;
366 const char *prefix
= getenv( "WINEPREFIX" );
369 int len
= strlen(prefix
);
370 if (!(confdir
= strdup( prefix
))) fatal_error( "out of memory\n" );
371 if (len
> 1 && confdir
[len
-1] == '/') confdir
[len
-1] = 0;
375 const char *home
= getenv( "HOME" );
378 struct passwd
*pwd
= getpwuid( getuid() );
379 if (!pwd
) fatal_error( "could not find your home directory\n" );
382 if (!(confdir
= malloc( strlen(home
) + strlen(CONFDIR
) + 1 )))
383 fatal_error( "out of memory\n" );
384 strcpy( confdir
, home
);
385 strcat( confdir
, CONFDIR
);
387 mkdir( confdir
, 0755 ); /* just in case */
392 /* create the server directory and chdir to it */
393 static void create_server_dir(void)
397 const char *confdir
= get_config_dir();
400 if (gethostname( hostname
, sizeof(hostname
) ) == -1) fatal_perror( "gethostname" );
402 if (!(serverdir
= malloc( strlen(confdir
) + strlen(SERVERDIR
) + strlen(hostname
) + 1 )))
403 fatal_error( "out of memory\n" );
405 strcpy( serverdir
, confdir
);
406 strcat( serverdir
, SERVERDIR
);
407 strcat( serverdir
, hostname
);
409 if (chdir( serverdir
) == -1)
411 if (errno
!= ENOENT
) fatal_perror( "chdir %s", serverdir
);
412 if (mkdir( serverdir
, 0700 ) == -1) fatal_perror( "mkdir %s", serverdir
);
413 if (chdir( serverdir
) == -1) fatal_perror( "chdir %s", serverdir
);
415 if (stat( ".", &st
) == -1) fatal_perror( "stat %s", serverdir
);
416 if (!S_ISDIR(st
.st_mode
)) fatal_error( "%s is not a directory\n", serverdir
);
417 if (st
.st_uid
!= getuid()) fatal_error( "%s is not owned by you\n", serverdir
);
418 if (st
.st_mode
& 077) fatal_error( "%s must not be accessible by other users\n", serverdir
);
421 /* open the master server socket and start waiting for new clients */
422 void open_master_socket(void)
424 struct sockaddr_un addr
;
427 /* make sure no request is larger than the maximum size */
428 assert( sizeof(union generic_request
) == sizeof(struct request_max_size
) );
431 if ((fd
= socket( AF_UNIX
, SOCK_STREAM
, 0 )) == -1) fatal_perror( "socket" );
432 addr
.sun_family
= AF_UNIX
;
433 strcpy( addr
.sun_path
, SOCKETNAME
);
434 slen
= sizeof(addr
) - sizeof(addr
.sun_path
) + strlen(addr
.sun_path
) + 1;
435 #ifdef HAVE_SOCKADDR_SUN_LEN
438 if (bind( fd
, (struct sockaddr
*)&addr
, slen
) == -1)
440 if ((errno
== EEXIST
) || (errno
== EADDRINUSE
))
441 exit(0); /* pretend we succeeded to start */
443 fatal_perror( "bind" );
445 atexit( socket_cleanup
);
447 chmod( SOCKETNAME
, 0600 ); /* make sure no other user can connect */
448 if (listen( fd
, 5 ) == -1) fatal_perror( "listen" );
450 if (!(master_socket
= alloc_object( &master_socket_ops
, fd
)))
451 fatal_error( "out of memory\n" );
452 set_select_events( &master_socket
->obj
, POLLIN
);
454 /* setup msghdr structure constant fields */
455 msghdr
.msg_name
= NULL
;
456 msghdr
.msg_namelen
= 0;
457 msghdr
.msg_iov
= &myiovec
;
458 msghdr
.msg_iovlen
= 1;
460 /* go in the background */
464 fatal_perror( "fork" );
469 _exit(0); /* do not call atexit functions */
473 /* close the master socket and stop waiting for new clients */
474 void close_master_socket(void)
476 /* if a new client is waiting, we keep on running */
477 if (!check_select_events( master_socket
->obj
.fd
, POLLIN
))
478 release_object( master_socket
);
481 /* lock/unlock the master socket to stop accepting new clients */
482 void lock_master_socket( int locked
)
484 set_select_events( &master_socket
->obj
, locked
? 0 : POLLIN
);