/* create a signal handler */
static struct handler *create_handler( signal_callback callback )
{
struct handler *handler;
int fd[2];
if (pipe( fd ) == -1) return NULL;
if (!(handler = alloc_object( &handler_ops )))
{
close( fd[0] );
close( fd[1] );
return NULL;
}
handler->pipe_write = fd[1];
handler->pending = 0;
handler->callback = callback;
if (!(handler->fd = create_anonymous_fd( &handler_fd_ops, fd[0], &handler->obj, 0 )))
{
release_object( handler );
return NULL;
}
set_fd_events( handler->fd, POLLIN );
make_object_static( &handler->obj );
return handler;
}
/* if the function fails the fd is closed */
struct file *create_file_for_fd( int fd, unsigned int access, unsigned int sharing )
{
struct file *file;
struct stat st;
if (fstat( fd, &st ) == -1)
{
file_set_error();
close( fd );
return NULL;
}
if (!(file = alloc_object( &file_ops )))
{
close( fd );
return NULL;
}
file->mode = st.st_mode;
file->access = default_fd_map_access( &file->obj, access );
if (!(file->fd = create_anonymous_fd( &file_fd_ops, fd, &file->obj,
FILE_SYNCHRONOUS_IO_NONALERT )))
{
release_object( file );
return NULL;
}
allow_fd_caching( file->fd );
return file;
}
/* accept a socket (creates a new fd) */
static struct sock *accept_socket( obj_handle_t handle )
{
struct sock *acceptsock;
struct sock *sock;
int acceptfd;
sock = (struct sock *)get_handle_obj( current->process, handle, FILE_READ_DATA, &sock_ops );
if (!sock)
return NULL;
if ( sock->deferred )
{
acceptsock = sock->deferred;
sock->deferred = NULL;
}
else
{
if ((acceptfd = accept_new_fd( sock )) == -1)
{
release_object( sock );
return NULL;
}
if (!(acceptsock = alloc_object( &sock_ops )))
{
close( acceptfd );
release_object( sock );
return NULL;
}
init_sock( acceptsock );
/* newly created socket gets the same properties of the listening socket */
acceptsock->state = FD_WINE_CONNECTED|FD_READ|FD_WRITE;
if (sock->state & FD_WINE_NONBLOCKING)
acceptsock->state |= FD_WINE_NONBLOCKING;
acceptsock->mask = sock->mask;
acceptsock->proto = sock->proto;
acceptsock->type = sock->type;
acceptsock->family = sock->family;
acceptsock->window = sock->window;
acceptsock->message = sock->message;
if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
acceptsock->flags = sock->flags;
if (!(acceptsock->fd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
get_fd_options( sock->fd ) )))
{
release_object( acceptsock );
release_object( sock );
return NULL;
}
}
clear_error();
sock->pmask &= ~FD_ACCEPT;
sock->hmask &= ~FD_ACCEPT;
sock_reselect( sock );
release_object( sock );
return acceptsock;
}
/* if the function fails the fd is closed */
static struct file *create_file_for_fd( int fd, unsigned int access, unsigned int sharing )
{
struct file *file;
if ((file = alloc_object( &file_ops )))
{
file->access = file_map_access( &file->obj, access );
file->options = FILE_SYNCHRONOUS_IO_NONALERT;
if (!(file->fd = create_anonymous_fd( &file_fd_ops, fd, &file->obj )))
{
release_object( file );
return NULL;
}
}
return file;
}
/* create a new and unconnected socket */
static struct object *create_socket( int family, int type, int protocol, unsigned int flags )
{
struct sock *sock;
int sockfd;
sockfd = socket( family, type, protocol );
if (debug_level)
fprintf(stderr,"socket(%d,%d,%d)=%d\n",family,type,protocol,sockfd);
if (sockfd == -1)
{
sock_set_error();
return NULL;
}
fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
if (!(sock = alloc_object( &sock_ops )))
{
close( sockfd );
return NULL;
}
sock->state = (type != SOCK_STREAM) ? (FD_READ|FD_WRITE) : 0;
sock->mask = 0;
sock->hmask = 0;
sock->pmask = 0;
sock->polling = 0;
sock->flags = flags;
sock->type = type;
sock->family = family;
sock->event = NULL;
sock->window = 0;
sock->message = 0;
sock->wparam = 0;
sock->deferred = NULL;
sock->read_q = NULL;
sock->write_q = NULL;
memset( sock->errors, 0, sizeof(sock->errors) );
if (!(sock->fd = create_anonymous_fd( &sock_fd_ops, sockfd, &sock->obj,
(flags & WSA_FLAG_OVERLAPPED) ? 0 : FILE_SYNCHRONOUS_IO_NONALERT )))
{
release_object( sock );
return NULL;
}
sock_reselect( sock );
clear_error();
return &sock->obj;
}
static int accept_into_socket( struct sock *sock, struct sock *acceptsock )
{
int acceptfd;
struct fd *newfd;
if ( sock->deferred )
{
newfd = dup_fd_object( sock->deferred->fd, 0, 0,
get_fd_options( acceptsock->fd ) );
if ( !newfd )
return FALSE;
set_fd_user( newfd, &sock_fd_ops, &acceptsock->obj );
release_object( sock->deferred );
sock->deferred = NULL;
}
else
{
if ((acceptfd = accept_new_fd( sock )) == -1)
return FALSE;
if (!(newfd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
get_fd_options( acceptsock->fd ) )))
return FALSE;
}
acceptsock->state |= FD_WINE_CONNECTED|FD_READ|FD_WRITE;
acceptsock->hmask = 0;
acceptsock->pmask = 0;
acceptsock->polling = 0;
acceptsock->type = sock->type;
acceptsock->family = sock->family;
acceptsock->wparam = 0;
acceptsock->deferred = NULL;
release_object( acceptsock->fd );
acceptsock->fd = newfd;
clear_error();
sock->pmask &= ~FD_ACCEPT;
sock->hmask &= ~FD_ACCEPT;
sock_reselect( sock );
return TRUE;
}
/* acquire the main server lock */
static void acquire_lock(void)
{
struct sockaddr_un addr;
struct stat st;
struct flock fl;
int fd, slen, got_lock = 0;
fd = create_server_lock();
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",
server_argv0, wine_get_server_dir() );
}
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:
fatal_perror( "fcntl %s/%s", wine_get_server_dir(), server_lock_name );
}
/* it seems we can't use locks on this fs, so we will use the socket existence as lock */
close( fd );
}
if ((fd = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
addr.sun_family = AF_UNIX;
strcpy( addr.sun_path, server_socket_name );
slen = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path) + 1;
#ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
addr.sun_len = slen;
#endif
if (bind( fd, (struct sockaddr *)&addr, slen ) == -1)
{
if ((errno == EEXIST) || (errno == EADDRINUSE))
{
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" );
}
atexit( socket_cleanup );
chmod( server_socket_name, 0600 ); /* make sure no other user can connect */
if (listen( fd, 5 ) == -1) fatal_perror( "listen" );
if (!(master_socket = alloc_object( &master_socket_ops )) ||
!(master_socket->fd = create_anonymous_fd( &master_socket_fd_ops, fd, &master_socket->obj, 0 )))
fatal_error( "out of memory\n" );
set_fd_events( master_socket->fd, POLLIN );
make_object_static( &master_socket->obj );
}
static struct object *create_mapping( struct object *root, const struct unicode_str *name,
unsigned int attr, mem_size_t size, unsigned int flags,
obj_handle_t handle, unsigned int file_access,
const struct security_descriptor *sd )
{
struct mapping *mapping;
struct file *file;
struct fd *fd;
int unix_fd;
struct stat st;
if (!page_mask) page_mask = sysconf( _SC_PAGESIZE ) - 1;
if (!(mapping = create_named_object( root, &mapping_ops, name, attr, sd )))
return NULL;
if (get_error() == STATUS_OBJECT_NAME_EXISTS)
return &mapping->obj; /* Nothing else to do */
mapping->size = size;
mapping->fd = NULL;
mapping->shared = NULL;
mapping->committed = NULL;
if (!(mapping->flags = get_mapping_flags( handle, flags ))) goto error;
if (handle)
{
const unsigned int sharing = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
unsigned int mapping_access = FILE_MAPPING_ACCESS;
if (!(file = get_file_obj( current->process, handle, file_access ))) goto error;
fd = get_obj_fd( (struct object *)file );
/* file sharing rules for mappings are different so we use magic the access rights */
if (flags & SEC_IMAGE) mapping_access |= FILE_MAPPING_IMAGE;
else if (file_access & FILE_WRITE_DATA) mapping_access |= FILE_MAPPING_WRITE;
if (!(mapping->fd = get_fd_object_for_mapping( fd, mapping_access, sharing )))
{
mapping->fd = dup_fd_object( fd, mapping_access, sharing, FILE_SYNCHRONOUS_IO_NONALERT );
if (mapping->fd) set_fd_user( mapping->fd, &mapping_fd_ops, NULL );
}
release_object( file );
release_object( fd );
if (!mapping->fd) goto error;
if ((unix_fd = get_unix_fd( mapping->fd )) == -1) goto error;
if (fstat( unix_fd, &st ) == -1)
{
file_set_error();
goto error;
}
if (flags & SEC_IMAGE)
{
unsigned int err = get_image_params( mapping, st.st_size, unix_fd );
if (!err) return &mapping->obj;
set_error( err );
goto error;
}
if (!mapping->size)
{
if (!(mapping->size = st.st_size))
{
set_error( STATUS_MAPPED_FILE_SIZE_ZERO );
goto error;
}
}
else if (st.st_size < mapping->size)
{
if (!(file_access & FILE_WRITE_DATA))
{
set_error( STATUS_SECTION_TOO_BIG );
goto error;
}
if (!grow_file( unix_fd, mapping->size )) goto error;
}
}
else /* Anonymous mapping (no associated file) */
{
if (!mapping->size)
{
set_error( STATUS_INVALID_PARAMETER );
goto error;
}
if ((flags & SEC_RESERVE) && !(mapping->committed = create_ranges())) goto error;
mapping->size = (mapping->size + page_mask) & ~((mem_size_t)page_mask);
if ((unix_fd = create_temp_file( mapping->size )) == -1) goto error;
if (!(mapping->fd = create_anonymous_fd( &mapping_fd_ops, unix_fd, &mapping->obj,
FILE_SYNCHRONOUS_IO_NONALERT ))) goto error;
allow_fd_caching( mapping->fd );
}
return &mapping->obj;
error:
release_object( mapping );
return NULL;
}
/* accept a socket (creates a new fd) */
static struct sock *accept_socket( obj_handle_t handle )
{
struct sock *acceptsock;
struct sock *sock;
int acceptfd;
struct sockaddr saddr;
sock = (struct sock *)get_handle_obj( current->process, handle, FILE_READ_DATA, &sock_ops );
if (!sock)
return NULL;
if ( sock->deferred )
{
acceptsock = sock->deferred;
sock->deferred = NULL;
}
else
{
/* Try to accept(2). We can't be safe that this an already connected socket
* or that accept() is allowed on it. In those cases we will get -1/errno
* return.
*/
unsigned int slen = sizeof(saddr);
acceptfd = accept( get_unix_fd(sock->fd), &saddr, &slen);
if (acceptfd==-1)
{
sock_set_error();
release_object( sock );
return NULL;
}
if (!(acceptsock = alloc_object( &sock_ops )))
{
close( acceptfd );
release_object( sock );
return NULL;
}
/* newly created socket gets the same properties of the listening socket */
fcntl(acceptfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
acceptsock->state = FD_WINE_CONNECTED|FD_READ|FD_WRITE;
if (sock->state & FD_WINE_NONBLOCKING)
acceptsock->state |= FD_WINE_NONBLOCKING;
acceptsock->mask = sock->mask;
acceptsock->hmask = 0;
acceptsock->pmask = 0;
acceptsock->polling = 0;
acceptsock->type = sock->type;
acceptsock->family = sock->family;
acceptsock->event = NULL;
acceptsock->window = sock->window;
acceptsock->message = sock->message;
acceptsock->wparam = 0;
if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
acceptsock->flags = sock->flags;
acceptsock->deferred = NULL;
acceptsock->read_q = NULL;
acceptsock->write_q = NULL;
memset( acceptsock->errors, 0, sizeof(acceptsock->errors) );
if (!(acceptsock->fd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
get_fd_options( sock->fd ) )))
{
release_object( acceptsock );
release_object( sock );
return NULL;
}
}
clear_error();
sock->pmask &= ~FD_ACCEPT;
sock->hmask &= ~FD_ACCEPT;
sock_reselect( sock );
release_object( sock );
return acceptsock;
}