libjava/java/net/natPlainSocketImpl.cc

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