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