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