libjava/gnu/java/net/natPlainSocketImplPosix.cc

   1 /* Copyright (C) 2003, 2004, 2005, 2006, 2007  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 #ifdef HAVE_SYS_IOCTL_H
  13 #define BSD_COMP /* Get FIONREAD on Solaris2. */
  14 #include <sys/ioctl.h>
  15 #endif
  16
  17 // Pick up FIONREAD on Solaris 2.5.
  18 #ifdef HAVE_SYS_FILIO_H
  19 #include <sys/filio.h>
  20 #endif
  21
  22 #include <netinet/in.h>
  23 #include <netinet/tcp.h>
  24 #include <errno.h>
  25 #include <string.h>
  26
  27 #if HAVE_BSTRING_H
  28 // Needed for bzero, implicitly used by FD_ZERO on IRIX 5.2
  29 #include <bstring.h>
  30 #endif
  31
  32 #include <gcj/cni.h>
  33 #include <gcj/javaprims.h>
  34 #include <gnu/java/net/PlainSocketImpl.h>
  35 #include <gnu/java/net/PlainSocketImpl$SocketInputStream.h>
  36 #include <gnu/java/net/PlainSocketImpl$SocketOutputStream.h>
  37 #include <java/io/IOException.h>
  38 #include <java/io/InterruptedIOException.h>
  39 #include <java/net/BindException.h>
  40 #include <java/net/ConnectException.h>
  41 #include <java/net/InetAddress.h>
  42 #include <java/net/InetSocketAddress.h>
  43 #include <java/net/SocketException.h>
  44 #include <java/net/SocketTimeoutException.h>
  45 #include <java/lang/InternalError.h>
  46 #include <java/lang/Object.h>
  47 #include <java/lang/Boolean.h>
  48 #include <java/lang/Class.h>
  49 #include <java/lang/Integer.h>
  50 #include <java/lang/Thread.h>
  51 #include <java/lang/NullPointerException.h>
  52 #include <java/lang/ArrayIndexOutOfBoundsException.h>
  53 #include <java/lang/IllegalArgumentException.h>
  54 #include <java/net/UnknownHostException.h>
  55
  56 union SockAddr
  57 {
  58   struct sockaddr_in address;
  59 #ifdef HAVE_INET6
  60   struct sockaddr_in6 address6;
  61 #endif
  62 };
  63
  64 void
  65 gnu::java::net::PlainSocketImpl::create (jboolean stream)
  66 {
  67   int sock = _Jv_socket (AF_INET, stream ? SOCK_STREAM : SOCK_DGRAM, 0);
  68
  69   if (sock < 0)
  70     {
  71       char* strerr = strerror (errno);
  72       throw new ::java::io::IOException (JvNewStringUTF (strerr));
  73     }
  74
  75   // We use native_fd in place of fd here.  From leaving fd null we avoid
  76   // the double close problem in FileDescriptor.finalize.
  77   native_fd = sock;
  78 }
  79
  80 void
  81 gnu::java::net::PlainSocketImpl::bind (::java::net::InetAddress *host, jint lport)
  82 {
  83   union SockAddr u;
  84   struct sockaddr *ptr = (struct sockaddr *) &u.address;
  85   jbyteArray haddress = host->addr;
  86   jbyte *bytes = elements (haddress);
  87   int len = haddress->length;
  88   int i = 1;
  89
  90   // The following is needed for OS X/PPC, otherwise bind() fails with an
  91   // error. I found the issue and following fix on some mailing list, but
  92   // no explanation was given as to why this solved the problem.
  93   memset (&u, 0, sizeof (u));
  94
  95   if (len == 4)
  96     {
  97       u.address.sin_family = AF_INET;
  98
  99       if (host != NULL)
 100         memcpy (&u.address.sin_addr, bytes, len);
 101       else
 102         u.address.sin_addr.s_addr = htonl (INADDR_ANY);
 103
 104       len = sizeof (struct sockaddr_in);
 105       u.address.sin_port = htons (lport);
 106     }
 107 #ifdef HAVE_INET6
 108   else if (len == 16)
 109     {
 110       u.address6.sin6_family = AF_INET6;
 111       memcpy (&u.address6.sin6_addr, bytes, len);
 112       len = sizeof (struct sockaddr_in6);
 113       u.address6.sin6_port = htons (lport);
 114     }
 115 #endif
 116   else
 117     throw new ::java::net::SocketException (JvNewStringUTF ("invalid length"));
 118
 119   // Enable SO_REUSEADDR, so that servers can reuse ports left in TIME_WAIT.
 120   ::setsockopt(native_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &i, sizeof(i));
 121
 122   if (_Jv_bind (native_fd, ptr, len) == 0)
 123     {
 124       socklen_t addrlen = sizeof(u);
 125
 126       if (lport != 0)
 127         localport = lport;
 128       else if (::getsockname (native_fd, (sockaddr*) &u, &addrlen) == 0)
 129         localport = ntohs (u.address.sin_port);
 130       else
 131         goto error;
 132
 133       return;
 134     }
 135
 136  error:
 137   char* strerr = strerror (errno);
 138   throw new ::java::net::BindException (JvNewStringUTF (strerr));
 139 }
 140
 141 void
 142 gnu::java::net::PlainSocketImpl::connect (::java::net::SocketAddress *addr,
 143                                           jint timeout)
 144 {
 145   ::java::net::InetSocketAddress *tmp = (::java::net::InetSocketAddress*) addr;
 146   ::java::net::InetAddress *host = tmp->getAddress();
 147   if (! host)
 148     throw new ::java::net::UnknownHostException(tmp->toString());
 149
 150   jint rport = tmp->getPort();
 151
 152   // Set the SocketImpl's address and port fields before we try to
 153   // connect.  Note that the fact that these are set doesn't imply
 154   // that we're actually connected to anything.  We need to record
 155   // this data before we attempt the connect, since non-blocking
 156   // SocketChannels will use this and almost certainly throw timeout
 157   // exceptions.
 158   address = host;
 159   port = rport;
 160
 161   union SockAddr u;
 162   socklen_t addrlen = sizeof(u);
 163   jbyteArray haddress = host->addr;
 164   jbyte *bytes = elements (haddress);
 165   int len = haddress->length;
 166   struct sockaddr *ptr = (struct sockaddr *) &u.address;
 167   if (len == 4)
 168     {
 169       u.address.sin_family = AF_INET;
 170       memcpy (&u.address.sin_addr, bytes, len);
 171       len = sizeof (struct sockaddr_in);
 172       u.address.sin_port = htons (rport);
 173     }
 174 #ifdef HAVE_INET6
 175   else if (len == 16)
 176     {
 177       u.address6.sin6_family = AF_INET6;
 178       memcpy (&u.address6.sin6_addr, bytes, len);
 179       len = sizeof (struct sockaddr_in6);
 180       u.address6.sin6_port = htons (rport);
 181     }
 182 #endif
 183   else
 184     throw new ::java::net::SocketException (JvNewStringUTF ("invalid length"));
 185
 186   if (timeout > 0)
 187     {
 188       int flags = ::fcntl (native_fd, F_GETFL);
 189       ::fcntl (native_fd, F_SETFL, flags | O_NONBLOCK);
 190
 191       if ((_Jv_connect (native_fd, ptr, len) != 0) && (errno != EINPROGRESS))
 192         goto error;
 193
 194       fd_set fset;
 195       struct timeval tv;
 196       FD_ZERO(&fset);
 197       FD_SET(native_fd, &fset);
 198       tv.tv_sec = timeout / 1000;
 199       tv.tv_usec = (timeout % 1000) * 1000;
 200       int retval;
 201
 202       if ((retval = _Jv_select (native_fd + 1, &fset, &fset, NULL, &tv)) < 0)
 203         goto error;
 204       else if (retval == 0)
 205         throw new ::java::net::SocketTimeoutException
 206           (JvNewStringUTF ("Connect timed out"));
 207        // Set the socket back into a blocking state.
 208        ::fcntl (native_fd, F_SETFL, flags);
 209     }
 210   else
 211     {
 212       if (_Jv_connect (native_fd, ptr, len) != 0)
 213         goto error;
 214     }
 215
 216   // A bind may not have been done on this socket; if so, set localport now.
 217   if (localport == 0)
 218     {
 219       if (::getsockname (native_fd, (sockaddr*) &u, &addrlen) == 0)
 220         localport = ntohs (u.address.sin_port);
 221       else
 222         goto error;
 223     }
 224
 225   return;
 226
 227  error:
 228   char* strerr = strerror (errno);
 229   throw new ::java::net::ConnectException (JvNewStringUTF (strerr));
 230 }
 231
 232 void
 233 gnu::java::net::PlainSocketImpl::listen (jint backlog)
 234 {
 235   if (::listen (native_fd, backlog) != 0)
 236     {
 237       char* strerr = strerror (errno);
 238       throw new ::java::io::IOException (JvNewStringUTF (strerr));
 239     }
 240 }
 241
 242 static void
 243 throw_on_sock_closed (gnu::java::net::PlainSocketImpl *soc_impl)
 244 {
 245     // Avoid races from asynchronous close().
 246     JvSynchronize sync (soc_impl);
 247     if (soc_impl->native_fd == -1)
 248       {
 249         using namespace java::net;
 250         // Socket was closed.
 251         SocketException *se =
 252             new SocketException (JvNewStringUTF ("Socket Closed"));
 253         throw se;
 254       }
 255 }
 256
 257 void
 258 gnu::java::net::PlainSocketImpl::accept (gnu::java::net::PlainSocketImpl *s)
 259 {
 260   union SockAddr u;
 261   socklen_t addrlen = sizeof(u);
 262   int new_socket = 0;
 263
 264   // Do timeouts via select since SO_RCVTIMEO is not always available.
 265   if (timeout > 0 && native_fd >= 0 && native_fd < FD_SETSIZE)
 266     {
 267       fd_set fset;
 268       struct timeval tv;
 269       FD_ZERO(&fset);
 270       FD_SET(native_fd, &fset);
 271       tv.tv_sec = timeout / 1000;
 272       tv.tv_usec = (timeout % 1000) * 1000;
 273       int retval;
 274       if ((retval = _Jv_select (native_fd + 1, &fset, &fset, NULL, &tv)) < 0)
 275         goto error;
 276       else if (retval == 0)
 277         throw new ::java::net::SocketTimeoutException (
 278                                           JvNewStringUTF("Accept timed out"));
 279     }
 280
 281   new_socket = _Jv_accept (native_fd, (sockaddr*) &u, &addrlen);
 282
 283   if (new_socket < 0)
 284     goto error;
 285
 286   jbyteArray raddr;
 287   jint rport;
 288   if (u.address.sin_family == AF_INET)
 289     {
 290       raddr = JvNewByteArray (4);
 291       memcpy (elements (raddr), &u.address.sin_addr, 4);
 292       rport = ntohs (u.address.sin_port);
 293     }
 294 #ifdef HAVE_INET6
 295   else if (u.address.sin_family == AF_INET6)
 296     {
 297       raddr = JvNewByteArray (16);
 298       memcpy (elements (raddr), &u.address6.sin6_addr, 16);
 299       rport = ntohs (u.address6.sin6_port);
 300     }
 301 #endif
 302   else
 303     throw new ::java::net::SocketException (JvNewStringUTF ("invalid family"));
 304
 305   s->native_fd = new_socket;
 306   s->localport = localport;
 307   s->address = ::java::net::InetAddress::getByAddress (raddr);
 308   s->port = rport;
 309   return;
 310
 311  error:
 312   char* strerr = strerror (errno);
 313   throw_on_sock_closed (this);
 314   throw new ::java::io::IOException (JvNewStringUTF (strerr));
 315 }
 316
 317 // Close(shutdown) the socket.
 318 void
 319 gnu::java::net::PlainSocketImpl::close()
 320 {
 321   // Avoid races from asynchronous finalization.
 322   JvSynchronize sync (this);
 323
 324   // Should we use shutdown here? Yes.
 325   // How would that effect so_linger? Uncertain.
 326   ::shutdown (native_fd, 2);
 327   // Ignore errors in shutdown as we are closing and all the same
 328   // errors are handled in the close.
 329   int res = _Jv_close (native_fd);
 330
 331   if (res == -1)
 332     {
 333       // These three errors are not errors according to tests performed
 334       // on the reference implementation.
 335       if (errno != ENOTCONN && errno != ECONNRESET && errno != EBADF)
 336         throw new ::java::io::IOException  (JvNewStringUTF (strerror (errno)));
 337     }
 338   // Safe place to reset the file pointer.
 339   native_fd = -1;
 340   timeout = 0;
 341 }
 342
 343 static void
 344 write_helper (jint native_fd, jbyte *bytes, jint len);
 345
 346 // Write a byte to the socket.
 347 void
 348 gnu::java::net::PlainSocketImpl$SocketOutputStream::write(jint b)
 349 {
 350   jbyte data = (jbyte) b;
 351   write_helper (this$0->native_fd, &data, 1);
 352 }
 353
 354 // Write some bytes to the socket.
 355 void
 356 gnu::java::net::PlainSocketImpl$SocketOutputStream::write(jbyteArray b, jint offset, jint len)
 357 {
 358   if (! b)
 359     throw new ::java::lang::NullPointerException;
 360   if (offset < 0 || len < 0 || offset + len > JvGetArrayLength (b))
 361     throw new ::java::lang::ArrayIndexOutOfBoundsException;
 362
 363   write_helper (this$0->native_fd, elements (b) + offset, len);
 364 }
 365
 366 static void
 367 write_helper(jint native_fd, jbyte *bytes, jint len)
 368 {
 369   int written = 0;
 370
 371   while (len > 0)
 372     {
 373       int r = _Jv_write (native_fd, bytes, len);
 374
 375       if (r == -1)
 376         {
 377           if (::java::lang::Thread::interrupted())
 378             {
 379               ::java::io::InterruptedIOException *iioe
 380                 = new ::java::io::InterruptedIOException
 381                 (JvNewStringLatin1 (strerror (errno)));
 382               iioe->bytesTransferred = written;
 383               throw iioe;
 384             }
 385           // Some errors should not cause exceptions.
 386           if (errno != ENOTCONN && errno != ECONNRESET && errno != EBADF)
 387             throw new ::java::io::IOException (JvNewStringUTF (strerror (errno)));
 388           break;
 389         }
 390
 391       written += r;
 392       len -= r;
 393       bytes += r;
 394     }
 395 }
 396
 397 void
 398 gnu::java::net::PlainSocketImpl::sendUrgentData (jint)
 399 {
 400   throw new ::java::net::SocketException (JvNewStringLatin1 (
 401     "PlainSocketImpl: sending of urgent data not supported by this socket"));
 402 }
 403
 404 static jint
 405 read_helper (gnu::java::net::PlainSocketImpl *soc_impl,
 406              jbyte *bytes, jint count);
 407
 408 // Read a single byte from the socket.
 409 jint
 410 gnu::java::net::PlainSocketImpl$SocketInputStream::read(void)
 411 {
 412   jbyte data;
 413
 414   if (read_helper (this$0, &data, 1) == 1)
 415     return data & 0xFF;
 416
 417   return -1;
 418 }
 419
 420 // Read count bytes into the buffer, starting at offset.
 421 jint
 422 gnu::java::net::PlainSocketImpl$SocketInputStream::read(jbyteArray buffer,
 423                                                         jint offset,
 424                                                         jint count)
 425 {
 426  if (! buffer)
 427     throw new ::java::lang::NullPointerException;
 428
 429   jsize bsize = JvGetArrayLength (buffer);
 430
 431   if (offset < 0 || count < 0 || offset + count > bsize)
 432     throw new ::java::lang::ArrayIndexOutOfBoundsException;
 433
 434   return read_helper (this$0, elements (buffer) + offset, count);
 435 }
 436
 437 static jint
 438 read_helper (gnu::java::net::PlainSocketImpl *soc_impl,
 439              jbyte *bytes, jint count)
 440 {
 441   // If zero bytes were requested, short circuit so that recv
 442   // doesn't signal EOF.
 443   if (count == 0)
 444     return 0;
 445
 446   // Do timeouts via select.
 447   if (soc_impl->timeout > 0
 448       && soc_impl->native_fd >= 0
 449       && soc_impl->native_fd < FD_SETSIZE)
 450     {
 451       // Create the file descriptor set.
 452       fd_set read_fds;
 453       FD_ZERO (&read_fds);
 454       FD_SET (soc_impl->native_fd, &read_fds);
 455       // Create the timeout struct based on our internal timeout value.
 456       struct timeval timeout_value;
 457       timeout_value.tv_sec = soc_impl->timeout / 1000;
 458       timeout_value.tv_usec =(soc_impl->timeout % 1000) * 1000;
 459       // Select on the fds.
 460       int sel_retval =
 461         _Jv_select (soc_impl->native_fd + 1,
 462                     &read_fds, NULL, NULL, &timeout_value);
 463       // We're only interested in the 0 return.
 464       // error returns still require us to try to read
 465       // the socket to see what happened.
 466       if (sel_retval == 0)
 467         {
 468           ::java::net::SocketTimeoutException *timeoutException =
 469             new ::java::net::SocketTimeoutException
 470             (JvNewStringUTF ("Read timed out"));
 471           throw timeoutException;
 472         }
 473     }
 474
 475   // Read the socket.
 476   int r = ::recv (soc_impl->native_fd, (char *) bytes, count, 0);
 477
 478   if (r == 0)
 479     {
 480       throw_on_sock_closed (soc_impl);
 481       return -1;
 482     }
 483
 484   if (::java::lang::Thread::interrupted())
 485     {
 486       ::java::io::InterruptedIOException *iioe =
 487         new ::java::io::InterruptedIOException
 488         (JvNewStringUTF ("Read interrupted"));
 489       iioe->bytesTransferred = r == -1 ? 0 : r;
 490       throw iioe;
 491     }
 492   else if (r == -1)
 493     {
 494       throw_on_sock_closed (soc_impl);
 495       // Some errors cause us to return end of stream...
 496       if (errno == ENOTCONN)
 497         return -1;
 498
 499       // Other errors need to be signalled.
 500       throw new ::java::io::IOException (JvNewStringUTF (strerror (errno)));
 501     }
 502
 503   return r;
 504 }
 505
 506 // How many bytes are available?
 507 jint
 508 gnu::java::net::PlainSocketImpl::available(void)
 509 {
 510 #if defined(FIONREAD) || defined(HAVE_SELECT)
 511   int num = 0;
 512   int r = 0;
 513   bool num_set = false;
 514
 515 #if defined(FIONREAD)
 516   r = ::ioctl (native_fd, FIONREAD, &num);
 517
 518   if (r == -1 && errno == ENOTTY)
 519     {
 520       // If the ioctl doesn't work, we don't care.
 521       r = 0;
 522       num = 0;
 523     }
 524   else
 525     num_set = true;
 526 #elif defined(HAVE_SELECT)
 527   if (native_fd < 0)
 528     {
 529       errno = EBADF;
 530       r = -1;
 531     }
 532 #endif
 533
 534   if (r == -1)
 535     {
 536     posix_error:
 537       throw new ::java::io::IOException(JvNewStringUTF(strerror(errno)));
 538     }
 539
 540   // If we didn't get anything we can use select.
 541
 542 #if defined(HAVE_SELECT)
 543   if (! num_set)
 544     if (! num_set && native_fd >= 0 && native_fd < FD_SETSIZE)
 545       {
 546         fd_set rd;
 547         FD_ZERO (&rd);
 548         FD_SET (native_fd, &rd);
 549         struct timeval tv;
 550         tv.tv_sec = 0;
 551         tv.tv_usec = 0;
 552         r = _Jv_select (native_fd + 1, &rd, NULL, NULL, &tv);
 553         if(r == -1)
 554           goto posix_error;
 555         num = r == 0 ? 0 : 1;
 556       }
 557 #endif /* HAVE_SELECT */
 558
 559   return (jint) num;
 560 #else
 561   throw new ::java::io::IOException (JvNewStringUTF ("unimplemented"));
 562 #endif
 563 }
 564
 565 void
 566 gnu::java::net::PlainSocketImpl::setOption (jint optID, ::java::lang::Object *value)
 567 {
 568   int val;
 569   socklen_t val_len = sizeof (val);
 570
 571   if (native_fd < 0)
 572     throw new ::java::net::SocketException (JvNewStringUTF ("Socket closed"));
 573
 574   if (_Jv_IsInstanceOf (value, &::java::lang::Boolean::class$))
 575     {
 576       ::java::lang::Boolean *boolobj =
 577         static_cast< ::java::lang::Boolean *> (value);
 578       if (boolobj->booleanValue())
 579         val = 1;
 580       else
 581         {
 582           if (optID == _Jv_SO_LINGER_)
 583             val = -1;
 584           else
 585             val = 0;
 586         }
 587     }
 588   else if (_Jv_IsInstanceOf (value, &::java::lang::Integer::class$))
 589     {
 590       ::java::lang::Integer *intobj =
 591         static_cast< ::java::lang::Integer *> (value);
 592       val = (int) intobj->intValue();
 593     }
 594   else
 595     {
 596       throw new ::java::lang::IllegalArgumentException (
 597         JvNewStringLatin1 ("`value' must be Boolean or Integer"));
 598     }
 599
 600   switch (optID)
 601     {
 602       case _Jv_TCP_NODELAY_ :
 603 #ifdef TCP_NODELAY
 604         if (::setsockopt (native_fd, IPPROTO_TCP, TCP_NODELAY, (char *) &val,
 605                           val_len) != 0)
 606           goto error;
 607 #else
 608         throw new ::java::lang::InternalError
 609           (JvNewStringUTF ("TCP_NODELAY not supported"));
 610 #endif /* TCP_NODELAY */
 611         return;
 612
 613       case _Jv_SO_KEEPALIVE_ :
 614         if (::setsockopt (native_fd, SOL_SOCKET, SO_KEEPALIVE, (char *) &val,
 615                           val_len) != 0)
 616           goto error;
 617         return;
 618
 619       case _Jv_SO_BROADCAST_ :
 620         throw new ::java::net::SocketException
 621           (JvNewStringUTF ("SO_BROADCAST not valid for TCP"));
 622         return;
 623
 624       case _Jv_SO_OOBINLINE_ :
 625         if (::setsockopt (native_fd, SOL_SOCKET, SO_OOBINLINE, (char *) &val,
 626                           val_len) != 0)
 627           goto error;
 628         return;
 629
 630       case _Jv_SO_LINGER_ :
 631 #ifdef SO_LINGER
 632         struct linger l_val;
 633         l_val.l_onoff = (val != -1);
 634         l_val.l_linger = val;
 635
 636         if (::setsockopt (native_fd, SOL_SOCKET, SO_LINGER, (char *) &l_val,
 637                           sizeof(l_val)) != 0)
 638           goto error;
 639 #else
 640         throw new ::java::lang::InternalError (
 641           JvNewStringUTF ("SO_LINGER not supported"));
 642 #endif /* SO_LINGER */
 643         return;
 644
 645       case _Jv_SO_SNDBUF_ :
 646       case _Jv_SO_RCVBUF_ :
 647 #if defined(SO_SNDBUF) && defined(SO_RCVBUF)
 648         int opt;
 649         optID == _Jv_SO_SNDBUF_ ? opt = SO_SNDBUF : opt = SO_RCVBUF;
 650         if (::setsockopt (native_fd, SOL_SOCKET, opt, (char *) &val, val_len) != 0)
 651           goto error;
 652 #else
 653         throw new ::java::lang::InternalError (
 654           JvNewStringUTF ("SO_RCVBUF/SO_SNDBUF not supported"));
 655 #endif
 656         return;
 657
 658       case _Jv_SO_BINDADDR_ :
 659         throw new ::java::net::SocketException (
 660           JvNewStringUTF ("SO_BINDADDR: read only option"));
 661         return;
 662
 663       case _Jv_IP_MULTICAST_IF_ :
 664         throw new ::java::net::SocketException (
 665           JvNewStringUTF ("IP_MULTICAST_IF: not valid for TCP"));
 666         return;
 667
 668       case _Jv_IP_MULTICAST_IF2_ :
 669         throw new ::java::net::SocketException (
 670           JvNewStringUTF ("IP_MULTICAST_IF2: not valid for TCP"));
 671         return;
 672
 673       case _Jv_IP_MULTICAST_LOOP_ :
 674         throw new ::java::net::SocketException (
 675           JvNewStringUTF ("IP_MULTICAST_LOOP: not valid for TCP"));
 676         return;
 677
 678       case _Jv_IP_TOS_ :
 679         if (::setsockopt (native_fd, SOL_SOCKET, IP_TOS, (char *) &val,
 680                           val_len) != 0)
 681           goto error;
 682         return;
 683
 684       case _Jv_SO_REUSEADDR_ :
 685 #if defined(SO_REUSEADDR)
 686         if (::setsockopt (native_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &val,
 687             val_len) != 0)
 688           goto error;
 689         return;
 690 #else
 691         throw new ::java::lang::InternalError (
 692           JvNewStringUTF ("SO_REUSEADDR not supported"));
 693 #endif
 694
 695       case _Jv_SO_TIMEOUT_ :
 696         timeout = val;
 697         return;
 698
 699       default :
 700         errno = ENOPROTOOPT;
 701     }
 702
 703  error:
 704   char* strerr = strerror (errno);
 705   throw new ::java::net::SocketException (JvNewStringUTF (strerr));
 706 }
 707
 708 ::java::lang::Object *
 709 gnu::java::net::PlainSocketImpl::getOption (jint optID)
 710 {
 711   int val;
 712   socklen_t val_len = sizeof(val);
 713   union SockAddr u;
 714   socklen_t addrlen = sizeof(u);
 715   struct linger l_val;
 716   socklen_t l_val_len = sizeof(l_val);
 717
 718   switch (optID)
 719     {
 720 #ifdef TCP_NODELAY
 721     case _Jv_TCP_NODELAY_ :
 722       if (::getsockopt (native_fd, IPPROTO_TCP, TCP_NODELAY, (char *) &val,
 723                         &val_len) != 0)
 724         goto error;
 725       else
 726         return new ::java::lang::Boolean (val != 0);
 727 #else
 728       throw new ::java::lang::InternalError
 729         (JvNewStringUTF ("TCP_NODELAY not supported"));
 730 #endif
 731       break;
 732
 733     case _Jv_SO_LINGER_ :
 734 #ifdef SO_LINGER
 735       if (::getsockopt (native_fd, SOL_SOCKET, SO_LINGER, (char *) &l_val,
 736                         &l_val_len) != 0)
 737         goto error;
 738
 739       if (l_val.l_onoff)
 740         return new ::java::lang::Integer (l_val.l_linger);
 741       else
 742         return new ::java::lang::Boolean ((jboolean)false);
 743 #else
 744       throw new ::java::lang::InternalError
 745         (JvNewStringUTF ("SO_LINGER not supported"));
 746 #endif
 747       break;
 748
 749     case _Jv_SO_KEEPALIVE_ :
 750       if (::getsockopt (native_fd, SOL_SOCKET, SO_KEEPALIVE, (char *) &val,
 751                         &val_len) != 0)
 752         goto error;
 753       else
 754         return new ::java::lang::Boolean (val != 0);
 755
 756     case _Jv_SO_BROADCAST_ :
 757       if (::getsockopt (native_fd, SOL_SOCKET, SO_BROADCAST, (char *) &val,
 758                         &val_len) != 0)
 759         goto error;
 760       return new ::java::lang::Boolean ((jboolean)val);
 761
 762     case _Jv_SO_OOBINLINE_ :
 763       if (::getsockopt (native_fd, SOL_SOCKET, SO_OOBINLINE, (char *) &val,
 764                         &val_len) != 0)
 765         goto error;
 766       return new ::java::lang::Boolean ((jboolean)val);
 767
 768     case _Jv_SO_RCVBUF_ :
 769     case _Jv_SO_SNDBUF_ :
 770 #if defined(SO_SNDBUF) && defined(SO_RCVBUF)
 771       int opt;
 772       optID == _Jv_SO_SNDBUF_ ? opt = SO_SNDBUF : opt = SO_RCVBUF;
 773       if (::getsockopt (native_fd, SOL_SOCKET, opt, (char *) &val, &val_len) != 0)
 774         goto error;
 775       else
 776         return new ::java::lang::Integer (val);
 777 #else
 778       throw new ::java::lang::InternalError
 779         (JvNewStringUTF ("SO_RCVBUF/SO_SNDBUF not supported"));
 780 #endif
 781       break;
 782     case _Jv_SO_BINDADDR_:
 783       // cache the local address
 784       if (localAddress == NULL)
 785         {
 786           jbyteArray laddr;
 787
 788           if (::getsockname (native_fd, (sockaddr*) &u, &addrlen) != 0)
 789             goto error;
 790
 791           if (u.address.sin_family == AF_INET)
 792             {
 793               laddr = JvNewByteArray (4);
 794               memcpy (elements (laddr), &u.address.sin_addr, 4);
 795             }
 796 #ifdef HAVE_INET6
 797           else if (u.address.sin_family == AF_INET6)
 798             {
 799               laddr = JvNewByteArray (16);
 800               memcpy (elements (laddr), &u.address6.sin6_addr, 16);
 801             }
 802 #endif
 803           else
 804             throw new ::java::net::SocketException
 805               (JvNewStringUTF ("invalid family"));
 806           localAddress = ::java::net::InetAddress::getByAddress (laddr);
 807         }
 808
 809       return localAddress;
 810       break;
 811     case _Jv_IP_MULTICAST_IF_ :
 812       throw new ::java::net::SocketException
 813         (JvNewStringUTF ("IP_MULTICAST_IF: not valid for TCP"));
 814       break;
 815
 816     case _Jv_IP_MULTICAST_IF2_ :
 817       throw new ::java::net::SocketException
 818         (JvNewStringUTF ("IP_MULTICAST_IF2: not valid for TCP"));
 819       break;
 820
 821     case _Jv_IP_MULTICAST_LOOP_ :
 822       throw new ::java::net::SocketException
 823         (JvNewStringUTF ("IP_MULTICAST_LOOP: not valid for TCP"));
 824       break;
 825
 826     case _Jv_IP_TOS_ :
 827       if (::getsockopt (native_fd, SOL_SOCKET, IP_TOS, (char *) &val,
 828                         &val_len) != 0)
 829         goto error;
 830       return new ::java::lang::Integer (val);
 831       break;
 832
 833     case _Jv_SO_REUSEADDR_ :
 834 #if defined(SO_REUSEADDR)
 835       if (::getsockopt (native_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &val,
 836                         &val_len) != 0)
 837         goto error;
 838 #else
 839         throw new ::java::lang::InternalError (
 840           JvNewStringUTF ("SO_REUSEADDR not supported"));
 841 #endif
 842       break;
 843
 844     case _Jv_SO_TIMEOUT_ :
 845       return new ::java::lang::Integer (timeout);
 846       break;
 847
 848     default :
 849       errno = ENOPROTOOPT;
 850     }
 851
 852  error:
 853   char* strerr = strerror (errno);
 854   throw new ::java::net::SocketException (JvNewStringUTF (strerr));
 855 }
 856
 857 void
 858 gnu::java::net::PlainSocketImpl::shutdownInput (void)
 859 {
 860   if (::shutdown (native_fd, 0))
 861     throw new ::java::net::SocketException (JvNewStringUTF (strerror (errno)));
 862 }
 863
 864 void
 865 gnu::java::net::PlainSocketImpl::shutdownOutput (void)
 866 {
 867   if (::shutdown (native_fd, 1))
 868     throw new ::java::net::SocketException (JvNewStringUTF (strerror (errno)));
 869 }