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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #ifdef HAVE_SYS_ERRNO_H
  33 # include <sys/errno.h>
  34 #endif
  35 #include <sys/time.h>
  36 #include <sys/types.h>
  37 #ifdef HAVE_SYS_SOCKET_H
  38 # include <sys/socket.h>
  39 #endif
  40 #include <sys/ioctl.h>
  41 #ifdef HAVE_SYS_FILIO_H
  42 # include <sys/filio.h>
  43 #endif
  44 #include <time.h>
  45 #include <unistd.h>
  46
  47 #include "winerror.h"
  48 #include "winbase.h"
  49 #include "process.h"
  50 #include "handle.h"
  51 #include "thread.h"
  52 #include "request.h"
  53 #include "user.h"
  54 #include "async.h"
  55
  56 /* To avoid conflicts with the Unix socket headers. Plus we only need a few
  57  * macros anyway.
  58  */
  59 #define USE_WS_PREFIX
  60 #include "winsock2.h"
  61
  62 struct sock
  63 {
  64     struct object       obj;         /* object header */
  65     unsigned int        state;       /* status bits */
  66     unsigned int        mask;        /* event mask */
  67     unsigned int        hmask;       /* held (blocked) events */
  68     unsigned int        pmask;       /* pending events */
  69     unsigned int        flags;       /* socket flags */
  70     struct event       *event;       /* event object */
  71     user_handle_t       window;      /* window to send the message to */
  72     unsigned int        message;     /* message to send */
  73     unsigned int        wparam;      /* message wparam (socket handle) */
  74     int                 errors[FD_MAX_EVENTS]; /* event errors */
  75     struct async_queue  read_q;      /* Queue for asynchronous reads */
  76     struct async_queue  write_q;     /* Queue for asynchronous writes */
  77 };
  78
  79 static void sock_dump( struct object *obj, int verbose );
  80 static int sock_signaled( struct object *obj, struct thread *thread );
  81 static int sock_get_poll_events( struct object *obj );
  82 static void sock_poll_event( struct object *obj, int event );
  83 static int sock_get_fd( struct object *obj );
  84 static int sock_get_info( struct object *obj, struct get_file_info_reply *reply, int *flags );
  85 static void sock_destroy( struct object *obj );
  86 static int sock_get_error( int err );
  87 static void sock_set_error(void);
  88
  89 static const struct object_ops sock_ops =
  90 {
  91     sizeof(struct sock),          /* size */
  92     sock_dump,                    /* dump */
  93     add_queue,                    /* add_queue */
  94     remove_queue,                 /* remove_queue */
  95     sock_signaled,                /* signaled */
  96     no_satisfied,                 /* satisfied */
  97     sock_get_poll_events,         /* get_poll_events */
  98     sock_poll_event,              /* poll_event */
  99     sock_get_fd,                  /* get_fd */
 100     no_flush,                     /* flush */
 101     sock_get_info,                /* get_file_info */
 102     NULL,                         /* queue_async */
 103     sock_destroy                  /* destroy */
 104 };
 105
 106
 107 /* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which
 108  * we post messages if there are multiple events.  Used to send
 109  * messages.  The problem is if there is both a FD_CONNECT event and,
 110  * say, an FD_READ event available on the same socket, we want to
 111  * notify the app of the connect event first.  Otherwise it may
 112  * discard the read event because it thinks it hasn't connected yet.
 113  */
 114 static const int event_bitorder[FD_MAX_EVENTS] =
 115 {
 116     FD_CONNECT_BIT,
 117     FD_ACCEPT_BIT,
 118     FD_OOB_BIT,
 119     FD_WRITE_BIT,
 120     FD_READ_BIT,
 121     FD_CLOSE_BIT,
 122     6, 7, 8, 9  /* leftovers */
 123 };
 124
 125
 126 static void sock_reselect( struct sock *sock )
 127 {
 128     int ev = sock_get_poll_events( &sock->obj );
 129
 130     if (debug_level)
 131         fprintf(stderr,"sock_reselect(%d): new mask %x\n", sock->obj.fd, ev);
 132
 133     if (sock->obj.select == -1) {
 134         /* previously unconnected socket, is this reselect supposed to connect it? */
 135         if (!(sock->state & ~FD_WINE_NONBLOCKING)) return;
 136         /* ok, it is, attach it to the wineserver's main poll loop */
 137         add_select_user( &sock->obj );
 138     }
 139     /* update condition mask */
 140     set_select_events( &sock->obj, ev );
 141 }
 142
 143 /* wake anybody waiting on the socket event or send the associated message */
 144 static void sock_wake_up( struct sock *sock )
 145 {
 146     unsigned int events = sock->pmask & sock->mask;
 147     int i;
 148
 149     if (!events) return;
 150
 151     if (sock->event)
 152     {
 153         if (debug_level) fprintf(stderr, "signalling events %x ptr %p\n", events, sock->event );
 154         set_event( sock->event );
 155     }
 156     if (sock->window)
 157     {
 158         if (debug_level) fprintf(stderr, "signalling events %x win %x\n", events, sock->window );
 159         for (i = 0; i < FD_MAX_EVENTS; i++)
 160         {
 161             int event = event_bitorder[i];
 162             if (sock->pmask & (1 << event))
 163             {
 164                 unsigned int lparam = (1 << event) | (sock->errors[event] << 16);
 165                 post_message( sock->window, sock->message, sock->wparam, lparam );
 166             }
 167         }
 168         sock->pmask = 0;
 169         sock_reselect( sock );
 170     }
 171 }
 172
 173 inline static int sock_error(int s)
 174 {
 175     unsigned int optval = 0, optlen;
 176
 177     optlen = sizeof(optval);
 178     getsockopt(s, SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
 179     return optval ? sock_get_error(optval) : 0;
 180 }
 181
 182 static void sock_poll_event( struct object *obj, int event )
 183 {
 184     struct sock *sock = (struct sock *)obj;
 185
 186     assert( sock->obj.ops == &sock_ops );
 187     if (debug_level)
 188         fprintf(stderr, "socket %d select event: %x\n", sock->obj.fd, event);
 189     if (sock->state & FD_CONNECT)
 190     {
 191         /* connecting */
 192         if (event & POLLOUT)
 193         {
 194             /* we got connected */
 195             sock->state |= FD_WINE_CONNECTED|FD_READ|FD_WRITE;
 196             sock->state &= ~FD_CONNECT;
 197             sock->pmask |= FD_CONNECT;
 198             sock->errors[FD_CONNECT_BIT] = 0;
 199             if (debug_level)
 200                 fprintf(stderr, "socket %d connection success\n", sock->obj.fd);
 201         }
 202         else if (event & (POLLERR|POLLHUP))
 203         {
 204             /* we didn't get connected? */
 205             sock->state &= ~FD_CONNECT;
 206             sock->pmask |= FD_CONNECT;
 207             sock->errors[FD_CONNECT_BIT] = sock_error( sock->obj.fd );
 208             if (debug_level)
 209                 fprintf(stderr, "socket %d connection failure\n", sock->obj.fd);
 210         }
 211     } else
 212     if (sock->state & FD_WINE_LISTENING)
 213     {
 214         /* listening */
 215         if (event & POLLIN)
 216         {
 217             /* incoming connection */
 218             sock->pmask |= FD_ACCEPT;
 219             sock->errors[FD_ACCEPT_BIT] = 0;
 220             sock->hmask |= FD_ACCEPT;
 221         }
 222         else if (event & (POLLERR|POLLHUP))
 223         {
 224             /* failed incoming connection? */
 225             sock->pmask |= FD_ACCEPT;
 226             sock->errors[FD_ACCEPT_BIT] = sock_error( sock->obj.fd );
 227             sock->hmask |= FD_ACCEPT;
 228         }
 229     } else
 230     {
 231         /* normal data flow */
 232         if (event & POLLIN)
 233         {
 234             char dummy;
 235
 236             /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
 237              * has been closed, so we need to check for it explicitly here */
 238             if (!recv( sock->obj.fd, &dummy, 1, MSG_PEEK )) event = POLLHUP;
 239             else
 240             {
 241                 /* incoming data */
 242                 sock->pmask |= FD_READ;
 243                 sock->hmask |= FD_READ;
 244                 sock->errors[FD_READ_BIT] = 0;
 245                 if (debug_level)
 246                     fprintf(stderr, "socket %d is readable\n", sock->obj.fd );
 247             }
 248         }
 249         if (event & POLLOUT)
 250         {
 251             sock->pmask |= FD_WRITE;
 252             sock->hmask |= FD_WRITE;
 253             sock->errors[FD_WRITE_BIT] = 0;
 254             if (debug_level)
 255                 fprintf(stderr, "socket %d is writable\n", sock->obj.fd);
 256         }
 257         if (event & POLLPRI)
 258         {
 259             sock->pmask |= FD_OOB;
 260             sock->hmask |= FD_OOB;
 261             sock->errors[FD_OOB_BIT] = 0;
 262             if (debug_level)
 263                 fprintf(stderr, "socket %d got OOB data\n", sock->obj.fd);
 264         }
 265         if (((event & POLLERR) || ((event & (POLLIN|POLLHUP)) == POLLHUP))
 266             && (sock->state & (FD_READ|FD_WRITE))) {
 267             /* socket closing */
 268             sock->errors[FD_CLOSE_BIT] = sock_error( sock->obj.fd );
 269             sock->state &= ~(FD_WINE_CONNECTED|FD_READ|FD_WRITE);
 270             sock->pmask |= FD_CLOSE;
 271             if (debug_level)
 272                 fprintf(stderr, "socket %d aborted by error %d\n",
 273                         sock->obj.fd, sock->errors[FD_CLOSE_BIT]);
 274         }
 275     }
 276
 277     if (event & (POLLERR|POLLHUP))
 278         set_select_events( &sock->obj, -1 );
 279     else
 280         sock_reselect( sock );
 281
 282     /* wake up anyone waiting for whatever just happened */
 283     if (sock->pmask & sock->mask) sock_wake_up( sock );
 284
 285     /* if anyone is stupid enough to wait on the socket object itself,
 286      * maybe we should wake them up too, just in case? */
 287     wake_up( &sock->obj, 0 );
 288 }
 289
 290 static void sock_dump( struct object *obj, int verbose )
 291 {
 292     struct sock *sock = (struct sock *)obj;
 293     assert( obj->ops == &sock_ops );
 294     printf( "Socket fd=%d, state=%x, mask=%x, pending=%x, held=%x\n",
 295             sock->obj.fd, sock->state,
 296             sock->mask, sock->pmask, sock->hmask );
 297 }
 298
 299 static int sock_signaled( struct object *obj, struct thread *thread )
 300 {
 301     struct sock *sock = (struct sock *)obj;
 302     assert( obj->ops == &sock_ops );
 303
 304     return check_select_events( sock->obj.fd, sock_get_poll_events( &sock->obj ) );
 305 }
 306
 307 static int sock_get_poll_events( struct object *obj )
 308 {
 309     struct sock *sock = (struct sock *)obj;
 310     unsigned int mask = sock->mask & sock->state & ~sock->hmask;
 311     int ev = 0;
 312
 313     assert( obj->ops == &sock_ops );
 314
 315     if (sock->state & FD_CONNECT)
 316         /* connecting, wait for writable */
 317         return POLLOUT;
 318     if (sock->state & FD_WINE_LISTENING)
 319         /* listening, wait for readable */
 320         return (sock->hmask & FD_ACCEPT) ? 0 : POLLIN;
 321
 322     if (mask & FD_READ)  ev |= POLLIN | POLLPRI;
 323     if (mask & FD_WRITE) ev |= POLLOUT;
 324     return ev;
 325 }
 326
 327 static int sock_get_fd( struct object *obj )
 328 {
 329     struct sock *sock = (struct sock *)obj;
 330     assert( obj->ops == &sock_ops );
 331     return sock->obj.fd;
 332 }
 333
 334 static int sock_get_info( struct object *obj, struct get_file_info_reply *reply, int *flags )
 335 {
 336     struct sock *sock = (struct sock*) obj;
 337     assert ( obj->ops == &sock_ops );
 338
 339     if (reply)
 340     {
 341         reply->type        = FILE_TYPE_PIPE;
 342         reply->attr        = 0;
 343         reply->access_time = 0;
 344         reply->write_time  = 0;
 345         reply->size_high   = 0;
 346         reply->size_low    = 0;
 347         reply->links       = 0;
 348         reply->index_high  = 0;
 349         reply->index_low   = 0;
 350         reply->serial      = 0;
 351     }
 352     *flags = 0;
 353     if (sock->flags & WSA_FLAG_OVERLAPPED) *flags |= FD_FLAG_OVERLAPPED;
 354     return FD_TYPE_DEFAULT;
 355 }
 356
 357 static void sock_destroy( struct object *obj )
 358 {
 359     struct sock *sock = (struct sock *)obj;
 360     assert( obj->ops == &sock_ops );
 361
 362     /* FIXME: special socket shutdown stuff? */
 363
 364     if ( sock->flags & WSA_FLAG_OVERLAPPED )
 365     {
 366         destroy_async_queue ( &sock->read_q );
 367         destroy_async_queue ( &sock->write_q );
 368     }
 369     if (sock->event) release_object( sock->event );
 370 }
 371
 372 /* create a new and unconnected socket */
 373 static struct object *create_socket( int family, int type, int protocol, unsigned int flags )
 374 {
 375     struct sock *sock;
 376     int sockfd;
 377
 378     sockfd = socket( family, type, protocol );
 379     if (debug_level)
 380         fprintf(stderr,"socket(%d,%d,%d)=%d\n",family,type,protocol,sockfd);
 381     if (sockfd == -1) {
 382         sock_set_error();
 383         return NULL;
 384     }
 385     fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
 386     if (!(sock = alloc_object( &sock_ops, -1 ))) return NULL;
 387     sock->obj.fd = sockfd;
 388     sock->state = (type != SOCK_STREAM) ? (FD_READ|FD_WRITE) : 0;
 389     sock->mask    = 0;
 390     sock->hmask   = 0;
 391     sock->pmask   = 0;
 392     sock->flags   = flags;
 393     sock->event   = NULL;
 394     sock->window  = 0;
 395     sock->message = 0;
 396     sock->wparam  = 0;
 397     sock_reselect( sock );
 398     clear_error();
 399     if (sock->flags & WSA_FLAG_OVERLAPPED)
 400     {
 401         init_async_queue (&sock->read_q);
 402         init_async_queue (&sock->write_q);
 403     }
 404     return &sock->obj;
 405 }
 406
 407 /* accept a socket (creates a new fd) */
 408 static struct sock *accept_socket( handle_t handle )
 409 {
 410     struct sock *acceptsock;
 411     struct sock *sock;
 412     int acceptfd;
 413     struct sockaddr     saddr;
 414     int                 slen;
 415
 416     sock=(struct sock*)get_handle_obj(current->process,handle,
 417                                       GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,&sock_ops);
 418     if (!sock)
 419         return NULL;
 420     /* Try to accept(2). We can't be safe that this an already connected socket
 421      * or that accept() is allowed on it. In those cases we will get -1/errno
 422      * return.
 423      */
 424     slen = sizeof(saddr);
 425     acceptfd = accept(sock->obj.fd,&saddr,&slen);
 426     if (acceptfd==-1) {
 427         sock_set_error();
 428         release_object( sock );
 429         return NULL;
 430     }
 431     if (!(acceptsock = alloc_object( &sock_ops, -1 )))
 432     {
 433         release_object( sock );
 434         return NULL;
 435     }
 436
 437     /* newly created socket gets the same properties of the listening socket */
 438     fcntl(acceptfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
 439     acceptsock->obj.fd = acceptfd;
 440     acceptsock->state  = FD_WINE_CONNECTED|FD_READ|FD_WRITE;
 441     if (sock->state & FD_WINE_NONBLOCKING)
 442         acceptsock->state |= FD_WINE_NONBLOCKING;
 443     acceptsock->mask    = sock->mask;
 444     acceptsock->hmask   = 0;
 445     acceptsock->pmask   = 0;
 446     acceptsock->event   = NULL;
 447     acceptsock->window  = sock->window;
 448     acceptsock->message = sock->message;
 449     acceptsock->wparam  = 0;
 450     if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
 451     acceptsock->flags = sock->flags;
 452     if ( acceptsock->flags & WSA_FLAG_OVERLAPPED )
 453     {
 454         init_async_queue ( &acceptsock->read_q );
 455         init_async_queue ( &acceptsock->write_q );
 456     }
 457
 458     clear_error();
 459     sock->pmask &= ~FD_ACCEPT;
 460     sock->hmask &= ~FD_ACCEPT;
 461     sock_reselect( sock );
 462     release_object( sock );
 463     return acceptsock;
 464 }
 465
 466 /* set the last error depending on errno */
 467 static int sock_get_error( int err )
 468 {
 469     switch (err)
 470     {
 471         case EINTR:             return WSAEINTR; break;
 472         case EBADF:             return WSAEBADF; break;
 473         case EPERM:
 474         case EACCES:            return WSAEACCES; break;
 475         case EFAULT:            return WSAEFAULT; break;
 476         case EINVAL:            return WSAEINVAL; break;
 477         case EMFILE:            return WSAEMFILE; break;
 478         case EWOULDBLOCK:       return WSAEWOULDBLOCK; break;
 479         case EINPROGRESS:       return WSAEINPROGRESS; break;
 480         case EALREADY:          return WSAEALREADY; break;
 481         case ENOTSOCK:          return WSAENOTSOCK; break;
 482         case EDESTADDRREQ:      return WSAEDESTADDRREQ; break;
 483         case EMSGSIZE:          return WSAEMSGSIZE; break;
 484         case EPROTOTYPE:        return WSAEPROTOTYPE; break;
 485         case ENOPROTOOPT:       return WSAENOPROTOOPT; break;
 486         case EPROTONOSUPPORT:   return WSAEPROTONOSUPPORT; break;
 487         case ESOCKTNOSUPPORT:   return WSAESOCKTNOSUPPORT; break;
 488         case EOPNOTSUPP:        return WSAEOPNOTSUPP; break;
 489         case EPFNOSUPPORT:      return WSAEPFNOSUPPORT; break;
 490         case EAFNOSUPPORT:      return WSAEAFNOSUPPORT; break;
 491         case EADDRINUSE:        return WSAEADDRINUSE; break;
 492         case EADDRNOTAVAIL:     return WSAEADDRNOTAVAIL; break;
 493         case ENETDOWN:          return WSAENETDOWN; break;
 494         case ENETUNREACH:       return WSAENETUNREACH; break;
 495         case ENETRESET:         return WSAENETRESET; break;
 496         case ECONNABORTED:      return WSAECONNABORTED; break;
 497         case EPIPE:
 498         case ECONNRESET:        return WSAECONNRESET; break;
 499         case ENOBUFS:           return WSAENOBUFS; break;
 500         case EISCONN:           return WSAEISCONN; break;
 501         case ENOTCONN:          return WSAENOTCONN; break;
 502         case ESHUTDOWN:         return WSAESHUTDOWN; break;
 503         case ETOOMANYREFS:      return WSAETOOMANYREFS; break;
 504         case ETIMEDOUT:         return WSAETIMEDOUT; break;
 505         case ECONNREFUSED:      return WSAECONNREFUSED; break;
 506         case ELOOP:             return WSAELOOP; break;
 507         case ENAMETOOLONG:      return WSAENAMETOOLONG; break;
 508         case EHOSTDOWN:         return WSAEHOSTDOWN; break;
 509         case EHOSTUNREACH:      return WSAEHOSTUNREACH; break;
 510         case ENOTEMPTY:         return WSAENOTEMPTY; break;
 511 #ifdef EPROCLIM
 512         case EPROCLIM:          return WSAEPROCLIM; break;
 513 #endif
 514 #ifdef EUSERS
 515         case EUSERS:            return WSAEUSERS; break;
 516 #endif
 517 #ifdef EDQUOT
 518         case EDQUOT:            return WSAEDQUOT; break;
 519 #endif
 520 #ifdef ESTALE
 521         case ESTALE:            return WSAESTALE; break;
 522 #endif
 523 #ifdef EREMOTE
 524         case EREMOTE:           return WSAEREMOTE; break;
 525 #endif
 526     default: errno=err; perror("sock_set_error"); return ERROR_UNKNOWN; break;
 527     }
 528 }
 529
 530 /* set the last error depending on errno */
 531 static void sock_set_error(void)
 532 {
 533     set_error( sock_get_error( errno ) );
 534 }
 535
 536 /* create a socket */
 537 DECL_HANDLER(create_socket)
 538 {
 539     struct object *obj;
 540
 541     reply->handle = 0;
 542     if ((obj = create_socket( req->family, req->type, req->protocol, req->flags )) != NULL)
 543     {
 544         reply->handle = alloc_handle( current->process, obj, req->access, req->inherit );
 545         release_object( obj );
 546     }
 547 }
 548
 549 /* accept a socket */
 550 DECL_HANDLER(accept_socket)
 551 {
 552     struct sock *sock;
 553
 554     reply->handle = 0;
 555     if ((sock = accept_socket( req->lhandle )) != NULL)
 556     {
 557         reply->handle = alloc_handle( current->process, &sock->obj, req->access, req->inherit );
 558         sock->wparam = reply->handle;  /* wparam for message is the socket handle */
 559         sock_reselect( sock );
 560         release_object( &sock->obj );
 561     }
 562 }
 563
 564 /* set socket event parameters */
 565 DECL_HANDLER(set_socket_event)
 566 {
 567     struct sock *sock;
 568     struct event *old_event;
 569
 570     if (!(sock = (struct sock*)get_handle_obj( current->process, req->handle,
 571                                                GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE, &sock_ops)))
 572         return;
 573     old_event = sock->event;
 574     sock->mask    = req->mask;
 575     sock->event   = NULL;
 576     sock->window  = req->window;
 577     sock->message = req->msg;
 578     sock->wparam  = req->handle;  /* wparam is the socket handle */
 579     if (req->event) sock->event = get_event_obj( current->process, req->event, EVENT_MODIFY_STATE );
 580
 581     if (debug_level && sock->event) fprintf(stderr, "event ptr: %p\n", sock->event);
 582     sock_reselect( sock );
 583     if (sock->mask)
 584         sock->state |= FD_WINE_NONBLOCKING;
 585
 586     /* if a network event is pending, signal the event object
 587        it is possible that FD_CONNECT or FD_ACCEPT network events has happened
 588        before a WSAEventSelect() was done on it.
 589        (when dealing with Asynchronous socket)  */
 590     if (sock->pmask & sock->mask) sock_wake_up( sock );
 591
 592     if (old_event) release_object( old_event ); /* we're through with it */
 593     release_object( &sock->obj );
 594 }
 595
 596 /* get socket event parameters */
 597 DECL_HANDLER(get_socket_event)
 598 {
 599     struct sock *sock;
 600
 601     sock=(struct sock*)get_handle_obj(current->process,req->handle,GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,&sock_ops);
 602     if (!sock)
 603     {
 604         reply->mask  = 0;
 605         reply->pmask = 0;
 606         reply->state = 0;
 607         set_error( WSAENOTSOCK );
 608         return;
 609     }
 610     reply->mask  = sock->mask;
 611     reply->pmask = sock->pmask;
 612     reply->state = sock->state;
 613     set_reply_data( sock->errors, min( get_reply_max_size(), sizeof(sock->errors) ));
 614
 615     if (req->service)
 616     {
 617         if (req->c_event)
 618         {
 619             struct event *cevent = get_event_obj( current->process, req->c_event,
 620                                                   EVENT_MODIFY_STATE );
 621             if (cevent)
 622             {
 623                 reset_event( cevent );
 624                 release_object( cevent );
 625             }
 626         }
 627         sock->pmask = 0;
 628         sock_reselect( sock );
 629     }
 630     release_object( &sock->obj );
 631 }
 632
 633 /* re-enable pending socket events */
 634 DECL_HANDLER(enable_socket_event)
 635 {
 636     struct sock *sock;
 637
 638     if (!(sock = (struct sock*)get_handle_obj( current->process, req->handle,
 639                                                GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE, &sock_ops)))
 640         return;
 641
 642     sock->pmask &= ~req->mask; /* is this safe? */
 643     sock->hmask &= ~req->mask;
 644     sock->state |= req->sstate;
 645     sock->state &= ~req->cstate;
 646     sock_reselect( sock );
 647     release_object( &sock->obj );
 648 }