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