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