server/sock.c

   1 /*
   2  * Server-side socket management
   3  *
   4  * Copyright (C) 1999 Marcus Meissner, Ove Kåven
   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  * FIXME: we use read|write access in all cases. Shouldn't we depend that
  21  * on the access of the current handle?
  22  */
  23
  24 #include "config.h"
  25
  26 #include <assert.h>
  27 #include <fcntl.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <errno.h>
  33 #ifdef HAVE_POLL_H
  34 # include <poll.h>
  35 #endif
  36 #include <sys/time.h>
  37 #include <sys/types.h>
  38 #ifdef HAVE_SYS_SOCKET_H
  39 # include <sys/socket.h>
  40 #endif
  41 #ifdef HAVE_SYS_IOCTL_H
  42 #include <sys/ioctl.h>
  43 #endif
  44 #ifdef HAVE_SYS_FILIO_H
  45 # include <sys/filio.h>
  46 #endif
  47 #include <time.h>
  48 #include <unistd.h>
  49 #include <limits.h>
  50 #ifdef HAVE_LINUX_RTNETLINK_H
  51 # include <linux/rtnetlink.h>
  52 #endif
  53
  54 #include "ntstatus.h"
  55 #define WIN32_NO_STATUS
  56 #include "windef.h"
  57 #include "winternl.h"
  58 #include "winerror.h"
  59 #define USE_WS_PREFIX
  60 #include "winsock2.h"
  61 #include "wine/afd.h"
  62
  63 #include "process.h"
  64 #include "file.h"
  65 #include "handle.h"
  66 #include "thread.h"
  67 #include "request.h"
  68 #include "user.h"
  69
  70 /* From winsock.h */
  71 #define FD_MAX_EVENTS              10
  72 #define FD_READ_BIT                0
  73 #define FD_WRITE_BIT               1
  74 #define FD_OOB_BIT                 2
  75 #define FD_ACCEPT_BIT              3
  76 #define FD_CONNECT_BIT             4
  77 #define FD_CLOSE_BIT               5
  78
  79 /*
  80  * Define flags to be used with the WSAAsyncSelect() call.
  81  */
  82 #define FD_READ                    0x00000001
  83 #define FD_WRITE                   0x00000002
  84 #define FD_OOB                     0x00000004
  85 #define FD_ACCEPT                  0x00000008
  86 #define FD_CONNECT                 0x00000010
  87 #define FD_CLOSE                   0x00000020
  88
  89 /* internal per-socket flags */
  90 #define FD_WINE_LISTENING          0x10000000
  91 #define FD_WINE_NONBLOCKING        0x20000000
  92 #define FD_WINE_CONNECTED          0x40000000
  93 #define FD_WINE_RAW                0x80000000
  94 #define FD_WINE_INTERNAL           0xFFFF0000
  95
  96 struct sock
  97 {
  98     struct object       obj;         /* object header */
  99     struct fd          *fd;          /* socket file descriptor */
 100     unsigned int        state;       /* status bits */
 101     unsigned int        mask;        /* event mask */
 102     unsigned int        hmask;       /* held (blocked) events */
 103     unsigned int        pmask;       /* pending events */
 104     unsigned int        flags;       /* socket flags */
 105     int                 polling;     /* is socket being polled? */
 106     unsigned short      proto;       /* socket protocol */
 107     unsigned short      type;        /* socket type */
 108     unsigned short      family;      /* socket family */
 109     struct event       *event;       /* event object */
 110     user_handle_t       window;      /* window to send the message to */
 111     unsigned int        message;     /* message to send */
 112     obj_handle_t        wparam;      /* message wparam (socket handle) */
 113     unsigned int        errors[FD_MAX_EVENTS]; /* event errors */
 114     timeout_t           connect_time;/* time the socket was connected */
 115     struct sock        *deferred;    /* socket that waits for a deferred accept */
 116     struct async_queue  read_q;      /* queue for asynchronous reads */
 117     struct async_queue  write_q;     /* queue for asynchronous writes */
 118     struct async_queue  ifchange_q;  /* queue for interface change notifications */
 119     struct object      *ifchange_obj; /* the interface change notification object */
 120     struct list         ifchange_entry; /* entry in ifchange notification list */
 121 };
 122
 123 static void sock_dump( struct object *obj, int verbose );
 124 static int sock_signaled( struct object *obj, struct wait_queue_entry *entry );
 125 static struct fd *sock_get_fd( struct object *obj );
 126 static void sock_destroy( struct object *obj );
 127 static struct object *sock_get_ifchange( struct sock *sock );
 128 static void sock_release_ifchange( struct sock *sock );
 129
 130 static int sock_get_poll_events( struct fd *fd );
 131 static void sock_poll_event( struct fd *fd, int event );
 132 static enum server_fd_type sock_get_fd_type( struct fd *fd );
 133 static int sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
 134 static void sock_queue_async( struct fd *fd, struct async *async, int type, int count );
 135 static void sock_reselect_async( struct fd *fd, struct async_queue *queue );
 136
 137 static int init_socket( struct sock *sock, int family, int type, int protocol, unsigned int flags );
 138 static int sock_get_ntstatus( int err );
 139 static unsigned int sock_get_error( int err );
 140
 141 static const struct object_ops sock_ops =
 142 {
 143     sizeof(struct sock),          /* size */
 144     sock_dump,                    /* dump */
 145     no_get_type,                  /* get_type */
 146     add_queue,                    /* add_queue */
 147     remove_queue,                 /* remove_queue */
 148     sock_signaled,                /* signaled */
 149     no_satisfied,                 /* satisfied */
 150     no_signal,                    /* signal */
 151     sock_get_fd,                  /* get_fd */
 152     default_fd_map_access,        /* map_access */
 153     default_get_sd,               /* get_sd */
 154     default_set_sd,               /* set_sd */
 155     no_get_full_name,             /* get_full_name */
 156     no_lookup_name,               /* lookup_name */
 157     no_link_name,                 /* link_name */
 158     NULL,                         /* unlink_name */
 159     no_open_file,                 /* open_file */
 160     no_kernel_obj_list,           /* get_kernel_obj_list */
 161     fd_close_handle,              /* close_handle */
 162     sock_destroy                  /* destroy */
 163 };
 164
 165 static const struct fd_ops sock_fd_ops =
 166 {
 167     sock_get_poll_events,         /* get_poll_events */
 168     sock_poll_event,              /* poll_event */
 169     sock_get_fd_type,             /* get_fd_type */
 170     no_fd_read,                   /* read */
 171     no_fd_write,                  /* write */
 172     no_fd_flush,                  /* flush */
 173     default_fd_get_file_info,     /* get_file_info */
 174     no_fd_get_volume_info,        /* get_volume_info */
 175     sock_ioctl,                   /* ioctl */
 176     sock_queue_async,             /* queue_async */
 177     sock_reselect_async           /* reselect_async */
 178 };
 179
 180
 181 /* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which
 182  * we post messages if there are multiple events.  Used to send
 183  * messages.  The problem is if there is both a FD_CONNECT event and,
 184  * say, an FD_READ event available on the same socket, we want to
 185  * notify the app of the connect event first.  Otherwise it may
 186  * discard the read event because it thinks it hasn't connected yet.
 187  */
 188 static const int event_bitorder[FD_MAX_EVENTS] =
 189 {
 190     FD_CONNECT_BIT,
 191     FD_ACCEPT_BIT,
 192     FD_OOB_BIT,
 193     FD_WRITE_BIT,
 194     FD_READ_BIT,
 195     FD_CLOSE_BIT,
 196     6, 7, 8, 9  /* leftovers */
 197 };
 198
 199 /* Flags that make sense only for SOCK_STREAM sockets */
 200 #define STREAM_FLAG_MASK ((unsigned int) (FD_CONNECT | FD_ACCEPT | FD_WINE_LISTENING | FD_WINE_CONNECTED))
 201
 202 typedef enum {
 203     SOCK_SHUTDOWN_ERROR = -1,
 204     SOCK_SHUTDOWN_EOF = 0,
 205     SOCK_SHUTDOWN_POLLHUP = 1
 206 } sock_shutdown_t;
 207
 208 static sock_shutdown_t sock_shutdown_type = SOCK_SHUTDOWN_ERROR;
 209
 210 static sock_shutdown_t sock_check_pollhup(void)
 211 {
 212     sock_shutdown_t ret = SOCK_SHUTDOWN_ERROR;
 213     int fd[2], n;
 214     struct pollfd pfd;
 215     char dummy;
 216
 217     if ( socketpair( AF_UNIX, SOCK_STREAM, 0, fd ) ) return ret;
 218     if ( shutdown( fd[0], 1 ) ) goto out;
 219
 220     pfd.fd = fd[1];
 221     pfd.events = POLLIN;
 222     pfd.revents = 0;
 223
 224     /* Solaris' poll() sometimes returns nothing if given a 0ms timeout here */
 225     n = poll( &pfd, 1, 1 );
 226     if ( n != 1 ) goto out; /* error or timeout */
 227     if ( pfd.revents & POLLHUP )
 228         ret = SOCK_SHUTDOWN_POLLHUP;
 229     else if ( pfd.revents & POLLIN &&
 230               read( fd[1], &dummy, 1 ) == 0 )
 231         ret = SOCK_SHUTDOWN_EOF;
 232
 233 out:
 234     close( fd[0] );
 235     close( fd[1] );
 236     return ret;
 237 }
 238
 239 void sock_init(void)
 240 {
 241     sock_shutdown_type = sock_check_pollhup();
 242
 243     switch ( sock_shutdown_type )
 244     {
 245     case SOCK_SHUTDOWN_EOF:
 246         if (debug_level) fprintf( stderr, "sock_init: shutdown() causes EOF\n" );
 247         break;
 248     case SOCK_SHUTDOWN_POLLHUP:
 249         if (debug_level) fprintf( stderr, "sock_init: shutdown() causes POLLHUP\n" );
 250         break;
 251     default:
 252         fprintf( stderr, "sock_init: ERROR in sock_check_pollhup()\n" );
 253         sock_shutdown_type = SOCK_SHUTDOWN_EOF;
 254     }
 255 }
 256
 257 static int sock_reselect( struct sock *sock )
 258 {
 259     int ev = sock_get_poll_events( sock->fd );
 260
 261     if (debug_level)
 262         fprintf(stderr,"sock_reselect(%p): new mask %x\n", sock, ev);
 263
 264     if (!sock->polling)  /* FIXME: should find a better way to do this */
 265     {
 266         /* previously unconnected socket, is this reselect supposed to connect it? */
 267         if (!(sock->state & ~FD_WINE_NONBLOCKING)) return 0;
 268         /* ok, it is, attach it to the wineserver's main poll loop */
 269         sock->polling = 1;
 270         allow_fd_caching( sock->fd );
 271     }
 272     /* update condition mask */
 273     set_fd_events( sock->fd, ev );
 274     return ev;
 275 }
 276
 277 /* wake anybody waiting on the socket event or send the associated message */
 278 static void sock_wake_up( struct sock *sock )
 279 {
 280     unsigned int events = sock->pmask & sock->mask;
 281     int i;
 282
 283     if ( !events ) return;
 284
 285     if (sock->event)
 286     {
 287         if (debug_level) fprintf(stderr, "signalling events %x ptr %p\n", events, sock->event );
 288         set_event( sock->event );
 289     }
 290     if (sock->window)
 291     {
 292         if (debug_level) fprintf(stderr, "signalling events %x win %08x\n", events, sock->window );
 293         for (i = 0; i < FD_MAX_EVENTS; i++)
 294         {
 295             int event = event_bitorder[i];
 296             if (sock->pmask & (1 << event))
 297             {
 298                 lparam_t lparam = (1 << event) | (sock->errors[event] << 16);
 299                 post_message( sock->window, sock->message, sock->wparam, lparam );
 300             }
 301         }
 302         sock->pmask = 0;
 303         sock_reselect( sock );
 304     }
 305 }
 306
 307 static inline int sock_error( struct fd *fd )
 308 {
 309     unsigned int optval = 0;
 310     socklen_t optlen = sizeof(optval);
 311
 312     getsockopt( get_unix_fd(fd), SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
 313     return optval;
 314 }
 315
 316 static int sock_dispatch_asyncs( struct sock *sock, int event, int error )
 317 {
 318     if ( sock->flags & WSA_FLAG_OVERLAPPED )
 319     {
 320         if (event & (POLLIN|POLLPRI) && async_waiting( &sock->read_q ))
 321         {
 322             if (debug_level) fprintf( stderr, "activating read queue for socket %p\n", sock );
 323             async_wake_up( &sock->read_q, STATUS_ALERTED );
 324             event &= ~(POLLIN|POLLPRI);
 325         }
 326         if (event & POLLOUT && async_waiting( &sock->write_q ))
 327         {
 328             if (debug_level) fprintf( stderr, "activating write queue for socket %p\n", sock );
 329             async_wake_up( &sock->write_q, STATUS_ALERTED );
 330             event &= ~POLLOUT;
 331         }
 332         if ( event & (POLLERR|POLLHUP) )
 333         {
 334             int status = sock_get_ntstatus( error );
 335
 336             if ( !(sock->state & FD_READ) )
 337                 async_wake_up( &sock->read_q, status );
 338             if ( !(sock->state & FD_WRITE) )
 339                 async_wake_up( &sock->write_q, status );
 340         }
 341     }
 342     return event;
 343 }
 344
 345 static void sock_dispatch_events( struct sock *sock, int prevstate, int event, int error )
 346 {
 347     if (prevstate & FD_CONNECT)
 348     {
 349         sock->pmask |= FD_CONNECT;
 350         sock->hmask |= FD_CONNECT;
 351         sock->errors[FD_CONNECT_BIT] = sock_get_error( error );
 352         goto end;
 353     }
 354     if (prevstate & FD_WINE_LISTENING)
 355     {
 356         sock->pmask |= FD_ACCEPT;
 357         sock->hmask |= FD_ACCEPT;
 358         sock->errors[FD_ACCEPT_BIT] = sock_get_error( error );
 359         goto end;
 360     }
 361
 362     if (event & POLLIN)
 363     {
 364         sock->pmask |= FD_READ;
 365         sock->hmask |= FD_READ;
 366         sock->errors[FD_READ_BIT] = 0;
 367     }
 368
 369     if (event & POLLOUT)
 370     {
 371         sock->pmask |= FD_WRITE;
 372         sock->hmask |= FD_WRITE;
 373         sock->errors[FD_WRITE_BIT] = 0;
 374     }
 375
 376     if (event & POLLPRI)
 377     {
 378         sock->pmask |= FD_OOB;
 379         sock->hmask |= FD_OOB;
 380         sock->errors[FD_OOB_BIT] = 0;
 381     }
 382
 383     if (event & (POLLERR|POLLHUP))
 384     {
 385         sock->pmask |= FD_CLOSE;
 386         sock->hmask |= FD_CLOSE;
 387         sock->errors[FD_CLOSE_BIT] = sock_get_error( error );
 388     }
 389 end:
 390     sock_wake_up( sock );
 391 }
 392
 393 static void sock_poll_event( struct fd *fd, int event )
 394 {
 395     struct sock *sock = get_fd_user( fd );
 396     int hangup_seen = 0;
 397     int prevstate = sock->state;
 398     int error = 0;
 399
 400     assert( sock->obj.ops == &sock_ops );
 401     if (debug_level)
 402         fprintf(stderr, "socket %p select event: %x\n", sock, event);
 403
 404     /* we may change event later, remove from loop here */
 405     if (event & (POLLERR|POLLHUP)) set_fd_events( sock->fd, -1 );
 406
 407     if (sock->state & FD_CONNECT)
 408     {
 409         if (event & (POLLERR|POLLHUP))
 410         {
 411             /* we didn't get connected? */
 412             sock->state &= ~FD_CONNECT;
 413             event &= ~POLLOUT;
 414             error = sock_error( fd );
 415         }
 416         else if (event & POLLOUT)
 417         {
 418             /* we got connected */
 419             sock->state |= FD_WINE_CONNECTED|FD_READ|FD_WRITE;
 420             sock->state &= ~FD_CONNECT;
 421             sock->connect_time = current_time;
 422         }
 423     }
 424     else if (sock->state & FD_WINE_LISTENING)
 425     {
 426         /* listening */
 427         if (event & (POLLERR|POLLHUP))
 428             error = sock_error( fd );
 429     }
 430     else
 431     {
 432         /* normal data flow */
 433         if ( sock->type == SOCK_STREAM && ( event & POLLIN ) )
 434         {
 435             char dummy;
 436             int nr;
 437
 438             /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
 439              * has been closed, so we need to check for it explicitly here */
 440             nr  = recv( get_unix_fd( fd ), &dummy, 1, MSG_PEEK );
 441             if ( nr == 0 )
 442             {
 443                 hangup_seen = 1;
 444                 event &= ~POLLIN;
 445             }
 446             else if ( nr < 0 )
 447             {
 448                 event &= ~POLLIN;
 449                 /* EAGAIN can happen if an async recv() falls between the server's poll()
 450                    call and the invocation of this routine */
 451                 if ( errno != EAGAIN )
 452                 {
 453                     error = errno;
 454                     event |= POLLERR;
 455                     if ( debug_level )
 456                         fprintf( stderr, "recv error on socket %p: %d\n", sock, errno );
 457                 }
 458             }
 459         }
 460
 461         if ( (hangup_seen || event & (POLLHUP|POLLERR)) && (sock->state & (FD_READ|FD_WRITE)) )
 462         {
 463             error = error ? error : sock_error( fd );
 464             if ( (event & POLLERR) || ( sock_shutdown_type == SOCK_SHUTDOWN_EOF && (event & POLLHUP) ))
 465                 sock->state &= ~FD_WRITE;
 466             sock->state &= ~FD_READ;
 467
 468             if (debug_level)
 469                 fprintf(stderr, "socket %p aborted by error %d, event: %x\n", sock, error, event);
 470         }
 471
 472         if (hangup_seen)
 473             event |= POLLHUP;
 474     }
 475
 476     event = sock_dispatch_asyncs( sock, event, error );
 477     sock_dispatch_events( sock, prevstate, event, error );
 478
 479     /* if anyone is stupid enough to wait on the socket object itself,
 480      * maybe we should wake them up too, just in case? */
 481     wake_up( &sock->obj, 0 );
 482
 483     sock_reselect( sock );
 484 }
 485
 486 static void sock_dump( struct object *obj, int verbose )
 487 {
 488     struct sock *sock = (struct sock *)obj;
 489     assert( obj->ops == &sock_ops );
 490     fprintf( stderr, "Socket fd=%p, state=%x, mask=%x, pending=%x, held=%x\n",
 491             sock->fd, sock->state,
 492             sock->mask, sock->pmask, sock->hmask );
 493 }
 494
 495 static int sock_signaled( struct object *obj, struct wait_queue_entry *entry )
 496 {
 497     struct sock *sock = (struct sock *)obj;
 498     assert( obj->ops == &sock_ops );
 499
 500     return check_fd_events( sock->fd, sock_get_poll_events( sock->fd ) ) != 0;
 501 }
 502
 503 static int sock_get_poll_events( struct fd *fd )
 504 {
 505     struct sock *sock = get_fd_user( fd );
 506     unsigned int mask = sock->mask & ~sock->hmask;
 507     unsigned int smask = sock->state & mask;
 508     int ev = 0;
 509
 510     assert( sock->obj.ops == &sock_ops );
 511
 512     if (sock->state & FD_CONNECT)
 513         /* connecting, wait for writable */
 514         return POLLOUT;
 515
 516     if (async_queued( &sock->read_q ))
 517     {
 518         if (async_waiting( &sock->read_q )) ev |= POLLIN | POLLPRI;
 519     }
 520     else if (smask & FD_READ || (sock->state & FD_WINE_LISTENING && mask & FD_ACCEPT))
 521         ev |= POLLIN | POLLPRI;
 522     /* We use POLLIN with 0 bytes recv() as FD_CLOSE indication for stream sockets. */
 523     else if ( sock->type == SOCK_STREAM && sock->state & FD_READ && mask & FD_CLOSE &&
 524               !(sock->hmask & FD_READ) )
 525         ev |= POLLIN;
 526
 527     if (async_queued( &sock->write_q ))
 528     {
 529         if (async_waiting( &sock->write_q )) ev |= POLLOUT;
 530     }
 531     else if (smask & FD_WRITE)
 532         ev |= POLLOUT;
 533
 534     return ev;
 535 }
 536
 537 static enum server_fd_type sock_get_fd_type( struct fd *fd )
 538 {
 539     return FD_TYPE_SOCKET;
 540 }
 541
 542 static int sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
 543 {
 544     struct sock *sock = get_fd_user( fd );
 545
 546     assert( sock->obj.ops == &sock_ops );
 547
 548     if (get_unix_fd( fd ) == -1 && code != IOCTL_AFD_CREATE) return 0;
 549
 550     switch(code)
 551     {
 552     case IOCTL_AFD_CREATE:
 553     {
 554         const struct afd_create_params *params = get_req_data();
 555
 556         if (get_req_data_size() != sizeof(*params))
 557         {
 558             set_error( STATUS_INVALID_PARAMETER );
 559             return 0;
 560         }
 561         init_socket( sock, params->family, params->type, params->protocol, params->flags );
 562         return 0;
 563     }
 564
 565     case WS_SIO_ADDRESS_LIST_CHANGE:
 566         if ((sock->state & FD_WINE_NONBLOCKING) && async_is_blocking( async ))
 567         {
 568             set_win32_error( WSAEWOULDBLOCK );
 569             return 0;
 570         }
 571         if (!sock_get_ifchange( sock )) return 0;
 572         queue_async( &sock->ifchange_q, async );
 573         set_error( STATUS_PENDING );
 574         return 1;
 575     default:
 576         set_error( STATUS_NOT_SUPPORTED );
 577         return 0;
 578     }
 579 }
 580
 581 static void sock_queue_async( struct fd *fd, struct async *async, int type, int count )
 582 {
 583     struct sock *sock = get_fd_user( fd );
 584     struct async_queue *queue;
 585
 586     assert( sock->obj.ops == &sock_ops );
 587
 588     switch (type)
 589     {
 590     case ASYNC_TYPE_READ:
 591         queue = &sock->read_q;
 592         break;
 593     case ASYNC_TYPE_WRITE:
 594         queue = &sock->write_q;
 595         break;
 596     default:
 597         set_error( STATUS_INVALID_PARAMETER );
 598         return;
 599     }
 600
 601     if ( ( !( sock->state & (FD_READ|FD_CONNECT|FD_WINE_LISTENING) ) && type == ASYNC_TYPE_READ  ) ||
 602          ( !( sock->state & (FD_WRITE|FD_CONNECT) ) && type == ASYNC_TYPE_WRITE ) )
 603     {
 604         set_error( STATUS_PIPE_DISCONNECTED );
 605         return;
 606     }
 607
 608     queue_async( queue, async );
 609     sock_reselect( sock );
 610
 611     set_error( STATUS_PENDING );
 612 }
 613
 614 static void sock_reselect_async( struct fd *fd, struct async_queue *queue )
 615 {
 616     struct sock *sock = get_fd_user( fd );
 617     /* ignore reselect on ifchange queue */
 618     if (&sock->ifchange_q != queue)
 619         sock_reselect( sock );
 620 }
 621
 622 static struct fd *sock_get_fd( struct object *obj )
 623 {
 624     struct sock *sock = (struct sock *)obj;
 625     return (struct fd *)grab_object( sock->fd );
 626 }
 627
 628 static void sock_destroy( struct object *obj )
 629 {
 630     struct sock *sock = (struct sock *)obj;
 631     assert( obj->ops == &sock_ops );
 632
 633     /* FIXME: special socket shutdown stuff? */
 634
 635     if ( sock->deferred )
 636         release_object( sock->deferred );
 637
 638     async_wake_up( &sock->ifchange_q, STATUS_CANCELLED );
 639     sock_release_ifchange( sock );
 640     free_async_queue( &sock->read_q );
 641     free_async_queue( &sock->write_q );
 642     free_async_queue( &sock->ifchange_q );
 643     if (sock->event) release_object( sock->event );
 644     if (sock->fd)
 645     {
 646         /* shut the socket down to force pending poll() calls in the client to return */
 647         shutdown( get_unix_fd(sock->fd), SHUT_RDWR );
 648         release_object( sock->fd );
 649     }
 650 }
 651
 652 static struct sock *create_socket(void)
 653 {
 654     struct sock *sock;
 655
 656     if (!(sock = alloc_object( &sock_ops ))) return NULL;
 657     sock->fd      = NULL;
 658     sock->state   = 0;
 659     sock->mask    = 0;
 660     sock->hmask   = 0;
 661     sock->pmask   = 0;
 662     sock->polling = 0;
 663     sock->flags   = 0;
 664     sock->proto   = 0;
 665     sock->type    = 0;
 666     sock->family  = 0;
 667     sock->event   = NULL;
 668     sock->window  = 0;
 669     sock->message = 0;
 670     sock->wparam  = 0;
 671     sock->connect_time = 0;
 672     sock->deferred = NULL;
 673     sock->ifchange_obj = NULL;
 674     init_async_queue( &sock->read_q );
 675     init_async_queue( &sock->write_q );
 676     init_async_queue( &sock->ifchange_q );
 677     memset( sock->errors, 0, sizeof(sock->errors) );
 678     return sock;
 679 }
 680
 681 static int init_socket( struct sock *sock, int family, int type, int protocol, unsigned int flags )
 682 {
 683     int sockfd;
 684
 685     sockfd = socket( family, type, protocol );
 686     if (sockfd == -1)
 687     {
 688         if (errno == EINVAL) set_win32_error( WSAESOCKTNOSUPPORT );
 689         else set_win32_error( sock_get_error( errno ));
 690         return -1;
 691     }
 692     fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
 693     sock->state  = (type != SOCK_STREAM) ? (FD_READ|FD_WRITE) : 0;
 694     sock->flags  = flags;
 695     sock->proto  = protocol;
 696     sock->type   = type;
 697     sock->family = family;
 698
 699     if (sock->fd) release_object( sock->fd );
 700
 701     if (!(sock->fd = create_anonymous_fd( &sock_fd_ops, sockfd, &sock->obj,
 702                             (flags & WSA_FLAG_OVERLAPPED) ? 0 : FILE_SYNCHRONOUS_IO_NONALERT )))
 703     {
 704         return -1;
 705     }
 706     sock_reselect( sock );
 707     clear_error();
 708     return 0;
 709 }
 710
 711 /* accepts a socket and inits it */
 712 static int accept_new_fd( struct sock *sock )
 713 {
 714
 715     /* Try to accept(2). We can't be safe that this an already connected socket
 716      * or that accept() is allowed on it. In those cases we will get -1/errno
 717      * return.
 718      */
 719     struct sockaddr saddr;
 720     socklen_t slen = sizeof(saddr);
 721     int acceptfd = accept( get_unix_fd(sock->fd), &saddr, &slen );
 722     if (acceptfd != -1)
 723         fcntl( acceptfd, F_SETFL, O_NONBLOCK );
 724     else
 725         set_win32_error( sock_get_error( errno ));
 726     return acceptfd;
 727 }
 728
 729 /* accept a socket (creates a new fd) */
 730 static struct sock *accept_socket( obj_handle_t handle )
 731 {
 732     struct sock *acceptsock;
 733     struct sock *sock;
 734     int acceptfd;
 735
 736     sock = (struct sock *)get_handle_obj( current->process, handle, FILE_READ_DATA, &sock_ops );
 737     if (!sock)
 738         return NULL;
 739
 740     if (get_unix_fd( sock->fd ) == -1) return NULL;
 741
 742     if ( sock->deferred )
 743     {
 744         acceptsock = sock->deferred;
 745         sock->deferred = NULL;
 746     }
 747     else
 748     {
 749         if ((acceptfd = accept_new_fd( sock )) == -1)
 750         {
 751             release_object( sock );
 752             return NULL;
 753         }
 754         if (!(acceptsock = create_socket()))
 755         {
 756             close( acceptfd );
 757             release_object( sock );
 758             return NULL;
 759         }
 760
 761         /* newly created socket gets the same properties of the listening socket */
 762         acceptsock->state  = FD_WINE_CONNECTED|FD_READ|FD_WRITE;
 763         if (sock->state & FD_WINE_NONBLOCKING)
 764             acceptsock->state |= FD_WINE_NONBLOCKING;
 765         acceptsock->mask    = sock->mask;
 766         acceptsock->proto   = sock->proto;
 767         acceptsock->type    = sock->type;
 768         acceptsock->family  = sock->family;
 769         acceptsock->window  = sock->window;
 770         acceptsock->message = sock->message;
 771         acceptsock->connect_time = current_time;
 772         if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
 773         acceptsock->flags = sock->flags;
 774         if (!(acceptsock->fd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
 775                                                     get_fd_options( sock->fd ) )))
 776         {
 777             release_object( acceptsock );
 778             release_object( sock );
 779             return NULL;
 780         }
 781     }
 782     clear_error();
 783     sock->pmask &= ~FD_ACCEPT;
 784     sock->hmask &= ~FD_ACCEPT;
 785     sock_reselect( sock );
 786     release_object( sock );
 787     return acceptsock;
 788 }
 789
 790 static int accept_into_socket( struct sock *sock, struct sock *acceptsock )
 791 {
 792     int acceptfd;
 793     struct fd *newfd;
 794
 795     if (get_unix_fd( sock->fd ) == -1) return FALSE;
 796
 797     if ( sock->deferred )
 798     {
 799         newfd = dup_fd_object( sock->deferred->fd, 0, 0,
 800                                get_fd_options( acceptsock->fd ) );
 801         if ( !newfd )
 802             return FALSE;
 803
 804         set_fd_user( newfd, &sock_fd_ops, &acceptsock->obj );
 805
 806         release_object( sock->deferred );
 807         sock->deferred = NULL;
 808     }
 809     else
 810     {
 811         if ((acceptfd = accept_new_fd( sock )) == -1)
 812             return FALSE;
 813
 814         if (!(newfd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
 815                                             get_fd_options( acceptsock->fd ) )))
 816             return FALSE;
 817     }
 818
 819     acceptsock->state  |= FD_WINE_CONNECTED|FD_READ|FD_WRITE;
 820     acceptsock->hmask   = 0;
 821     acceptsock->pmask   = 0;
 822     acceptsock->polling = 0;
 823     acceptsock->proto   = sock->proto;
 824     acceptsock->type    = sock->type;
 825     acceptsock->family  = sock->family;
 826     acceptsock->wparam  = 0;
 827     acceptsock->deferred = NULL;
 828     acceptsock->connect_time = current_time;
 829     fd_copy_completion( acceptsock->fd, newfd );
 830     release_object( acceptsock->fd );
 831     acceptsock->fd = newfd;
 832
 833     clear_error();
 834     sock->pmask &= ~FD_ACCEPT;
 835     sock->hmask &= ~FD_ACCEPT;
 836     sock_reselect( sock );
 837
 838     return TRUE;
 839 }
 840
 841 /* return an errno value mapped to a WSA error */
 842 static unsigned int sock_get_error( int err )
 843 {
 844     switch (err)
 845     {
 846         case EINTR:             return WSAEINTR;
 847         case EBADF:             return WSAEBADF;
 848         case EPERM:
 849         case EACCES:            return WSAEACCES;
 850         case EFAULT:            return WSAEFAULT;
 851         case EINVAL:            return WSAEINVAL;
 852         case EMFILE:            return WSAEMFILE;
 853         case EWOULDBLOCK:       return WSAEWOULDBLOCK;
 854         case EINPROGRESS:       return WSAEINPROGRESS;
 855         case EALREADY:          return WSAEALREADY;
 856         case ENOTSOCK:          return WSAENOTSOCK;
 857         case EDESTADDRREQ:      return WSAEDESTADDRREQ;
 858         case EMSGSIZE:          return WSAEMSGSIZE;
 859         case EPROTOTYPE:        return WSAEPROTOTYPE;
 860         case ENOPROTOOPT:       return WSAENOPROTOOPT;
 861         case EPROTONOSUPPORT:   return WSAEPROTONOSUPPORT;
 862         case ESOCKTNOSUPPORT:   return WSAESOCKTNOSUPPORT;
 863         case EOPNOTSUPP:        return WSAEOPNOTSUPP;
 864         case EPFNOSUPPORT:      return WSAEPFNOSUPPORT;
 865         case EAFNOSUPPORT:      return WSAEAFNOSUPPORT;
 866         case EADDRINUSE:        return WSAEADDRINUSE;
 867         case EADDRNOTAVAIL:     return WSAEADDRNOTAVAIL;
 868         case ENETDOWN:          return WSAENETDOWN;
 869         case ENETUNREACH:       return WSAENETUNREACH;
 870         case ENETRESET:         return WSAENETRESET;
 871         case ECONNABORTED:      return WSAECONNABORTED;
 872         case EPIPE:
 873         case ECONNRESET:        return WSAECONNRESET;
 874         case ENOBUFS:           return WSAENOBUFS;
 875         case EISCONN:           return WSAEISCONN;
 876         case ENOTCONN:          return WSAENOTCONN;
 877         case ESHUTDOWN:         return WSAESHUTDOWN;
 878         case ETOOMANYREFS:      return WSAETOOMANYREFS;
 879         case ETIMEDOUT:         return WSAETIMEDOUT;
 880         case ECONNREFUSED:      return WSAECONNREFUSED;
 881         case ELOOP:             return WSAELOOP;
 882         case ENAMETOOLONG:      return WSAENAMETOOLONG;
 883         case EHOSTDOWN:         return WSAEHOSTDOWN;
 884         case EHOSTUNREACH:      return WSAEHOSTUNREACH;
 885         case ENOTEMPTY:         return WSAENOTEMPTY;
 886 #ifdef EPROCLIM
 887         case EPROCLIM:          return WSAEPROCLIM;
 888 #endif
 889 #ifdef EUSERS
 890         case EUSERS:            return WSAEUSERS;
 891 #endif
 892 #ifdef EDQUOT
 893         case EDQUOT:            return WSAEDQUOT;
 894 #endif
 895 #ifdef ESTALE
 896         case ESTALE:            return WSAESTALE;
 897 #endif
 898 #ifdef EREMOTE
 899         case EREMOTE:           return WSAEREMOTE;
 900 #endif
 901
 902         case 0:                 return 0;
 903         default:
 904             errno = err;
 905             perror("wineserver: sock_get_error() can't map error");
 906             return WSAEFAULT;
 907     }
 908 }
 909
 910 static int sock_get_ntstatus( int err )
 911 {
 912     switch ( err )
 913     {
 914         case EBADF:             return STATUS_INVALID_HANDLE;
 915         case EBUSY:             return STATUS_DEVICE_BUSY;
 916         case EPERM:
 917         case EACCES:            return STATUS_ACCESS_DENIED;
 918         case EFAULT:            return STATUS_NO_MEMORY;
 919         case EINVAL:            return STATUS_INVALID_PARAMETER;
 920         case ENFILE:
 921         case EMFILE:            return STATUS_TOO_MANY_OPENED_FILES;
 922         case EWOULDBLOCK:       return STATUS_CANT_WAIT;
 923         case EINPROGRESS:       return STATUS_PENDING;
 924         case EALREADY:          return STATUS_NETWORK_BUSY;
 925         case ENOTSOCK:          return STATUS_OBJECT_TYPE_MISMATCH;
 926         case EDESTADDRREQ:      return STATUS_INVALID_PARAMETER;
 927         case EMSGSIZE:          return STATUS_BUFFER_OVERFLOW;
 928         case EPROTONOSUPPORT:
 929         case ESOCKTNOSUPPORT:
 930         case EPFNOSUPPORT:
 931         case EAFNOSUPPORT:
 932         case EPROTOTYPE:        return STATUS_NOT_SUPPORTED;
 933         case ENOPROTOOPT:       return STATUS_INVALID_PARAMETER;
 934         case EOPNOTSUPP:        return STATUS_NOT_SUPPORTED;
 935         case EADDRINUSE:        return STATUS_ADDRESS_ALREADY_ASSOCIATED;
 936         case EADDRNOTAVAIL:     return STATUS_INVALID_PARAMETER;
 937         case ECONNREFUSED:      return STATUS_CONNECTION_REFUSED;
 938         case ESHUTDOWN:         return STATUS_PIPE_DISCONNECTED;
 939         case ENOTCONN:          return STATUS_CONNECTION_DISCONNECTED;
 940         case ETIMEDOUT:         return STATUS_IO_TIMEOUT;
 941         case ENETUNREACH:       return STATUS_NETWORK_UNREACHABLE;
 942         case EHOSTUNREACH:      return STATUS_HOST_UNREACHABLE;
 943         case ENETDOWN:          return STATUS_NETWORK_BUSY;
 944         case EPIPE:
 945         case ECONNRESET:        return STATUS_CONNECTION_RESET;
 946         case ECONNABORTED:      return STATUS_CONNECTION_ABORTED;
 947
 948         case 0:                 return STATUS_SUCCESS;
 949         default:
 950             errno = err;
 951             perror("wineserver: sock_get_ntstatus() can't map error");
 952             return STATUS_UNSUCCESSFUL;
 953     }
 954 }
 955
 956 #ifdef HAVE_LINUX_RTNETLINK_H
 957
 958 /* only keep one ifchange object around, all sockets waiting for wakeups will look to it */
 959 static struct object *ifchange_object;
 960
 961 static void ifchange_dump( struct object *obj, int verbose );
 962 static struct fd *ifchange_get_fd( struct object *obj );
 963 static void ifchange_destroy( struct object *obj );
 964
 965 static int ifchange_get_poll_events( struct fd *fd );
 966 static void ifchange_poll_event( struct fd *fd, int event );
 967
 968 struct ifchange
 969 {
 970     struct object       obj;     /* object header */
 971     struct fd          *fd;      /* interface change file descriptor */
 972     struct list         sockets; /* list of sockets to send interface change notifications */
 973 };
 974
 975 static const struct object_ops ifchange_ops =
 976 {
 977     sizeof(struct ifchange), /* size */
 978     ifchange_dump,           /* dump */
 979     no_get_type,             /* get_type */
 980     add_queue,               /* add_queue */
 981     NULL,                    /* remove_queue */
 982     NULL,                    /* signaled */
 983     no_satisfied,            /* satisfied */
 984     no_signal,               /* signal */
 985     ifchange_get_fd,         /* get_fd */
 986     default_fd_map_access,   /* map_access */
 987     default_get_sd,          /* get_sd */
 988     default_set_sd,          /* set_sd */
 989     no_get_full_name,        /* get_full_name */
 990     no_lookup_name,          /* lookup_name */
 991     no_link_name,            /* link_name */
 992     NULL,                    /* unlink_name */
 993     no_open_file,            /* open_file */
 994     no_kernel_obj_list,      /* get_kernel_obj_list */
 995     no_close_handle,         /* close_handle */
 996     ifchange_destroy         /* destroy */
 997 };
 998
 999 static const struct fd_ops ifchange_fd_ops =
