old-autovect-branch/libjava/gnu/java/net/natPlainSocketImplWin32.cc

   1 /* Copyright (C) 2003, 2004, 2005 Free Software Foundation
   2
   3    This file is part of libgcj.
   4
   5 This software is copyrighted work licensed under the terms of the
   6 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   7 details.  */
   8
   9 #include <config.h>
  10 #include <platform.h>
  11
  12 #undef STRICT
  13 #undef MAX_PRIORITY
  14 #undef MIN_PRIORITY
  15
  16 #include <gnu/java/net/PlainSocketImpl.h>
  17 #include <gnu/java/net/PlainSocketImpl$SocketInputStream.h>
  18 #include <gnu/java/net/PlainSocketImpl$SocketOutputStream.h>
  19 #include <java/io/IOException.h>
  20 #include <java/net/BindException.h>
  21 #include <java/net/ConnectException.h>
  22 #include <java/net/InetAddress.h>
  23 #include <java/net/InetSocketAddress.h>
  24 #include <java/net/SocketException.h>
  25 #include <java/net/SocketTimeoutException.h>
  26 #include <java/lang/InternalError.h>
  27 #include <java/lang/Object.h>
  28 #include <java/lang/Boolean.h>
  29 #include <java/lang/Class.h>
  30 #include <java/lang/Integer.h>
  31 #include <java/lang/Thread.h>
  32 #include <java/lang/NullPointerException.h>
  33 #include <java/lang/ArrayIndexOutOfBoundsException.h>
  34 #include <java/lang/IllegalArgumentException.h>
  35
  36 union SockAddr
  37 {
  38   struct sockaddr_in address;
  39 #ifdef HAVE_INET6
  40   struct sockaddr_in6 address6;
  41 #endif
  42 };
  43
  44 void
  45 gnu::java::net::PlainSocketImpl::create (jboolean stream)
  46 {
  47   SOCKET sock = ::socket (AF_INET, stream ? SOCK_STREAM : SOCK_DGRAM, 0);
  48
  49   if (sock == INVALID_SOCKET)
  50     {
  51       _Jv_ThrowIOException ();
  52     }
  53
  54   // Cast this to a HANDLE so we can make
  55   // it non-inheritable via _Jv_platform_close_on_exec.
  56   HANDLE hSocket = (HANDLE) sock;
  57   _Jv_platform_close_on_exec (hSocket);
  58
  59   // We use native_fd in place of fd here.  From leaving fd null we avoid
  60   // the double close problem in FileDescriptor.finalize.
  61   native_fd = (jint) hSocket;
  62 }
  63
  64 void
  65 gnu::java::net::PlainSocketImpl::bind (::java::net::InetAddress *host, jint lport)
  66 {
  67   union SockAddr u;
  68   struct sockaddr *ptr = (struct sockaddr *) &u.address;
  69   jbyteArray haddress = host->addr;
  70   jbyte *bytes = elements (haddress);
  71   int len = haddress->length;
  72
  73   if (len == 4)
  74     {
  75       u.address.sin_family = AF_INET;
  76
  77       if (host != NULL)
  78         memcpy (&u.address.sin_addr, bytes, len);
  79       else
  80         u.address.sin_addr.s_addr = htonl (INADDR_ANY);
  81
  82       len = sizeof (struct sockaddr_in);
  83       u.address.sin_port = htons (lport);
  84     }
  85 #ifdef HAVE_INET6
  86   else if (len == 16)
  87     {
  88       u.address6.sin6_family = AF_INET6;
  89       memcpy (&u.address6.sin6_addr, bytes, len);
  90       len = sizeof (struct sockaddr_in6);
  91       u.address6.sin6_port = htons (lport);
  92     }
  93 #endif
  94   else
  95     throw new ::java::net::SocketException (JvNewStringUTF ("invalid length"));
  96
  97   if (::bind (native_fd, ptr, len) != SOCKET_ERROR)
  98     {
  99       socklen_t addrlen = sizeof(u);
 100
 101       if (lport != 0)
 102         localport = lport;
 103       else if (::getsockname (native_fd, (sockaddr*) &u, &addrlen) != SOCKET_ERROR)
 104         localport = ntohs (u.address.sin_port);
 105       else
 106         goto error;
 107
 108       return;
 109     }
 110
 111 error:
 112   DWORD dwErrorCode = WSAGetLastError ();
 113   throw new ::java::net::BindException (_Jv_WinStrError (dwErrorCode));
 114 }
 115
 116 static void
 117 throwConnectException (DWORD dwErrorCode)
 118 {
 119   throw new ::java::net::ConnectException (_Jv_WinStrError (dwErrorCode));
 120 }
 121
 122 static void
 123 throwConnectException ()
 124 {
 125   throwConnectException (WSAGetLastError ());
 126 }
 127
 128 void
 129 gnu::java::net::PlainSocketImpl::connect (::java::net::SocketAddress *addr,
 130                                      jint timeout)
 131 {
 132   ::java::net::InetSocketAddress *tmp = (::java::net::InetSocketAddress*) addr;
 133   ::java::net::InetAddress *host = tmp->getAddress();
 134   jint rport = tmp->getPort();
 135
 136   union SockAddr u;
 137   socklen_t addrlen = sizeof(u);
 138   jbyteArray haddress = host->addr;
 139   jbyte *bytes = elements (haddress);
 140   int len = haddress->length;
 141   struct sockaddr *ptr = (struct sockaddr *) &u.address;
 142
 143   if (len == 4)
 144     {
 145       u.address.sin_family = AF_INET;
 146       memcpy (&u.address.sin_addr, bytes, len);
 147       len = sizeof (struct sockaddr_in);
 148       u.address.sin_port = htons (rport);
 149     }
 150 #ifdef HAVE_INET6
 151   else if (len == 16)
 152     {
 153       u.address6.sin6_family = AF_INET6;
 154       memcpy (&u.address6.sin6_addr, bytes, len);
 155       len = sizeof (struct sockaddr_in6);
 156       u.address6.sin6_port = htons (rport);
 157     }
 158 #endif
 159   else
 160     throw new ::java::net::SocketException (JvNewStringUTF ("invalid length"));
 161
 162   if (timeout > 0)
 163     {
 164       // FIXME: we're creating a fresh WSAEVENT for each connect().
 165       WSAEventWrapper aWSAEventWrapper(native_fd, FD_CONNECT);
 166       WSAEVENT hEvent = aWSAEventWrapper.getEventHandle ();
 167
 168       if (::connect (native_fd, ptr, len) == SOCKET_ERROR)
 169       {
 170         if (WSAGetLastError () != WSAEWOULDBLOCK)
 171           throwConnectException ();
 172
 173         DWORD dwRet =
 174           WSAWaitForMultipleEvents (1, &hEvent, true, timeout, false);
 175             // use true, false instead of TRUE, FALSE because the
 176             // MS constants got undefined
 177
 178         // Reset and ignore our thread's interrupted flag.
 179         // It's not possible to interrupt these sort of
 180         // operations on Win32 anyway.
 181         ::java::lang::Thread::interrupted();
 182
 183         if (dwRet == WSA_WAIT_FAILED)
 184           throwConnectException ();
 185         else if (dwRet == WSA_WAIT_TIMEOUT)
 186           throw new ::java::net::SocketTimeoutException
 187             (JvNewStringUTF ("connect timed out"));
 188
 189         // If we get here, we still need to check whether the actual
 190         // connect() succeeded. Use any socket-specific error code
 191         // instead of the thread-based one.
 192         int nErrCode; int nErrLen=sizeof(nErrCode);
 193         if (::getsockopt(native_fd, SOL_SOCKET, SO_ERROR, (char*) &nErrCode,
 194           &nErrLen) == SOCKET_ERROR)
 195           {
 196             throwConnectException ();
 197           }
 198
 199         if (nErrCode != NO_ERROR)
 200           {
 201             throwConnectException (nErrCode);
 202           }
 203       }
 204     }
 205   else
 206     {
 207       if (::connect (native_fd, ptr, len) == SOCKET_ERROR)
 208         throwConnectException();
 209     }
 210
 211   address = host;
 212   port = rport;
 213
 214   // A bind may not have been done on this socket; if so, set localport now.
 215   if (localport == 0)
 216     {
 217       if (::getsockname (native_fd, (sockaddr*) &u, &addrlen) != SOCKET_ERROR)
 218         localport = ntohs (u.address.sin_port);
 219       else
 220         throwConnectException();
 221     }
 222 }
 223
 224 void
 225 gnu::java::net::PlainSocketImpl::listen (jint backlog)
 226 {
 227   if (::listen (native_fd, backlog) == SOCKET_ERROR)
 228     {
 229       _Jv_ThrowIOException ();
 230     }
 231 }
 232
 233 void
 234 gnu::java::net::PlainSocketImpl::accept (gnu::java::net::PlainSocketImpl *s)
 235 {
 236   union SockAddr u;
 237   socklen_t addrlen = sizeof(u);
 238   HANDLE hSocket = 0;
 239   SOCKET new_socket = 0;
 240
 241   if (timeout > 0)
 242     {
 243       // FIXME: we're creating a fresh WSAEVENT for each accept().
 244       // One possible alternative would be that native_fd really points
 245       // to an extended structure consisting of the SOCKET, its
 246       // associated WSAEVENT, etc.
 247       WSAEventWrapper aWSAEventWrapper(native_fd, FD_ACCEPT);
 248       WSAEVENT hEvent = aWSAEventWrapper.getEventHandle ();
 249
 250       for (;;)
 251       {
 252         new_socket = ::accept (native_fd, (sockaddr*) &u, &addrlen);
 253
 254         if (new_socket != INVALID_SOCKET)
 255         {
 256           // This new child socket is nonblocking because the parent
 257           // socket became nonblocking via the WSAEventSelect() call,
 258           // so we set its mode back to blocking.
 259           WSAEventSelect (new_socket, hEvent, 0);
 260             // undo the hEvent <-> FD_ACCEPT association inherited
 261             // inherited from our parent socket
 262
 263           unsigned long lSockOpt = 0L;
 264             // blocking mode
 265           if (ioctlsocket(new_socket, FIONBIO, &lSockOpt) == SOCKET_ERROR)
 266           {
 267             goto error;
 268           }
 269           break;
 270         }
 271         else if (WSAGetLastError () != WSAEWOULDBLOCK)
 272           {
 273             goto error;
 274           }
 275
 276         DWORD dwRet =
 277           WSAWaitForMultipleEvents (1, &hEvent, true, timeout, false);
 278             // use true, false instead of TRUE, FALSE because the
 279             // MS constants got undefined
 280
 281         // Reset and ignore our thread's interrupted flag.
 282         ::java::lang::Thread::interrupted();
 283
 284         if (dwRet == WSA_WAIT_FAILED)
 285           goto error;
 286         else if (dwRet == WSA_WAIT_TIMEOUT)
 287           throw new ::java::net::SocketTimeoutException
 288             (JvNewStringUTF ("Accept timed out"));
 289       }
 290     }
 291   else
 292     {
 293       new_socket = ::accept (native_fd, (sockaddr*) &u, &addrlen);
 294     }
 295
 296   if (new_socket == INVALID_SOCKET)
 297     goto error;
 298
 299   // Cast this to a HANDLE so we can make
 300   // it non-inheritable via _Jv_platform_close_on_exec.
 301   hSocket = (HANDLE) new_socket;
 302   _Jv_platform_close_on_exec (hSocket);
 303
 304   jbyteArray raddr;
 305   jint rport;
 306   if (u.address.sin_family == AF_INET)
 307     {
 308       raddr = JvNewByteArray (4);
 309       memcpy (elements (raddr), &u.address.sin_addr, 4);
 310       rport = ntohs (u.address.sin_port);
 311     }
 312 #ifdef HAVE_INET6
 313   else if (u.address.sin_family == AF_INET6)
 314     {
 315       raddr = JvNewByteArray (16);
 316       memcpy (elements (raddr), &u.address6.sin6_addr, 16);
 317       rport = ntohs (u.address6.sin6_port);
 318     }
 319 #endif
 320   else
 321     throw new ::java::net::SocketException (JvNewStringUTF ("invalid family"));
 322
 323   s->native_fd = (jint) hSocket;
 324   s->localport = localport;
 325   s->address = new ::java::net::InetAddress (raddr, NULL);
 326   s->port = rport;
 327   return;
 328
 329  error:
 330   _Jv_ThrowIOException ();
 331 }
 332
 333 // Close(shutdown) the socket.
 334 void
 335 gnu::java::net::PlainSocketImpl::close()
 336 {
 337   // Avoid races from asynchronous finalization.
 338   JvSynchronize sync (this);
 339
 340   // should we use shutdown here? how would that effect so_linger?
 341   int res = ::closesocket (native_fd);
 342
 343   if (res == -1)
 344     {
 345       // These three errors are not errors according to tests performed
 346       // on the reference implementation.
 347       DWORD dwErr = WSAGetLastError();
 348       if (dwErr != WSAENOTCONN && dwErr != WSAECONNRESET
 349         && dwErr != WSAENOTSOCK)
 350         _Jv_ThrowIOException ();
 351     }
 352   // Safe place to reset the file pointer.
 353   native_fd = -1;
 354   timeout = 0;
 355 }
 356
 357 // Write a byte to the socket.
 358 void
 359 gnu::java::net::PlainSocketImpl$SocketOutputStream::write(jint b)
 360 {
 361   jbyte d =(jbyte) b;
 362   int r = 0;
 363
 364   while (r != 1)
 365     {
 366       r = ::send (this$0->native_fd, (char*) &d, 1, 0);
 367       if (r == -1)
 368         {
 369           DWORD dwErr = WSAGetLastError();
 370
 371           // Reset and ignore our thread's interrupted flag.
 372           // It's not possible to interrupt these sort of
 373           // operations on Win32 anyway.
 374           ::java::lang::Thread::interrupted();
 375
 376           // Some errors should not cause exceptions.
 377           if (dwErr != WSAENOTCONN && dwErr != WSAECONNRESET
 378             && dwErr != WSAENOTSOCK)
 379             _Jv_ThrowIOException ();
 380           break;
 381         }
 382     }
 383 }
 384
 385 // Write some bytes to the socket.
 386 void
 387 gnu::java::net::PlainSocketImpl$SocketOutputStream::write(jbyteArray b,
 388   jint offset, jint len)
 389 {
 390   if (! b)
 391     throw new ::java::lang::NullPointerException;
 392   if (offset < 0 || len < 0 || offset + len > JvGetArrayLength (b))
 393     throw new ::java::lang::ArrayIndexOutOfBoundsException;
 394
 395   jbyte *bytes = elements (b) + offset;
 396   int written = 0;
 397   while (len > 0)
 398     {
 399       int r = ::send (this$0->native_fd, (char*) bytes, len, 0);
 400
 401       if (r == -1)
 402         {
 403           DWORD dwErr = WSAGetLastError();
 404
 405           // Reset and ignore our thread's interrupted flag.
 406           ::java::lang::Thread::interrupted();
 407
 408           // Some errors should not cause exceptions.
 409           if (dwErr != WSAENOTCONN && dwErr != WSAECONNRESET
 410             && dwErr != WSAENOTSOCK)
 411             _Jv_ThrowIOException ();
 412           break;
 413         }
 414
 415       written += r;
 416       len -= r;
 417       bytes += r;
 418     }
 419 }
 420
 421 void
 422 gnu::java::net::PlainSocketImpl::sendUrgentData (jint)
 423 {
 424   throw new ::java::net::SocketException (JvNewStringLatin1 (
 425     "PlainSocketImpl: sending of urgent data not supported by this socket"));
 426 }
 427
 428 // read() helper
 429 static jint
 430 doRead(int native_fd, void* buf, int count, int timeout)
 431 {
 432   int r = 0;
 433   DWORD dwErrorCode = 0;
 434     // we are forced to declare this here because
 435     // a call to Thread::interrupted() blanks out
 436     // WSAGetLastError().
 437
 438   // FIXME: we unconditionally set SO_RCVTIMEO here
 439   // because we can't detect whether someone has
 440   // gone from a non-zero to zero timeout. What we'd
 441   // really need is a member state variable in addition
 442   // to timeout
 443   int nRet= ::setsockopt(native_fd, SOL_SOCKET, SO_RCVTIMEO,
 444     (char*)&timeout, sizeof(timeout));
 445   if (nRet != NO_ERROR)
 446   {
 447     dwErrorCode = WSAGetLastError ();
 448     goto error;
 449   }
 450
 451   r = ::recv (native_fd, (char*) buf, count, 0);
 452
 453   if (r == 0)
 454     return -1;
 455
 456   dwErrorCode = WSAGetLastError ();
 457     // save WSAGetLastError() before calling Thread.interrupted()
 458
 459   // Reset and ignore our thread's interrupted flag.
 460   ::java::lang::Thread::interrupted();
 461
 462   if (r == -1)
 463     {
 464 error:
 465       // Some errors cause us to return end of stream...
 466       if (dwErrorCode == WSAENOTCONN)
 467         return -1;
 468
 469       // Other errors need to be signalled.
 470       if (dwErrorCode == WSAETIMEDOUT)
 471         throw new ::java::net::SocketTimeoutException
 472           (JvNewStringUTF ("Read timed out") );
 473       else
 474         _Jv_ThrowIOException (dwErrorCode);
 475     }
 476
 477    return r;
 478 }
 479
 480 // Read a single byte from the socket.
 481 jint
 482 gnu::java::net::PlainSocketImpl$SocketInputStream::read(void)
 483 {
 484   jbyte b;
 485   doRead(this$0->native_fd, &b, 1, this$0->timeout);
 486   return b & 0xFF;
 487 }
 488
 489 // Read count bytes into the buffer, starting at offset.
 490 jint
 491 gnu::java::net::PlainSocketImpl$SocketInputStream::read(jbyteArray buffer,
 492   jint offset, jint count)
 493 {
 494   // If zero bytes were requested, short circuit so that recv
 495   // doesn't signal EOF.
 496   if (count == 0)
 497     return 0;
 498
 499   if (! buffer)
 500     throw new ::java::lang::NullPointerException;
 501
 502   jsize bsize = JvGetArrayLength (buffer);
 503
 504   if (offset < 0 || count < 0 || offset + count > bsize)
 505     throw new ::java::lang::ArrayIndexOutOfBoundsException;
 506
 507   jbyte *bytes = elements (buffer) + offset;
 508
 509   // Read the socket.
 510   return doRead(this$0->native_fd, bytes, count, this$0->timeout);
 511 }
 512
 513 // How many bytes are available?
 514 jint
 515 gnu::java::net::PlainSocketImpl::available(void)
 516 {
 517   unsigned long num = 0;
 518
 519   if (::ioctlsocket (native_fd, FIONREAD, &num) == SOCKET_ERROR)
 520     _Jv_ThrowIOException ();
 521
 522   return (jint) num;
 523 }
 524
 525 void
 526 gnu::java::net::PlainSocketImpl::setOption (jint optID, ::java::lang::Object *value)
 527 {
 528   int val;
 529   socklen_t val_len = sizeof (val);
 530
 531   if (native_fd < 0)
 532     throw new ::java::net::SocketException (JvNewStringUTF ("Socket closed"));
 533
 534   if (_Jv_IsInstanceOf (value, &::java::lang::Boolean::class$))
 535     {
 536       ::java::lang::Boolean *boolobj =
 537         static_cast< ::java::lang::Boolean *> (value);
 538       if (boolobj->booleanValue())
 539         val = 1;
 540       else
 541         {
 542           if (optID == _Jv_SO_LINGER_)
 543             val = -1;
 544           else
 545             val = 0;
 546         }
 547     }
 548   else if (_Jv_IsInstanceOf (value, &::java::lang::Integer::class$))
 549     {
 550       ::java::lang::Integer *intobj =
 551         static_cast< ::java::lang::Integer *> (value);
 552       val = (int) intobj->intValue();
 553     }
 554   else
 555     {
 556       throw new ::java::lang::IllegalArgumentException (
 557         JvNewStringLatin1 ("`value' must be Boolean or Integer"));
 558     }
 559
 560   switch (optID)
 561     {
 562       case _Jv_TCP_NODELAY_ :
 563         if (::setsockopt (native_fd, IPPROTO_TCP, TCP_NODELAY, (char *) &val,
 564                           val_len) == SOCKET_ERROR)
 565           goto error;
 566         return;
 567
 568       case _Jv_SO_KEEPALIVE_ :
 569         if (::setsockopt (native_fd, SOL_SOCKET, SO_KEEPALIVE, (char *) &val,
 570                           val_len) == SOCKET_ERROR)
 571           goto error;
 572         break;
 573
 574       case _Jv_SO_BROADCAST_ :
 575         throw new ::java::net::SocketException
 576           (JvNewStringUTF ("SO_BROADCAST not valid for TCP"));
 577         break;
 578
 579       case _Jv_SO_OOBINLINE_ :
 580         if (::setsockopt (native_fd, SOL_SOCKET, SO_OOBINLINE, (char *) &val,
 581                           val_len) == SOCKET_ERROR)
 582           goto error;
 583         break;
 584
 585       case _Jv_SO_LINGER_ :
 586         struct linger l_val;
 587         l_val.l_onoff = (val != -1);
 588         l_val.l_linger = val;
 589
 590         if (::setsockopt (native_fd, SOL_SOCKET, SO_LINGER, (char *) &l_val,
 591                           sizeof(l_val)) == SOCKET_ERROR)
 592           goto error;
 593         return;
 594
 595       case _Jv_SO_SNDBUF_ :
 596       case _Jv_SO_RCVBUF_ :
 597         int opt;
 598         optID == _Jv_SO_SNDBUF_ ? opt = SO_SNDBUF : opt = SO_RCVBUF;
 599         if (::setsockopt (native_fd, SOL_SOCKET, opt, (char *) &val,
 600                           val_len) == SOCKET_ERROR)
 601           goto error;
 602         return;
 603
 604       case _Jv_SO_BINDADDR_ :
 605         throw new ::java::net::SocketException (
 606           JvNewStringUTF ("SO_BINDADDR: read only option"));
 607         return;
 608
 609       case _Jv_IP_MULTICAST_IF_ :
 610         throw new ::java::net::SocketException (
 611           JvNewStringUTF ("IP_MULTICAST_IF: not valid for TCP"));
 612         return;
 613
 614       case _Jv_IP_MULTICAST_IF2_ :
 615         throw new ::java::net::SocketException (
 616           JvNewStringUTF ("IP_MULTICAST_IF2: not valid for TCP"));
 617         break;
 618
 619       case _Jv_IP_MULTICAST_LOOP_ :
 620         throw new ::java::net::SocketException (
 621           JvNewStringUTF ("IP_MULTICAST_LOOP: not valid for TCP"));
 622         break;
 623
 624       case _Jv_IP_TOS_ :
 625         if (::setsockopt (native_fd, SOL_SOCKET, IP_TOS, (char *) &val,
 626                           val_len) == SOCKET_ERROR)
 627           goto error;
 628         break;
 629
 630       case _Jv_SO_REUSEADDR_ :
 631         throw new ::java::net::SocketException (
 632           JvNewStringUTF ("SO_REUSEADDR: not valid for TCP"));
 633         return;
 634
 635       case _Jv_SO_TIMEOUT_ :
 636         timeout = val;
 637         return;
 638
 639       default :
 640         WSASetLastError (WSAENOPROTOOPT);
 641     }
 642
 643 error:
 644   _Jv_ThrowSocketException ();
 645 }
 646
 647 ::java::lang::Object *
 648 gnu::java::net::PlainSocketImpl::getOption (jint optID)
 649 {
 650   int val;
 651   socklen_t val_len = sizeof(val);
 652   union SockAddr u;
 653   socklen_t addrlen = sizeof(u);
 654   struct linger l_val;
 655   socklen_t l_val_len = sizeof(l_val);
 656
 657   switch (optID)
 658     {
 659     case _Jv_TCP_NODELAY_ :
 660       if (::getsockopt (native_fd, IPPROTO_TCP, TCP_NODELAY, (char *) &val,
 661                         &val_len) == SOCKET_ERROR)
 662         goto error;
 663       else
 664         return new ::java::lang::Boolean (val != 0);
 665       break;
 666
 667     case _Jv_SO_LINGER_ :
 668       if (::getsockopt (native_fd, SOL_SOCKET, SO_LINGER, (char *) &l_val,
 669                         &l_val_len) == SOCKET_ERROR)
 670         goto error;
 671
 672       if (l_val.l_onoff)
 673         return new ::java::lang::Integer (l_val.l_linger);
 674       else
 675         return new ::java::lang::Boolean ((jboolean)false);
 676       break;
 677
 678     case _Jv_SO_KEEPALIVE_ :
 679       if (::getsockopt (native_fd, SOL_SOCKET, SO_KEEPALIVE, (char *) &val,
 680                         &val_len) == SOCKET_ERROR)
 681         goto error;
 682       else
 683         return new ::java::lang::Boolean (val != 0);
 684
 685     case _Jv_SO_BROADCAST_ :
 686       if (::getsockopt (native_fd, SOL_SOCKET, SO_BROADCAST, (char *) &val,
 687                         &val_len) == SOCKET_ERROR)
 688         goto error;
 689       return new ::java::lang::Boolean ((jboolean)val);
 690
 691     case _Jv_SO_OOBINLINE_ :
 692       if (::getsockopt (native_fd, SOL_SOCKET, SO_OOBINLINE, (char *) &val,
 693                         &val_len) == SOCKET_ERROR)
 694         goto error;
 695       return new ::java::lang::Boolean ((jboolean)val);
 696
 697     case _Jv_SO_RCVBUF_ :
 698     case _Jv_SO_SNDBUF_ :
 699       int opt;
 700       optID == _Jv_SO_SNDBUF_ ? opt = SO_SNDBUF : opt = SO_RCVBUF;
 701       if (::getsockopt (native_fd, SOL_SOCKET, opt, (char *) &val,
 702                         &val_len) == SOCKET_ERROR)
 703         goto error;
 704       else
 705         return new ::java::lang::Integer (val);
 706       break;
 707     case _Jv_SO_BINDADDR_:
 708       // cache the local address
 709       if (localAddress == NULL)
 710         {
 711           jbyteArray laddr;
 712
 713           if (::getsockname (native_fd, (sockaddr*) &u,
 714                              &addrlen) == SOCKET_ERROR)
 715             goto error;
 716
 717           if (u.address.sin_family == AF_INET)
 718             {
 719               laddr = JvNewByteArray (4);
 720               memcpy (elements (laddr), &u.address.sin_addr, 4);
 721             }
 722 #ifdef HAVE_INET6
 723           else if (u.address.sin_family == AF_INET6)
 724             {
 725               laddr = JvNewByteArray (16);
 726               memcpy (elements (laddr), &u.address6.sin6_addr, 16);
 727             }
 728 #endif
 729           else
 730             throw new ::java::net::SocketException
 731               (JvNewStringUTF ("invalid family"));
 732           localAddress = new ::java::net::InetAddress (laddr, NULL);
 733         }
 734
 735       return localAddress;
 736       break;
 737     case _Jv_IP_MULTICAST_IF_ :
 738       throw new ::java::net::SocketException
 739         (JvNewStringUTF ("IP_MULTICAST_IF: not valid for TCP"));
 740       break;
 741
 742     case _Jv_IP_MULTICAST_IF2_ :
 743       throw new ::java::net::SocketException
 744         (JvNewStringUTF ("IP_MULTICAST_IF2: not valid for TCP"));
 745       break;
 746
 747     case _Jv_IP_MULTICAST_LOOP_ :
 748       throw new ::java::net::SocketException
 749         (JvNewStringUTF ("IP_MULTICAST_LOOP: not valid for TCP"));
 750       break;
 751
 752     case _Jv_IP_TOS_ :
 753       if (::getsockopt (native_fd, SOL_SOCKET, IP_TOS, (char *) &val,
 754                         &val_len) == SOCKET_ERROR)
 755         goto error;
 756       return new ::java::lang::Integer (val);
 757       break;
 758
 759     case _Jv_SO_REUSEADDR_ :
 760       throw new ::java::net::SocketException
 761         (JvNewStringUTF ("SO_REUSEADDR: not valid for TCP"));
 762       break;
 763
 764     case _Jv_SO_TIMEOUT_ :
 765       return new ::java::lang::Integer (timeout);
 766       break;
 767
 768     default :
 769       WSASetLastError (WSAENOPROTOOPT);
 770     }
 771
 772 error:
 773   _Jv_ThrowSocketException ();
 774   return 0;
 775     // we should never get here
 776 }
 777
 778 void
 779 gnu::java::net::PlainSocketImpl::shutdownInput (void)
 780 {
 781   if (::shutdown (native_fd, 0))
 782     _Jv_ThrowSocketException ();
 783 }
 784
 785 void
 786 gnu::java::net::PlainSocketImpl::shutdownOutput (void)
 787 {
 788   if (::shutdown (native_fd, 1))
 789     _Jv_ThrowSocketException ();
 790 }