old-autovect-branch/libjava/classpath/native/jni/java-net/javanet.c

   1 /* javanet.c - Common internal functions for the java.net package
   2    Copyright (C) 1998, 2002, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 /* do not move; needed here because of some macro definitions */
  39 #include <config.h>
  40
  41 #include <stdlib.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <assert.h>
  45
  46 #include <jni.h>
  47 #include <jcl.h>
  48
  49 #include "javanet.h"
  50
  51 #include "target_native.h"
  52 #ifndef WITHOUT_NETWORK
  53 #include "target_native_network.h"
  54 #endif /* WITHOUT_NETWORK */
  55
  56 #ifndef WITHOUT_NETWORK
  57 /* Need to have some value for SO_TIMEOUT */
  58 #ifndef SO_TIMEOUT
  59 #ifndef SO_RCVTIMEO
  60 #warning Neither SO_TIMEOUT or SO_RCVTIMEO are defined!
  61 #warning This will cause all get/setOption calls with that value to throw an exception
  62 #else
  63 #define SO_TIMEOUT SO_RCVTIMEO
  64 #endif /* not SO_RCVTIMEO */
  65 #endif /* not SO_TIMEOUT */
  66 #endif /* WITHOUT_NETWORK */
  67
  68 /*************************************************************************/
  69
  70 /*
  71  * Sets an integer field in the specified object.
  72  */
  73 static void
  74 _javanet_set_int_field (JNIEnv * env, jobject obj,
  75                         const char *class, const char *field, int val)
  76 {
  77   jclass cls;
  78   jfieldID fid;
  79
  80   assert (env != NULL);
  81   assert ((*env) != NULL);
  82
  83   cls = (*env)->FindClass (env, class);
  84   if (cls == NULL)
  85     return;
  86
  87   fid = (*env)->GetFieldID (env, cls, field, "I");
  88   if (fid == NULL)
  89     return;
  90
  91   (*env)->SetIntField (env, obj, fid, val);
  92
  93   return;
  94 }
  95
  96 /*************************************************************************/
  97
  98 /*
  99  * Returns the value of the specified integer instance variable field or
 100  * -1 if an error occurs.
 101  */
 102 int
 103 _javanet_get_int_field (JNIEnv * env, jobject obj, const char *field)
 104 {
 105   jclass cls = 0;
 106   jfieldID fid;
 107   int fd;
 108
 109   assert (env != NULL);
 110   assert ((*env) != NULL);
 111
 112   DBG ("_javanet_get_int_field(): Entered _javanet_get_int_field\n");
 113
 114   cls = (*env)->GetObjectClass (env, obj);
 115   if (cls == NULL)
 116     return -1;
 117
 118   fid = (*env)->GetFieldID (env, cls, field, "I");
 119   if (fid == NULL)
 120     return -1;
 121   DBG ("_javanet_get_int_field(): Found field id\n");
 122
 123   fd = (*env)->GetIntField (env, obj, fid);
 124
 125   return fd;
 126 }
 127
 128 /*************************************************************************/
 129
 130 /*
 131  * Creates a FileDescriptor object in the parent class.  It is not used
 132  * by this implementation, but the docs list it as a variable, so we
 133  * need to include it.
 134  */
 135 static void
 136 _javanet_create_localfd (JNIEnv * env, jobject this)
 137 {
 138   jclass this_cls, fd_cls;
 139   jfieldID fid;
 140   jmethodID mid;
 141   jobject fd_obj;
 142
 143   assert (env != NULL);
 144   assert ((*env) != NULL);
 145
 146   DBG ("_javanet_create_localfd(): Entered _javanet_create_localfd\n");
 147
 148   /* Look up the fd field */
 149   this_cls = (*env)->FindClass (env, "java/net/SocketImpl");
 150   if (this_cls == NULL)
 151     return;
 152
 153   fid = (*env)->GetFieldID (env, this_cls, "fd", "Ljava/io/FileDescriptor;");
 154   if (fid == NULL)
 155     return;
 156
 157   DBG ("_javanet_create_localfd(): Found fd variable\n");
 158
 159   /* Create a FileDescriptor */
 160   fd_cls = (*env)->FindClass (env, "java/io/FileDescriptor");
 161   if (fd_cls == NULL)
 162     return;
 163
 164   DBG ("_javanet_create_localfd(): Found FileDescriptor class\n");
 165
 166   mid = (*env)->GetMethodID (env, fd_cls, "<init>", "()V");
 167   if (mid == NULL)
 168     return;
 169
 170   DBG ("_javanet_create_localfd(): Found FileDescriptor constructor\n");
 171
 172   fd_obj = (*env)->NewObject (env, fd_cls, mid);
 173   if (fd_obj == NULL)
 174     return;
 175
 176   DBG ("_javanet_create_localfd(): Created FileDescriptor\n");
 177
 178   /* Now set the pointer to the new FileDescriptor */
 179   (*env)->SetObjectField (env, this, fid, fd_obj);
 180   DBG ("_javanet_create_localfd(): Set fd field\n");
 181
 182   return;
 183 }
 184
 185 /*************************************************************************/
 186
 187 /*
 188  * Returns a Boolean object with the specfied value
 189  */
 190 static jobject
 191 _javanet_create_boolean (JNIEnv * env, jboolean val)
 192 {
 193   jclass cls;
 194   jmethodID mid;
 195   jobject obj;
 196
 197   assert (env != NULL);
 198   assert ((*env) != NULL);
 199
 200   cls = (*env)->FindClass (env, "java/lang/Boolean");
 201   if (cls == NULL)
 202     return NULL;
 203
 204   mid = (*env)->GetMethodID (env, cls, "<init>", "(Z)V");
 205   if (mid == NULL)
 206     return NULL;
 207
 208   obj = (*env)->NewObject (env, cls, mid, val);
 209   if (obj == NULL)
 210     return NULL;
 211
 212   return obj;
 213 }
 214
 215 /*************************************************************************/
 216
 217 /*
 218  * Returns an Integer object with the specfied value
 219  */
 220 static jobject
 221 _javanet_create_integer (JNIEnv * env, jint val)
 222 {
 223   jclass cls;
 224   jmethodID mid;
 225   jobject obj;
 226
 227   assert (env != NULL);
 228   assert ((*env) != NULL);
 229
 230   cls = (*env)->FindClass (env, "java/lang/Integer");
 231   if (cls == NULL)
 232     return NULL;
 233
 234   mid = (*env)->GetMethodID (env, cls, "<init>", "(I)V");
 235   if (mid == NULL)
 236     return NULL;
 237
 238   obj = (*env)->NewObject (env, cls, mid, val);
 239   if (obj == NULL)
 240     return NULL;
 241
 242   return obj;
 243 }
 244
 245 /*************************************************************************/
 246
 247 /*
 248  * Builds an InetAddress object from a 32 bit address in host byte order
 249  */
 250 static jobject
 251 _javanet_create_inetaddress (JNIEnv * env, int netaddr)
 252 {
 253 #ifndef WITHOUT_NETWORK
 254   unsigned char octets[4];
 255   char buf[16];
 256   jclass ia_cls;
 257   jmethodID mid;
 258   jstring ip_str;
 259   jobject ia;
 260
 261   assert (env != NULL);
 262   assert ((*env) != NULL);
 263
 264   /* Build a string IP address */
 265   TARGET_NATIVE_NETWORK_INT_TO_IPADDRESS_BYTES (netaddr,
 266                                                 octets[0],
 267                                                 octets[1],
 268                                                 octets[2], octets[3]);
 269   sprintf (buf, "%d.%d.%d.%d", octets[0], octets[1], octets[2], octets[3]);
 270   DBG ("_javanet_create_inetaddress(): Created ip addr string\n");
 271
 272   /* Get an InetAddress object for this IP */
 273   ia_cls = (*env)->FindClass (env, "java/net/InetAddress");
 274   if (ia_cls == NULL)
 275     {
 276       return NULL;
 277     }
 278
 279   DBG ("_javanet_create_inetaddress(): Found InetAddress class\n");
 280
 281   mid = (*env)->GetStaticMethodID (env, ia_cls, "getByName",
 282                                    "(Ljava/lang/String;)Ljava/net/InetAddress;");
 283   if (mid == NULL)
 284     {
 285       return NULL;
 286     }
 287
 288   DBG ("_javanet_create_inetaddress(): Found getByName method\n");
 289
 290   ip_str = (*env)->NewStringUTF (env, buf);
 291   if (ip_str == NULL)
 292     {
 293       return NULL;
 294     }
 295
 296   ia = (*env)->CallStaticObjectMethod (env, ia_cls, mid, ip_str);
 297   if (ia == NULL)
 298     {
 299       return NULL;
 300     }
 301
 302   DBG ("_javanet_create_inetaddress(): Called getByName method\n");
 303
 304   return ia;
 305 #else /* not WITHOUT_NETWORK */
 306   return NULL;
 307 #endif /* not WITHOUT_NETWORK */
 308 }
 309
 310 /*************************************************************************/
 311
 312 static void
 313 _javanet_set_remhost_addr (JNIEnv * env, jobject this, jobject ia)
 314 {
 315   jclass this_cls;
 316   jfieldID fid;
 317
 318   assert (env != NULL);
 319   assert ((*env) != NULL);
 320
 321   /* Set the variable in the object */
 322   this_cls = (*env)->FindClass (env, "java/net/SocketImpl");
 323   if (this_cls == NULL)
 324     return;
 325
 326   fid =
 327     (*env)->GetFieldID (env, this_cls, "address", "Ljava/net/InetAddress;");
 328   if (fid == NULL)
 329     return;
 330
 331   DBG ("_javanet_set_remhost_addr(): Found address field\n");
 332
 333   (*env)->SetObjectField (env, this, fid, ia);
 334   DBG ("_javanet_set_remhost_addr(): Set field\n");
 335 }
 336
 337 /*
 338  * Set's the value of the "addr" field in PlainSocketImpl with a new
 339  * InetAddress for the specified addr
 340  */
 341 static void
 342 _javanet_set_remhost (JNIEnv * env, jobject this, int netaddr)
 343 {
 344   jobject ia;
 345
 346   assert (env != NULL);
 347   assert ((*env) != NULL);
 348
 349   DBG ("_javanet_set_remhost(): Entered _javanet_set_remhost\n");
 350
 351   /* Get an InetAddress object */
 352   ia = _javanet_create_inetaddress (env, netaddr);
 353   if (ia == NULL)
 354     return;
 355
 356   _javanet_set_remhost_addr (env, this, ia);
 357 }
 358
 359
 360 /*************************************************************************/
 361
 362 /*
 363  * Returns a 32 bit Internet address for the passed in InetAddress object
 364  */
 365 int
 366 _javanet_get_netaddr (JNIEnv * env, jobject addr)
 367 {
 368 #ifndef WITHOUT_NETWORK
 369   jclass cls = 0;
 370   jmethodID mid;
 371   jarray arr = 0;
 372   jbyte *octets;
 373   int netaddr, len;
 374
 375   assert (env != NULL);
 376   assert ((*env) != NULL);
 377
 378   DBG ("_javanet_get_netaddr(): Entered _javanet_get_netaddr\n");
 379
 380   if (addr == NULL)
 381     {
 382       JCL_ThrowException (env, "java/lang/NullPointerException",
 383                           "Null address");
 384       return 0;
 385     }
 386
 387   /* Call the getAddress method on the object to retrieve the IP address */
 388   cls = (*env)->GetObjectClass (env, addr);
 389   if (cls == NULL)
 390     return 0;
 391
 392   mid = (*env)->GetMethodID (env, cls, "getAddress", "()[B");
 393   if (mid == NULL)
 394     return 0;
 395
 396   DBG ("_javanet_get_netaddr(): Got getAddress method\n");
 397
 398   arr = (*env)->CallObjectMethod (env, addr, mid);
 399   if (arr == NULL)
 400     return 0;
 401
 402   DBG ("_javanet_get_netaddr(): Got the address\n");
 403
 404   /* Turn the IP address into a 32 bit Internet address in network byte order */
 405   len = (*env)->GetArrayLength (env, arr);
 406   if (len != 4)
 407     {
 408       JCL_ThrowException (env, IO_EXCEPTION, "Internal Error");
 409       return 0;
 410     }
 411   DBG ("_javanet_get_netaddr(): Length ok\n");
 412
 413   octets = (*env)->GetByteArrayElements (env, arr, 0);
 414   if (octets == NULL)
 415     return 0;
 416
 417   DBG ("_javanet_get_netaddr(): Grabbed bytes\n");
 418
 419   TARGET_NATIVE_NETWORK_IPADDRESS_BYTES_TO_INT (octets[0],
 420                                                 octets[1],
 421                                                 octets[2],
 422                                                 octets[3], netaddr);
 423
 424   (*env)->ReleaseByteArrayElements (env, arr, octets, 0);
 425   DBG ("_javanet_get_netaddr(): Done getting addr\n");
 426
 427   return netaddr;
 428 #else /* not WITHOUT_NETWORK */
 429 #endif /* not WITHOUT_NETWORK */
 430 }
 431
 432 /*************************************************************************/
 433
 434 /*
 435  * Creates a new stream or datagram socket
 436  */
 437 void
 438 _javanet_create (JNIEnv * env, jobject this, jboolean stream)
 439 {
 440 #ifndef WITHOUT_NETWORK
 441   int fd;
 442   int result;
 443
 444   assert (env != NULL);
 445   assert ((*env) != NULL);
 446
 447   if (stream)
 448     {
 449       /* create a stream socket */
 450       TARGET_NATIVE_NETWORK_SOCKET_OPEN_STREAM (fd, result);
 451       if (result != TARGET_NATIVE_OK)
 452         {
 453           JCL_ThrowException (env, IO_EXCEPTION,
 454                               TARGET_NATIVE_LAST_ERROR_STRING ());
 455           return;
 456         }
 457     }
 458   else
 459     {
 460       /* create a datagram socket, set broadcast option */
 461       TARGET_NATIVE_NETWORK_SOCKET_OPEN_DATAGRAM (fd, result);
 462       if (result != TARGET_NATIVE_OK)
 463         {
 464           JCL_ThrowException (env, IO_EXCEPTION,
 465                               TARGET_NATIVE_LAST_ERROR_STRING ());
 466           return;
 467         }
 468       TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_BROADCAST (fd, 1, result);
 469       if (result != TARGET_NATIVE_OK)
 470         {
 471           JCL_ThrowException (env, IO_EXCEPTION,
 472                               TARGET_NATIVE_LAST_ERROR_STRING ());
 473           return;
 474         }
 475     }
 476
 477   if (stream)
 478     _javanet_set_int_field (env, this, "gnu/java/net/PlainSocketImpl",
 479                             "native_fd", fd);
 480   else
 481     _javanet_set_int_field (env, this, "gnu/java/net/PlainDatagramSocketImpl",
 482                             "native_fd", fd);
 483
 484   if ((*env)->ExceptionOccurred (env))
 485     {
 486       /* Try to make sure we close the socket since close() won't work. */
 487       do
 488         {
 489           TARGET_NATIVE_NETWORK_SOCKET_CLOSE (fd, result);
 490           if (result != TARGET_NATIVE_OK
 491               && (TARGET_NATIVE_LAST_ERROR ()
 492                   != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))
 493             return;
 494         }
 495       while (result != TARGET_NATIVE_OK);
 496       return;
 497     }
 498
 499 #else /* not WITHOUT_NETWORK */
 500 #endif /* not WITHOUT_NETWORK */
 501 }
 502
 503 /*************************************************************************/
 504
 505 /*
 506  * Close the socket.  Any underlying streams will be closed by this
 507  * action as well.
 508  */
 509 void
 510 _javanet_close (JNIEnv * env, jobject this, int stream)
 511 {
 512 #ifndef WITHOUT_NETWORK
 513   int fd;
 514   int result;
 515   int error = 0;
 516
 517   assert (env != NULL);
 518   assert ((*env) != NULL);
 519
 520   fd = _javanet_get_int_field (env, this, "native_fd");
 521   if (fd == -1)
 522     return;
 523
 524   if (stream)
 525     _javanet_set_int_field (env, this, "gnu/java/net/PlainSocketImpl",
 526                             "native_fd", -1);
 527   else
 528     _javanet_set_int_field (env, this, "gnu/java/net/PlainDatagramSocketImpl",
 529                             "native_fd", -1);
 530   do
 531     {
 532       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (fd, result);
 533       if (result != TARGET_NATIVE_OK)
 534         {
 535           /* Only throw an error when a "real" error occurs. */
 536           error = TARGET_NATIVE_LAST_ERROR ();
 537           if (error != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL
 538               && error != ENOTCONN && error != ECONNRESET && error != EBADF)
 539             JCL_ThrowException (env, IO_EXCEPTION,
 540                                 TARGET_NATIVE_LAST_ERROR_STRING ());
 541         }
 542     }
 543   while (error == TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL);
 544
 545 #else /* not WITHOUT_NETWORK */
 546 #endif /* not WITHOUT_NETWORK */
 547 }
 548
 549 /*************************************************************************/
 550
 551 /*
 552  * Connects to the specified destination.
 553  */
 554 void
 555 _javanet_connect (JNIEnv * env, jobject this, jobject addr, jint port)
 556 {
 557 #ifndef WITHOUT_NETWORK
 558   int netaddr, fd;
 559   int result;
 560   int local_address, local_port;
 561   int remote_address, remote_port;
 562
 563   assert (env != NULL);
 564   assert ((*env) != NULL);
 565
 566   DBG ("_javanet_connect(): Entered _javanet_connect\n");
 567
 568   /* Pre-process input variables */
 569   netaddr = _javanet_get_netaddr (env, addr);
 570   if ((*env)->ExceptionOccurred (env))
 571     return;
 572
 573   if (port == -1)
 574     port = 0;
 575   DBG ("_javanet_connect(): Got network address\n");
 576
 577   /* Grab the real socket file descriptor */
 578   fd = _javanet_get_int_field (env, this, "native_fd");
 579   if (fd == -1)
 580     {
 581       JCL_ThrowException (env, IO_EXCEPTION,
 582                           "Internal error: _javanet_connect(): no native file descriptor");
 583       return;
 584     }
 585   DBG ("_javanet_connect(): Got native fd\n");
 586
 587   /* Connect up */
 588   do
 589     {
 590       TARGET_NATIVE_NETWORK_SOCKET_CONNECT (fd, netaddr, port, result);
 591       if (result != TARGET_NATIVE_OK
 592           && (TARGET_NATIVE_LAST_ERROR ()
 593               != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))
 594         {
 595           JCL_ThrowException (env, IO_EXCEPTION,
 596                               TARGET_NATIVE_LAST_ERROR_STRING ());
 597           return;
 598         }
 599     }
 600   while (result != TARGET_NATIVE_OK);
 601
 602   DBG ("_javanet_connect(): Connected successfully\n");
 603
 604   /* Populate instance variables */
 605   TARGET_NATIVE_NETWORK_SOCKET_GET_LOCAL_INFO (fd, local_address, local_port,
 606                                                result);
 607   if (result != TARGET_NATIVE_OK)
 608     {
 609       JCL_ThrowException (env, IO_EXCEPTION,
 610                           TARGET_NATIVE_LAST_ERROR_STRING ());
 611       /* We don't care whether this succeeds. close() will cleanup later. */
 612       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (fd, result);
 613       return;
 614     }
 615
 616   _javanet_create_localfd (env, this);
 617   if ((*env)->ExceptionOccurred (env))
 618     {
 619       /* We don't care whether this succeeds. close() will cleanup later. */
 620       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (fd, result);
 621       return;
 622     }
 623   DBG ("_javanet_connect(): Created fd\n");
 624
 625   _javanet_set_int_field (env, this, "java/net/SocketImpl", "localport",
 626                           local_port);
 627   if ((*env)->ExceptionOccurred (env))
 628     {
 629       /* We don't care whether this succeeds. close() will cleanup later. */
 630       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (fd, result);
 631       return;
 632     }
 633   DBG ("_javanet_connect(): Set the local port\n");
 634
 635   TARGET_NATIVE_NETWORK_SOCKET_GET_REMOTE_INFO (fd, remote_address,
 636                                                 remote_port, result);
 637   if (result != TARGET_NATIVE_OK)
 638     {
 639       JCL_ThrowException (env, IO_EXCEPTION,
 640                           TARGET_NATIVE_LAST_ERROR_STRING ());
 641       /* We don't care whether this succeeds. close() will cleanup later. */
 642       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (fd, result);
 643       return;
 644     }
 645
 646   if (remote_address == netaddr)
 647     {
 648       _javanet_set_remhost_addr (env, this, addr);
 649     }
 650   else
 651     {
 652       _javanet_set_remhost (env, this, remote_address);
 653     }
 654   if ((*env)->ExceptionOccurred (env))
 655     {
 656       /* We don't care whether this succeeds. close() will cleanup later. */
 657       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (fd, result);
 658       return;
 659     }
 660   DBG ("_javanet_connect(): Set the remote host\n");
 661
 662   _javanet_set_int_field (env, this, "java/net/SocketImpl", "port",
 663                           remote_port);
 664   if ((*env)->ExceptionOccurred (env))
 665     {
 666       /* We don't care whether this succeeds. close() will cleanup later. */
 667       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (fd, result);
 668       return;
 669     }
 670   DBG ("_javanet_connect(): Set the remote port\n");
 671 #else /* not WITHOUT_NETWORK */
 672 #endif /* not WITHOUT_NETWORK */
 673 }
 674
 675 /*************************************************************************/
 676
 677 /*
 678  * This method binds the specified address to the specified local port.
 679  * Note that we have to set the local address and local
 680  * port public instance variables.
 681  */
 682 void
 683 _javanet_bind (JNIEnv * env, jobject this, jobject addr, jint port,
 684                int stream)
 685 {
 686 #ifndef WITHOUT_NETWORK
 687   jclass cls;
 688   jmethodID mid;
 689   jbyteArray arr = 0;
 690   jbyte *octets;
 691   jint fd;
 692   int tmpaddr;
 693   int result;
 694   int local_address, local_port;
 695
 696   assert (env != NULL);
 697   assert ((*env) != NULL);
 698
 699   DBG ("_javanet_bind(): Entering native bind()\n");
 700
 701   /* Get the address to connect to */
 702   cls = (*env)->GetObjectClass (env, addr);
 703   if (cls == NULL)
 704     return;
 705
 706   mid = (*env)->GetMethodID (env, cls, "getAddress", "()[B");
 707   if (mid == NULL)
 708     return;
 709
 710   DBG ("_javanet_bind(): Past getAddress method id\n");
 711
 712   arr = (*env)->CallObjectMethod (env, addr, mid);
 713   if ((arr == NULL) || (*env)->ExceptionOccurred (env))
 714     {
 715       JCL_ThrowException (env, IO_EXCEPTION,
 716                           "Internal error: _javanet_bind()");
 717       return;
 718     }
 719
 720   DBG ("_javanet_bind(): Past call object method\n");
 721
 722   octets = (*env)->GetByteArrayElements (env, arr, 0);
 723   if (octets == NULL)
 724     return;
 725
 726   DBG ("_javanet_bind(): Past grab array\n");
 727
 728   /* Get the native socket file descriptor */
 729   fd = _javanet_get_int_field (env, this, "native_fd");
 730   if (fd == -1)
 731     {
 732       (*env)->ReleaseByteArrayElements (env, arr, octets, 0);
 733       JCL_ThrowException (env, IO_EXCEPTION,
 734                           "Internal error: _javanet_bind(): no native file descriptor");
 735       return;
 736     }
 737   DBG ("_javanet_bind(): Past native_fd lookup\n");
 738
 739   /* XXX NYI ??? */
 740   _javanet_set_option (env, this, SOCKOPT_SO_REUSEADDR,
 741                        _javanet_create_boolean (env, JNI_TRUE));
 742
 743
 744   /* Bind the socket */
 745   TARGET_NATIVE_NETWORK_IPADDRESS_BYTES_TO_INT (octets[0],
 746                                                 octets[1],
 747                                                 octets[2],
 748                                                 octets[3], tmpaddr);
 749   TARGET_NATIVE_NETWORK_SOCKET_BIND (fd, tmpaddr, port, result);
 750
 751   if (result != TARGET_NATIVE_OK)
 752     {
 753       char *errorstr = TARGET_NATIVE_LAST_ERROR_STRING ();
 754       (*env)->ReleaseByteArrayElements (env, arr, octets, 0);
 755
 756       JCL_ThrowException (env, BIND_EXCEPTION,
 757                           errorstr);
 758       return;
 759     }
 760   DBG ("_javanet_bind(): Past bind\n");
 761
 762   (*env)->ReleaseByteArrayElements (env, arr, octets, 0);
 763
 764   /* Update instance variables, specifically the local port number */
 765   TARGET_NATIVE_NETWORK_SOCKET_GET_LOCAL_INFO (fd, local_address, local_port,
 766                                                result);
 767   if (result != TARGET_NATIVE_OK)
 768     {
 769       JCL_ThrowException (env, IO_EXCEPTION,
 770                           TARGET_NATIVE_LAST_ERROR_STRING ());
 771       return;
 772     }
 773
 774   if (stream)
 775     _javanet_set_int_field (env, this, "java/net/SocketImpl",
 776                             "localport", local_port);
 777   else
 778     _javanet_set_int_field (env, this, "java/net/DatagramSocketImpl",
 779                             "localPort", local_port);
 780   DBG ("_javanet_bind(): Past update port number\n");
 781
 782   return;
 783 #else /* not WITHOUT_NETWORK */
 784 #endif /* not WITHOUT_NETWORK */
 785 }
 786
 787 /*************************************************************************/
 788
 789 /*
 790  * Starts listening on a socket with the specified number of pending
 791  * connections allowed.
 792  */
 793 void
 794 _javanet_listen (JNIEnv * env, jobject this, jint queuelen)
 795 {
 796 #ifndef WITHOUT_NETWORK
 797   int fd;
 798   int result;
 799
 800   assert (env != NULL);
 801   assert ((*env) != NULL);
 802
 803   /* Get the real file descriptor */
 804   fd = _javanet_get_int_field (env, this, "native_fd");
 805   if (fd == -1)
 806     {
 807       JCL_ThrowException (env, IO_EXCEPTION,
 808                           "Internal error: _javanet_listen(): no native file descriptor");
 809       return;
 810     }
 811
 812   /* Start listening */
 813   TARGET_NATIVE_NETWORK_SOCKET_LISTEN (fd, queuelen, result);
 814   if (result != TARGET_NATIVE_OK)
 815     {
 816       JCL_ThrowException (env, IO_EXCEPTION,
 817                           TARGET_NATIVE_LAST_ERROR_STRING ());
 818       return;
 819     }
 820 #else /* not WITHOUT_NETWORK */
 821 #endif /* not WITHOUT_NETWORK */
 822 }
 823
 824 /*************************************************************************/
 825
 826 /*
 827  * Accepts a new connection and assigns it to the passed in SocketImpl
 828  * object. Note that we assume this is a PlainSocketImpl just like us
 829  */
 830 void
 831 _javanet_accept (JNIEnv * env, jobject this, jobject impl)
 832 {
 833 #ifndef WITHOUT_NETWORK
 834   int fd, newfd;
 835   int result;
 836   int local_address, local_port;
 837   int remote_address, remote_port;
 838
 839   assert (env != NULL);
 840   assert ((*env) != NULL);
 841
 842   /* Get the real file descriptor */
 843   fd = _javanet_get_int_field (env, this, "native_fd");
 844   if (fd == -1)
 845     {
 846       JCL_ThrowException (env, IO_EXCEPTION,
 847                           "Internal error: _javanet_accept(): no native file descriptor");
 848       return;
 849     }
 850
 851   /* Accept the connection */
 852   do
 853     {
 854       TARGET_NATIVE_NETWORK_SOCKET_ACCEPT (fd, newfd, result);
 855       if (result != TARGET_NATIVE_OK
 856           && (TARGET_NATIVE_LAST_ERROR ()
 857               != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))
 858         {
 859           if (TARGET_NATIVE_LAST_ERROR () == EAGAIN)
 860             JCL_ThrowException (env, "java/net/SocketTimeoutException",
 861                                 "Timeout");
 862           else
 863             JCL_ThrowException (env, IO_EXCEPTION,
 864                                 TARGET_NATIVE_LAST_ERROR_STRING ());
 865           return;
 866         }
 867     }
 868   while (result != TARGET_NATIVE_OK);
 869
 870   /* Populate instance variables */
 871   _javanet_set_int_field (env, impl, "gnu/java/net/PlainSocketImpl",
 872                           "native_fd", newfd);
 873
 874   if ((*env)->ExceptionOccurred (env))
 875     {
 876       /* Try to make sure we close the socket since close() won't work. */
 877       do
 878         {
 879           TARGET_NATIVE_NETWORK_SOCKET_CLOSE (newfd, result);
 880           if (result != TARGET_NATIVE_OK
 881               && (TARGET_NATIVE_LAST_ERROR ()
 882                   != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))
 883             return;
 884         }
 885       while (result != TARGET_NATIVE_OK);
 886       return;
 887     }
 888
 889   TARGET_NATIVE_NETWORK_SOCKET_GET_LOCAL_INFO (newfd, local_address,
 890                                                local_port, result);
 891   if (result != TARGET_NATIVE_OK)
 892     {
 893       /* We don't care whether this succeeds. close() will cleanup later. */
 894       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (newfd, result);
 895       JCL_ThrowException (env, IO_EXCEPTION,
 896                           TARGET_NATIVE_LAST_ERROR_STRING ());
 897       return;
 898     }
 899
 900   _javanet_create_localfd (env, impl);
 901   if ((*env)->ExceptionOccurred (env))
 902     {
 903       /* We don't care whether this succeeds. close() will cleanup later. */
 904       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (newfd, result);
 905       return;
 906     }
 907
 908   _javanet_set_int_field (env, impl, "java/net/SocketImpl", "localport",
 909                           local_port);
 910   if ((*env)->ExceptionOccurred (env))
 911     {
 912       /* We don't care whether this succeeds. close() will cleanup later. */
 913       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (newfd, result);
 914       return;
 915     }
 916
 917   TARGET_NATIVE_NETWORK_SOCKET_GET_REMOTE_INFO (newfd, remote_address,
 918                                                 remote_port, result);
 919   if (result != TARGET_NATIVE_OK)
 920     {
 921       JCL_ThrowException (env, IO_EXCEPTION,
 922                           TARGET_NATIVE_LAST_ERROR_STRING ());
 923       /* We don't care whether this succeeds. close() will cleanup later. */
 924       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (newfd, result);
 925       return;
 926     }
 927
 928   _javanet_set_remhost (env, impl, remote_address);
 929   if ((*env)->ExceptionOccurred (env))
 930     {
 931       /* We don't care whether this succeeds. close() will cleanup later. */
 932       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (newfd, result);
 933       return;
 934     }
 935
 936   _javanet_set_int_field (env, impl, "java/net/SocketImpl", "port",
 937                           remote_port);
 938   if ((*env)->ExceptionOccurred (env))
 939     {
 940       /* We don't care whether this succeeds. close() will cleanup later. */
 941       TARGET_NATIVE_NETWORK_SOCKET_CLOSE (newfd, result);
 942       return;
 943     }
 944 #else /* not WITHOUT_NETWORK */
 945 #endif /* not WITHOUT_NETWORK */
 946 }
 947
 948 /*************************************************************************/
 949
 950 /*
 951  * Receives a buffer from a remote host. The args are:
 952  *
 953  * buf - The byte array into which the data received will be written
 954  * offset - Offset into the byte array to start writing
 955  * len - The number of bytes to read.
 956  * addr - Pointer to 32 bit net address of host to receive from. If null,
 957  *        this parm is ignored.  If pointing to an address of 0, the
 958  *        actual address read is stored here
 959  * port - Pointer to the port to receive from. If null, this parm is ignored.
 960  *        If it is 0, the actual remote port received from is stored here
 961  *
 962  * The actual number of bytes read is returned.
 963  */
 964 int
 965 _javanet_recvfrom (JNIEnv * env, jobject this, jarray buf, int offset,
 966                    int len, int *addr, int *port)
 967 {
 968 #ifndef WITHOUT_NETWORK
 969   int fd;
 970   jbyte *p;
 971   int from_address, from_port;
 972   int received_bytes;
 973
 974   assert (env != NULL);
 975   assert ((*env) != NULL);
 976
 977   DBG ("_javanet_recvfrom(): Entered _javanet_recvfrom\n");
 978
 979   /* Get the real file descriptor */
 980   fd = _javanet_get_int_field (env, this, "native_fd");
 981   if (fd == -1)
 982     {
 983       JCL_ThrowException (env, IO_EXCEPTION,
 984                           "Internal error: _javanet_recvfrom(): no native file descriptor");
 985       return 0;
 986     }
 987   DBG ("_javanet_recvfrom(): Got native_fd\n");
 988
 989   /* Get a pointer to the buffer */
 990   p = (*env)->GetByteArrayElements (env, buf, 0);
 991   if (p == NULL)
 992     return 0;
 993
 994   DBG ("_javanet_recvfrom(): Got buffer\n");
 995
 996   /* Read the data */
 997   from_address = 0;
 998   from_port = 0;
 999   do
1000     {
1001       if (addr != NULL)
1002         {
1003           TARGET_NATIVE_NETWORK_SOCKET_RECEIVE_WITH_ADDRESS_PORT (fd,
1004                                                                   p + offset,
1005                                                                   len,
1006                                                                   from_address,
1007                                                                   from_port,
1008                                                                   received_bytes);
1009         }
1010       else
1011         {
1012           TARGET_NATIVE_NETWORK_SOCKET_RECEIVE (fd, p + offset, len,
1013                                                 received_bytes);
1014         }
1015     }
1016   while ((received_bytes == -1) &&
1017          (TARGET_NATIVE_LAST_ERROR () ==
1018           TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL));
1019
1020   if (received_bytes == -1)
1021     {
1022       if (TARGET_NATIVE_LAST_ERROR () == EAGAIN)
1023         JCL_ThrowException (env, "java/net/SocketTimeoutException", "Timeout");
1024       else
1025         JCL_ThrowException (env, IO_EXCEPTION,
1026                             TARGET_NATIVE_LAST_ERROR_STRING ());
1027
1028       /* Cleanup and return. */
1029       (*env)->ReleaseByteArrayElements (env, buf, p, 0);
1030       return 0;
1031     }
1032
1033   (*env)->ReleaseByteArrayElements (env, buf, p, 0);
1034
1035   /* Handle return addr case */
1036   if (addr != NULL)
1037     {
1038       (*addr) = from_address;
1039       if (port != NULL)
1040         (*port) = from_port;
1041     }
1042
1043   return (received_bytes);
1044 #else /* not WITHOUT_NETWORK */
1045 #endif /* not WITHOUT_NETWORK */
1046 }
1047
1048 /*************************************************************************/
1049
1050 /*
1051  * Sends a buffer to a remote host.  The args are:
1052  *
1053  * buf - A byte array
1054  * offset - Index into the byte array to start sendign
1055  * len - The number of bytes to write
1056  * addr - The 32bit address to send to (may be 0)
1057  * port - The port number to send to (may be 0)
1058  */
1059 void
1060 _javanet_sendto (JNIEnv * env, jobject this, jarray buf, int offset, int len,
1061                  int addr, int port)
1062 {
1063 #ifndef WITHOUT_NETWORK
1064   int fd;
1065   jbyte *p;
1066   int bytes_sent;
1067
1068   assert (env != NULL);
1069   assert ((*env) != NULL);
1070
1071   /* Get the real file descriptor */
1072   fd = _javanet_get_int_field (env, this, "native_fd");
1073   if (fd == -1)
1074     {
1075       JCL_ThrowException (env, IO_EXCEPTION,
1076                           "Internal error: _javanet_sendto(): no native file descriptor");
1077       return;
1078     }
1079
1080   /* Get a pointer to the buffer */
1081   p = (*env)->GetByteArrayElements (env, buf, 0);
1082   if (p == NULL)
1083     return;
1084
1085   /* We must send all the data, so repeat till done. */
1086   while (len > 0)
1087     {
1088       /* Send the data */
1089       if (addr == 0)
1090         {
1091           DBG ("_javanet_sendto(): Sending....\n");
1092           TARGET_NATIVE_NETWORK_SOCKET_SEND (fd, p + offset, len, bytes_sent);
1093         }
1094       else
1095         {
1096           DBG ("_javanet_sendto(): Sending....\n");
1097           TARGET_NATIVE_NETWORK_SOCKET_SEND_WITH_ADDRESS_PORT (fd, p + offset,
1098                                                                len, addr, port,
1099                                                                bytes_sent);
1100         }
1101
1102       if (bytes_sent < 0)
1103         {
1104           if (TARGET_NATIVE_LAST_ERROR ()
1105               != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL)
1106             {
1107               JCL_ThrowException (env, IO_EXCEPTION,
1108                                   TARGET_NATIVE_LAST_ERROR_STRING ());
1109               break;
1110             }
1111         }
1112       else
1113         {
1114           len -= bytes_sent;
1115           addr += bytes_sent;
1116         }
1117     }
1118
1119   (*env)->ReleaseByteArrayElements (env, buf, p, 0);
1120
1121 #else /* not WITHOUT_NETWORK */
1122 #endif /* not WITHOUT_NETWORK */
1123 }
1124
1125 /*************************************************************************/
1126
1127 /*
1128  * Sets the specified option for a socket
1129  */
1130 void
1131 _javanet_set_option (JNIEnv * env, jobject this, jint option_id, jobject val)
1132 {
1133 #ifndef WITHOUT_NETWORK
1134   int fd;
1135   int optval;
1136   jclass cls;
1137   jmethodID mid;
1138   int address;
1139   int result;
1140
1141   assert (env != NULL);
1142   assert ((*env) != NULL);
1143
1144   /* Get the real file descriptor */
1145   fd = _javanet_get_int_field (env, this, "native_fd");
1146   if (fd == -1)
1147     {
1148       JCL_ThrowException (env, IO_EXCEPTION,
1149                           "Internal error: _javanet_set_option(): no native file descriptor");
1150       return;
1151     }
1152
1153   /* We need a class object for all cases below */
1154   cls = (*env)->GetObjectClass (env, val);
1155   if (cls == NULL)
1156     return;
1157
1158   /* Process the option request */
1159   result = TARGET_NATIVE_ERROR;
1160   switch (option_id)
1161     {
1162       /* TCP_NODELAY case.  val is a Boolean that tells us what to do */
1163     case SOCKOPT_TCP_NODELAY:
1164       mid = (*env)->GetMethodID (env, cls, "booleanValue", "()Z");
1165       if (mid == NULL)
1166         {
1167           JCL_ThrowException (env, IO_EXCEPTION,
1168                               "Internal error: _javanet_set_option()");
1169           return;
1170         }
1171
1172       /* Should be a 0 or a 1 */
1173       optval = (*env)->CallBooleanMethod (env, val, mid);
1174       if ((*env)->ExceptionOccurred (env))
1175         return;
1176
1177       TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_TCP_NODELAY (fd, optval,
1178                                                            result);
1179       break;
1180
1181       /* SO_LINGER case.  If val is a boolean, then it will always be set
1182          to false indicating disable linger, otherwise it will be an
1183          integer that contains the linger value */
1184     case SOCKOPT_SO_LINGER:
1185       mid = (*env)->GetMethodID (env, cls, "booleanValue", "()Z");
1186       if (mid)
1187         {
1188           /* We are disabling linger */
1189           TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_SO_LINGER (fd, 1, 0,
1190                                                              result);
1191         }
1192       else
1193         {
1194           /* Clear exception if thrown for failure to do method lookup
1195              above */
1196           if ((*env)->ExceptionOccurred (env))
1197             (*env)->ExceptionClear (env);
1198
1199           mid = (*env)->GetMethodID (env, cls, "intValue", "()I");
1200           if (mid == NULL)
1201             {
1202               JCL_ThrowException (env, IO_EXCEPTION,
1203                                   "Internal error: _javanet_set_option()");
1204               return;
1205             }
1206
1207           optval = (*env)->CallIntMethod (env, val, mid);
1208           if ((*env)->ExceptionOccurred (env))
1209             return;
1210
1211           TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_SO_LINGER (fd, 0, optval,
1212                                                              result);
1213         }
1214       break;
1215
1216       /* SO_TIMEOUT case. Val will be an integer with the new value */
1217       /* Not writable on Linux */
1218     case SOCKOPT_SO_TIMEOUT:
1219 #ifdef SO_TIMEOUT
1220       mid = (*env)->GetMethodID (env, cls, "intValue", "()I");
1221       if (mid == NULL)
1222         {
1223           JCL_ThrowException (env, IO_EXCEPTION,
1224                               "Internal error: _javanet_set_option()");
1225           return;
1226         }
1227
1228       optval = (*env)->CallIntMethod (env, val, mid);
1229       if ((*env)->ExceptionOccurred (env))
1230         return;
1231
1232       TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_SO_TIMEOUT (fd, optval, result);
1233 #else
1234       result = TARGET_NATIVE_OK;
1235 #endif
1236       break;
1237
1238     case SOCKOPT_SO_SNDBUF:
1239     case SOCKOPT_SO_RCVBUF:
1240       mid = (*env)->GetMethodID (env, cls, "intValue", "()I");
1241       if (mid == NULL)
1242         {
1243           JCL_ThrowException (env, IO_EXCEPTION,
1244                               "Internal error: _javanet_set_option()");
1245           return;
1246         }
1247
1248
1249       optval = (*env)->CallIntMethod (env, val, mid);
1250       if ((*env)->ExceptionOccurred (env))
1251         return;
1252
1253       if (option_id == SOCKOPT_SO_SNDBUF)
1254         TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_SO_SNDBUF (fd, optval,
1255                                                            result);
1256       else
1257         TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_SO_RCDBUF (fd, optval,
1258                                                            result);
1259       break;
1260
1261       /* TTL case.  Val with be an Integer with the new time to live value */
1262     case SOCKOPT_IP_TTL:
1263       mid = (*env)->GetMethodID (env, cls, "intValue", "()I");
1264       if (!mid)
1265         {
1266           JCL_ThrowException (env, IO_EXCEPTION,
1267                               "Internal error: _javanet_set_option()");
1268           return;
1269         }
1270
1271       optval = (*env)->CallIntMethod (env, val, mid);
1272       if ((*env)->ExceptionOccurred (env))
1273         return;
1274
1275       TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_IP_TTL (fd, optval, result);
1276       break;
1277
1278       /* Multicast Interface case - val is InetAddress object */
1279     case SOCKOPT_IP_MULTICAST_IF:
1280       address = _javanet_get_netaddr (env, val);
1281
1282       if ((*env)->ExceptionOccurred (env))
1283         return;
1284
1285       TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_IP_MULTICAST_IF (fd, address,
1286                                                                result);
1287       break;
1288
1289     case SOCKOPT_SO_REUSEADDR:
1290       mid = (*env)->GetMethodID (env, cls, "booleanValue", "()Z");
1291       if (mid == NULL)
1292         {
1293           JCL_ThrowException (env, IO_EXCEPTION,
1294                               "Internal error: _javanet_set_option()");
1295           return;
1296         }
1297
1298       /* Should be a 0 or a 1 */
1299       optval = (*env)->CallBooleanMethod (env, val, mid);
1300       if ((*env)->ExceptionOccurred (env))
1301         return;
1302
1303       TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_REUSE_ADDRESS (fd, optval,
1304                                                              result);
1305       break;
1306
1307     case SOCKOPT_SO_KEEPALIVE:
1308       mid = (*env)->GetMethodID (env, cls, "booleanValue", "()Z");
1309       if (mid == NULL)
1310         {
1311           JCL_ThrowException (env, IO_EXCEPTION,
1312                               "Internal error: _javanet_set_option()");
1313           return;
1314         }
1315
1316       /* Should be a 0 or a 1 */
1317       optval = (*env)->CallBooleanMethod (env, val, mid);
1318       if ((*env)->ExceptionOccurred (env))
1319         return;
1320
1321       TARGET_NATIVE_NETWORK_SOCKET_SET_OPTION_KEEP_ALIVE (fd, optval, result);
1322       break;
1323
1324     case SOCKOPT_SO_BINDADDR:
1325       JCL_ThrowException (env, SOCKET_EXCEPTION, "This option cannot be set");
1326       break;
1327
1328     default:
1329       JCL_ThrowException (env, SOCKET_EXCEPTION, "Unrecognized option");
1330       return;
1331     }
1332
1333   /* Check to see if above operations succeeded */
1334   if (result != TARGET_NATIVE_OK)
1335     {
1336       JCL_ThrowException (env, SOCKET_EXCEPTION,
1337                           TARGET_NATIVE_LAST_ERROR_STRING ());
1338       return;
1339     }
1340 #else /* not WITHOUT_NETWORK */
1341 #endif /* not WITHOUT_NETWORK */
1342 }
1343
1344 /*************************************************************************/
1345
1346 /*
1347  * Retrieves the specified option values for a socket
1348  */
1349 jobject
1350 _javanet_get_option (JNIEnv * env, jobject this, jint option_id)
1351 {
1352 #ifndef WITHOUT_NETWORK
1353   int fd;
1354   int flag, optval;
1355   int address;
1356   int result;
1357
1358   assert (env != NULL);
1359   assert ((*env) != NULL);
1360
1361   /* Get the real file descriptor */
1362   fd = _javanet_get_int_field (env, this, "native_fd");
1363   if (fd == -1)
1364     {
1365       JCL_ThrowException (env, SOCKET_EXCEPTION,
1366                           "Internal error: _javanet_get_option(): no native file descriptor");
1367       return (0);
1368     }
1369
1370   /* Process the option requested */
1371   switch (option_id)
1372     {
1373       /* TCP_NODELAY case.  Return a Boolean indicating on or off */
1374     case SOCKOPT_TCP_NODELAY:
1375       TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_TCP_NODELAY (fd, optval,
1376                                                            result);
1377       if (result != TARGET_NATIVE_OK)
1378         {
1379           JCL_ThrowException (env, SOCKET_EXCEPTION,
1380                               TARGET_NATIVE_LAST_ERROR_STRING ());
1381           return (0);
1382         }
1383
1384       if (optval)
1385         return (_javanet_create_boolean (env, JNI_TRUE));
1386       else
1387         return (_javanet_create_boolean (env, JNI_FALSE));
1388
1389       break;
1390
1391       /* SO_LINGER case.  If disabled, return a Boolean object that represents
1392          false, else return an Integer that is the value of SO_LINGER */
1393     case SOCKOPT_SO_LINGER:
1394       TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_SO_LINGER (fd, flag, optval,
1395                                                          result);
1396       if (result != TARGET_NATIVE_OK)
1397         {
1398           JCL_ThrowException (env, SOCKET_EXCEPTION,
1399                               TARGET_NATIVE_LAST_ERROR_STRING ());
1400           return (0);
1401         }
1402
1403       if (optval)
1404         return (_javanet_create_integer (env, JNI_TRUE));
1405       else
1406         return (_javanet_create_boolean (env, JNI_FALSE));
1407
1408       break;
1409
1410       /* SO_TIMEOUT case. Return an Integer object with the timeout value */
1411     case SOCKOPT_SO_TIMEOUT:
1412 #ifdef SO_TIMEOUT
1413       TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_SO_TIMEOUT (fd, optval, result);
1414       if (result != TARGET_NATIVE_OK)
1415         {
1416           JCL_ThrowException (env, SOCKET_EXCEPTION,
1417                               TARGET_NATIVE_LAST_ERROR_STRING ());
1418           return (0);
1419         }
1420       return (_javanet_create_integer (env, optval));
1421 #else
1422       JCL_ThrowException (env, SOCKET_EXCEPTION,
1423                           "SO_TIMEOUT not supported on this platform");
1424       return (0);
1425 #endif /* not SO_TIMEOUT */
1426       break;
1427
1428     case SOCKOPT_SO_SNDBUF:
1429     case SOCKOPT_SO_RCVBUF:
1430       if (option_id == SOCKOPT_SO_SNDBUF)
1431         TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_SO_SNDBUF (fd, optval,
1432                                                            result);
1433       else
1434         TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_SO_RCDBUF (fd, optval,
1435                                                            result);
1436       if (result != TARGET_NATIVE_OK)
1437         {
1438           JCL_ThrowException (env, SOCKET_EXCEPTION,
1439                               TARGET_NATIVE_LAST_ERROR_STRING ());
1440           return (0);
1441         }
1442
1443       return (_javanet_create_integer (env, optval));
1444       break;
1445
1446       /* The TTL case.  Return an Integer with the Time to Live value */
1447     case SOCKOPT_IP_TTL:
1448       TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_IP_TTL (fd, optval, result);
1449       if (result != TARGET_NATIVE_OK)
1450         {
1451           JCL_ThrowException (env, SOCKET_EXCEPTION,
1452                               TARGET_NATIVE_LAST_ERROR_STRING ());
1453           return (0);
1454         }
1455
1456       return (_javanet_create_integer (env, optval));
1457       break;
1458
1459       /* Multicast interface case */
1460     case SOCKOPT_IP_MULTICAST_IF:
1461       TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_IP_MULTICAST_IF (fd, address,
1462                                                                result);
1463       if (result != TARGET_NATIVE_OK)
1464         {
1465           JCL_ThrowException (env, SOCKET_EXCEPTION,
1466                               TARGET_NATIVE_LAST_ERROR_STRING ());
1467           return (0);
1468         }
1469
1470       return (_javanet_create_inetaddress (env, address));
1471       break;
1472
1473     case SOCKOPT_SO_BINDADDR:
1474       TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_BIND_ADDRESS (fd, address,
1475                                                             result);
1476       if (result != TARGET_NATIVE_OK)
1477         {
1478           JCL_ThrowException (env, SOCKET_EXCEPTION,
1479                               TARGET_NATIVE_LAST_ERROR_STRING ());
1480           return (0);
1481         }
1482
1483       return (_javanet_create_inetaddress (env, address));
1484       break;
1485
1486     case SOCKOPT_SO_REUSEADDR:
1487       TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_REUSE_ADDRESS (fd, optval,
1488                                                              result);
1489       if (result != TARGET_NATIVE_OK)
1490         {
1491           JCL_ThrowException (env, SOCKET_EXCEPTION,
1492                               TARGET_NATIVE_LAST_ERROR_STRING ());
1493           return (0);
1494         }
1495
1496       if (optval)
1497         return (_javanet_create_boolean (env, JNI_TRUE));
1498       else
1499         return (_javanet_create_boolean (env, JNI_FALSE));
1500
1501       break;
1502
1503     case SOCKOPT_SO_KEEPALIVE:
1504       TARGET_NATIVE_NETWORK_SOCKET_GET_OPTION_KEEP_ALIVE (fd, optval, result);
1505       if (result != TARGET_NATIVE_OK)
1506         {
1507           JCL_ThrowException (env, SOCKET_EXCEPTION,
1508                               TARGET_NATIVE_LAST_ERROR_STRING ());
1509           return (0);
1510         }
1511
1512       if (optval)
1513         return (_javanet_create_boolean (env, JNI_TRUE));
1514       else
1515         return (_javanet_create_boolean (env, JNI_FALSE));
1516
1517       break;
1518
1519     default:
1520       JCL_ThrowException (env, SOCKET_EXCEPTION, "No such option");
1521       return (0);
1522     }
1523
1524   return (0);
1525 #else /* not WITHOUT_NETWORK */
1526 #endif /* not WITHOUT_NETWORK */
1527 }
1528
1529 void
1530 _javanet_shutdownInput (JNIEnv * env, jobject this)
1531 {
1532   int fd;
1533
1534   assert (env != NULL);
1535   assert ((*env) != NULL);
1536
1537   /* Get the real file descriptor. */
1538   fd = _javanet_get_int_field (env, this, "native_fd");
1539   if (fd == -1)
1540     {
1541       JCL_ThrowException (env, SOCKET_EXCEPTION,
1542                           "Internal error: _javanet_get_option(): no native file descriptor");
1543       return;
1544     }
1545
1546   /* Shutdown input stream of socket. */
1547   if (shutdown (fd, SHUT_RD) == -1)
1548     {
1549       JCL_ThrowException (env, SOCKET_EXCEPTION, strerror (errno));
1550       return;
1551     }
1552 }
1553
1554 void
1555 _javanet_shutdownOutput (JNIEnv * env, jobject this)
1556 {
1557   int fd;
1558
1559   assert (env != NULL);
1560   assert ((*env) != NULL);
1561
1562   /* Get the real file descriptor. */
1563   fd = _javanet_get_int_field (env, this, "native_fd");
1564   if (fd == -1)
1565     {
1566       JCL_ThrowException (env, SOCKET_EXCEPTION,
1567                           "Internal error: _javanet_get_option(): no native file descriptor");
1568       return;
1569     }
1570
1571   /* Shutdown output stream of socket. */
1572   if (shutdown (fd, SHUT_WR) == -1)
1573     {
1574       JCL_ThrowException (env, SOCKET_EXCEPTION, strerror (errno));
1575       return;
1576     }
1577 }
1578
1579 /* end of file */