1000 {
1001     ifchange_get_poll_events, /* get_poll_events */
1002     ifchange_poll_event,      /* poll_event */
1003     NULL,                     /* get_fd_type */
1004     no_fd_read,               /* read */
1005     no_fd_write,              /* write */
1006     no_fd_flush,              /* flush */
1007     no_fd_get_file_info,      /* get_file_info */
1008     no_fd_get_volume_info,    /* get_volume_info */
1009     no_fd_ioctl,              /* ioctl */
1010     NULL,                     /* queue_async */
1011     NULL                      /* reselect_async */
1012 };
1013
1014 static void ifchange_dump( struct object *obj, int verbose )
1015 {
1016     assert( obj->ops == &ifchange_ops );
1017     fprintf( stderr, "Interface change\n" );
1018 }
1019
1020 static struct fd *ifchange_get_fd( struct object *obj )
1021 {
1022     struct ifchange *ifchange = (struct ifchange *)obj;
1023     return (struct fd *)grab_object( ifchange->fd );
1024 }
1025
1026 static void ifchange_destroy( struct object *obj )
1027 {
1028     struct ifchange *ifchange = (struct ifchange *)obj;
1029     assert( obj->ops == &ifchange_ops );
1030
1031     release_object( ifchange->fd );
1032
1033     /* reset the global ifchange object so that it will be recreated if it is needed again */
1034     assert( obj == ifchange_object );
1035     ifchange_object = NULL;
1036 }
1037
1038 static int ifchange_get_poll_events( struct fd *fd )
1039 {
1040     return POLLIN;
1041 }
1042
1043 /* wake up all the sockets waiting for a change notification event */
1044 static void ifchange_wake_up( struct object *obj, unsigned int status )
1045 {
1046     struct ifchange *ifchange = (struct ifchange *)obj;
1047     struct list *ptr, *next;
1048     assert( obj->ops == &ifchange_ops );
1049     assert( obj == ifchange_object );
1050
1051     LIST_FOR_EACH_SAFE( ptr, next, &ifchange->sockets )
1052     {
1053         struct sock *sock = LIST_ENTRY( ptr, struct sock, ifchange_entry );
1054
1055         assert( sock->ifchange_obj );
1056         async_wake_up( &sock->ifchange_q, status ); /* issue ifchange notification for the socket */
1057         sock_release_ifchange( sock ); /* remove socket from list and decrement ifchange refcount */
1058     }
1059 }
1060
1061 static void ifchange_poll_event( struct fd *fd, int event )
1062 {
1063     struct object *ifchange = get_fd_user( fd );
1064     unsigned int status = STATUS_PENDING;
1065     char buffer[PIPE_BUF];
1066     int r;
1067
1068     r = recv( get_unix_fd(fd), buffer, sizeof(buffer), MSG_DONTWAIT );
1069     if (r < 0)
1070     {
1071         if (errno == EWOULDBLOCK || (EWOULDBLOCK != EAGAIN && errno == EAGAIN))
1072             return;  /* retry when poll() says the socket is ready */
1073         status = sock_get_ntstatus( errno );
1074     }
1075     else if (r > 0)
1076     {
1077         struct nlmsghdr *nlh;
1078
1079         for (nlh = (struct nlmsghdr *)buffer; NLMSG_OK(nlh, r); nlh = NLMSG_NEXT(nlh, r))
1080         {
1081             if (nlh->nlmsg_type == NLMSG_DONE)
1082                 break;
1083             if (nlh->nlmsg_type == RTM_NEWADDR || nlh->nlmsg_type == RTM_DELADDR)
1084                 status = STATUS_SUCCESS;
1085         }
1086     }
1087     else status = STATUS_CANCELLED;
1088
1089     if (status != STATUS_PENDING) ifchange_wake_up( ifchange, status );
1090 }
1091
1092 #endif
1093
1094 /* we only need one of these interface notification objects, all of the sockets dependent upon
1095  * it will wake up when a notification event occurs */
1096  static struct object *get_ifchange( void )
1097  {
1098 #ifdef HAVE_LINUX_RTNETLINK_H
1099     struct ifchange *ifchange;
1100     struct sockaddr_nl addr;
1101     int unix_fd;
1102
1103     if (ifchange_object)
1104     {
1105         /* increment the refcount for each socket that uses the ifchange object */
1106         return grab_object( ifchange_object );
1107     }
1108
1109     /* create the socket we need for processing interface change notifications */
1110     unix_fd = socket( PF_NETLINK, SOCK_RAW, NETLINK_ROUTE );
1111     if (unix_fd == -1)
1112     {
1113         set_win32_error( sock_get_error( errno ));
1114         return NULL;
1115     }
1116     fcntl( unix_fd, F_SETFL, O_NONBLOCK ); /* make socket nonblocking */
1117     memset( &addr, 0, sizeof(addr) );
1118     addr.nl_family = AF_NETLINK;
1119     addr.nl_groups = RTMGRP_IPV4_IFADDR;
1120     /* bind the socket to the special netlink kernel interface */
1121     if (bind( unix_fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1)
1122     {
1123         close( unix_fd );
1124         set_win32_error( sock_get_error( errno ));
1125         return NULL;
1126     }
1127     if (!(ifchange = alloc_object( &ifchange_ops )))
1128     {
1129         close( unix_fd );
1130         set_error( STATUS_NO_MEMORY );
1131         return NULL;
1132     }
1133     list_init( &ifchange->sockets );
1134     if (!(ifchange->fd = create_anonymous_fd( &ifchange_fd_ops, unix_fd, &ifchange->obj, 0 )))
1135     {
1136         release_object( ifchange );
1137         set_error( STATUS_NO_MEMORY );
1138         return NULL;
1139     }
1140     set_fd_events( ifchange->fd, POLLIN ); /* enable read wakeup on the file descriptor */
1141
1142     /* the ifchange object is now successfully configured */
1143     ifchange_object = &ifchange->obj;
1144     return &ifchange->obj;
1145 #else
1146     set_error( STATUS_NOT_SUPPORTED );
1147     return NULL;
1148 #endif
1149 }
1150
1151 /* add the socket to the interface change notification list */
1152 static void ifchange_add_sock( struct object *obj, struct sock *sock )
1153 {
1154 #ifdef HAVE_LINUX_RTNETLINK_H
1155     struct ifchange *ifchange = (struct ifchange *)obj;
1156
1157     list_add_tail( &ifchange->sockets, &sock->ifchange_entry );
1158 #endif
1159 }
1160
1161 /* create a new ifchange queue for a specific socket or, if one already exists, reuse the existing one */
1162 static struct object *sock_get_ifchange( struct sock *sock )
1163 {
1164     struct object *ifchange;
1165
1166     if (sock->ifchange_obj) /* reuse existing ifchange_obj for this socket */
1167         return sock->ifchange_obj;
1168
1169     if (!(ifchange = get_ifchange()))
1170         return NULL;
1171
1172     /* add the socket to the ifchange notification list */
1173     ifchange_add_sock( ifchange, sock );
1174     sock->ifchange_obj = ifchange;
1175     return ifchange;
1176 }
1177
1178 /* destroy an existing ifchange queue for a specific socket */
1179 static void sock_release_ifchange( struct sock *sock )
1180 {
1181     if (sock->ifchange_obj)
1182     {
1183         list_remove( &sock->ifchange_entry );
1184         release_object( sock->ifchange_obj );
1185         sock->ifchange_obj = NULL;
1186     }
1187 }
1188
1189 static struct object_type *socket_device_get_type( struct object *obj );
1190 static void socket_device_dump( struct object *obj, int verbose );
1191 static struct object *socket_device_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr );
1192 static struct object *socket_device_open_file( struct object *obj, unsigned int access,
1193                                                unsigned int sharing, unsigned int options );
1194
1195 static const struct object_ops socket_device_ops =
1196 {
1197     sizeof(struct object),      /* size */
1198     socket_device_dump,         /* dump */
1199     socket_device_get_type,     /* get_type */
1200     no_add_queue,               /* add_queue */
1201     NULL,                       /* remove_queue */
1202     NULL,                       /* signaled */
1203     no_satisfied,               /* satisfied */
1204     no_signal,                  /* signal */
1205     no_get_fd,                  /* get_fd */
1206     default_fd_map_access,      /* map_access */
1207     default_get_sd,             /* get_sd */
1208     default_set_sd,             /* set_sd */
1209     default_get_full_name,      /* get_full_name */
1210     socket_device_lookup_name,  /* lookup_name */
1211     directory_link_name,        /* link_name */
1212     default_unlink_name,        /* unlink_name */
1213     socket_device_open_file,    /* open_file */
1214     no_kernel_obj_list,         /* get_kernel_obj_list */
1215     no_close_handle,            /* close_handle */
1216     no_destroy                  /* destroy */
1217 };
1218
1219 static struct object_type *socket_device_get_type( struct object *obj )
1220 {
1221     static const WCHAR name[] = {'D','e','v','i','c','e'};
1222     static const struct unicode_str str = { name, sizeof(name) };
1223     return get_object_type( &str );
1224 }
1225
1226 static void socket_device_dump( struct object *obj, int verbose )
1227 {
1228     fputs( "Socket device\n", stderr );
1229 }
1230
1231 static struct object *socket_device_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr )
1232 {
1233     return NULL;
1234 }
1235
1236 static struct object *socket_device_open_file( struct object *obj, unsigned int access,
1237                                                unsigned int sharing, unsigned int options )
1238 {
1239     struct sock *sock;
1240
1241     if (!(sock = create_socket())) return NULL;
1242     if (!(sock->fd = alloc_pseudo_fd( &sock_fd_ops, &sock->obj, options )))
1243     {
1244         release_object( sock );
1245         return NULL;
1246     }
1247     return &sock->obj;
1248 }
1249
1250 struct object *create_socket_device( struct object *root, const struct unicode_str *name )
1251 {
1252     return create_named_object( root, &socket_device_ops, name, 0, NULL );
1253 }
1254
1255 /* accept a socket */
1256 DECL_HANDLER(accept_socket)
1257 {
1258     struct sock *sock;
1259
1260     reply->handle = 0;
1261     if ((sock = accept_socket( req->lhandle )) != NULL)
1262     {
1263         reply->handle = alloc_handle( current->process, &sock->obj, req->access, req->attributes );
1264         sock->wparam = reply->handle;  /* wparam for message is the socket handle */
1265         sock_reselect( sock );
1266         release_object( &sock->obj );
1267     }
1268 }
1269
1270 /* accept a socket into an initialized socket */
1271 DECL_HANDLER(accept_into_socket)
1272 {
1273     struct sock *sock, *acceptsock;
1274     const int all_attributes = FILE_READ_ATTRIBUTES|FILE_WRITE_ATTRIBUTES|FILE_READ_DATA;
1275
1276     if (!(sock = (struct sock *)get_handle_obj( current->process, req->lhandle,
1277                                                 all_attributes, &sock_ops)))
1278         return;
1279
1280     if (!(acceptsock = (struct sock *)get_handle_obj( current->process, req->ahandle,
1281                                                       all_attributes, &sock_ops)))
1282     {
1283         release_object( sock );
1284         return;
1285     }
1286
1287     if (accept_into_socket( sock, acceptsock ))
1288     {
1289         acceptsock->wparam = req->ahandle;  /* wparam for message is the socket handle */
1290         sock_reselect( acceptsock );
1291     }
1292     release_object( acceptsock );
1293     release_object( sock );
1294 }
1295
1296 /* set socket event parameters */
1297 DECL_HANDLER(set_socket_event)
1298 {
1299     struct sock *sock;
1300     struct event *old_event;
1301
1302     if (!(sock = (struct sock *)get_handle_obj( current->process, req->handle,
1303                                                 FILE_WRITE_ATTRIBUTES, &sock_ops))) return;
1304     if (get_unix_fd( sock->fd ) == -1) return;
1305     old_event = sock->event;
1306     sock->mask    = req->mask;
1307     sock->hmask   &= ~req->mask; /* re-enable held events */
1308     sock->event   = NULL;
1309     sock->window  = req->window;
1310     sock->message = req->msg;
1311     sock->wparam  = req->handle;  /* wparam is the socket handle */
1312     if (req->event) sock->event = get_event_obj( current->process, req->event, EVENT_MODIFY_STATE );
1313
1314     if (debug_level && sock->event) fprintf(stderr, "event ptr: %p\n", sock->event);
1315
1316     sock_reselect( sock );
1317
1318     sock->state |= FD_WINE_NONBLOCKING;
1319
1320     /* if a network event is pending, signal the event object
1321        it is possible that FD_CONNECT or FD_ACCEPT network events has happened
1322        before a WSAEventSelect() was done on it.
1323        (when dealing with Asynchronous socket)  */
1324     sock_wake_up( sock );
1325
1326     if (old_event) release_object( old_event ); /* we're through with it */
1327     release_object( &sock->obj );
1328 }
1329
1330 /* get socket event parameters */
1331 DECL_HANDLER(get_socket_event)
1332 {
1333     struct sock *sock;
1334
1335     if (!(sock = (struct sock *)get_handle_obj( current->process, req->handle,
1336                                                 FILE_READ_ATTRIBUTES, &sock_ops ))) return;
1337     if (get_unix_fd( sock->fd ) == -1) return;
1338     reply->mask  = sock->mask;
1339     reply->pmask = sock->pmask;
1340     reply->state = sock->state;
1341     set_reply_data( sock->errors, min( get_reply_max_size(), sizeof(sock->errors) ));
1342
1343     if (req->service)
1344     {
1345         if (req->c_event)
1346         {
1347             struct event *cevent = get_event_obj( current->process, req->c_event,
1348                                                   EVENT_MODIFY_STATE );
1349             if (cevent)
1350             {
1351                 reset_event( cevent );
1352                 release_object( cevent );
1353             }
1354         }
1355         sock->pmask = 0;
1356         sock_reselect( sock );
1357     }
1358     release_object( &sock->obj );
1359 }
1360
1361 /* re-enable pending socket events */
1362 DECL_HANDLER(enable_socket_event)
1363 {
1364     struct sock *sock;
1365
1366     if (!(sock = (struct sock*)get_handle_obj( current->process, req->handle,
1367                                                FILE_WRITE_ATTRIBUTES, &sock_ops)))
1368         return;
1369
1370     if (get_unix_fd( sock->fd ) == -1) return;
1371
1372     /* for event-based notification, windows erases stale events */
1373     sock->pmask &= ~req->mask;
1374
1375     sock->hmask &= ~req->mask;
1376     sock->state |= req->sstate;
1377     sock->state &= ~req->cstate;
1378     if ( sock->type != SOCK_STREAM ) sock->state &= ~STREAM_FLAG_MASK;
1379
1380     sock_reselect( sock );
1381
1382     release_object( &sock->obj );
1383 }
1384
1385 DECL_HANDLER(set_socket_deferred)
1386 {
1387     struct sock *sock, *acceptsock;
1388
1389     sock=(struct sock *)get_handle_obj( current->process, req->handle, FILE_WRITE_ATTRIBUTES, &sock_ops );
1390     if ( !sock )
1391         return;
1392
1393     acceptsock = (struct sock *)get_handle_obj( current->process, req->deferred, 0, &sock_ops );
1394     if ( !acceptsock )
1395     {
1396         release_object( sock );
1397         return;
1398     }
1399     sock->deferred = acceptsock;
1400     release_object( sock );
1401 }
1402
1403 DECL_HANDLER(get_socket_info)
1404 {
1405     struct sock *sock;
1406
1407     sock = (struct sock *)get_handle_obj( current->process, req->handle, FILE_READ_ATTRIBUTES, &sock_ops );
1408     if (!sock) return;
1409
1410     if (get_unix_fd( sock->fd ) == -1) return;
1411
1412     reply->family   = sock->family;
1413     reply->type     = sock->type;
1414     reply->protocol = sock->proto;
1415
1416     release_object( &sock->obj );
1417 }