< prev index next >

src/java.base/unix/native/libnet/SocketInputStream.c

Print this page




  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 
  32 #include "jvm.h"
  33 #include "jni_util.h"
  34 #include "net_util.h"
  35 
  36 #include "java_net_SocketInputStream.h"
  37 
  38 
  39 /************************************************************************
  40  * SocketInputStream
  41  */
  42 
  43 static jfieldID IO_fd_fdID;
  44 
  45 /*
  46  * Class:     java_net_SocketInputStream
  47  * Method:    init
  48  * Signature: ()V
  49  */
  50 JNIEXPORT void JNICALL
  51 Java_java_net_SocketInputStream_init(JNIEnv *env, jclass cls) {
  52     IO_fd_fdID = NET_GetFileDescriptorID(env);
  53 }
  54 








































  55 /*
  56  * Class:     java_net_SocketInputStream
  57  * Method:    socketRead0
  58  * Signature: (Ljava/io/FileDescriptor;[BIII)I
  59  */
  60 JNIEXPORT jint JNICALL
  61 Java_java_net_SocketInputStream_socketRead0(JNIEnv *env, jobject this,
  62                                             jobject fdObj, jbyteArray data,
  63                                             jint off, jint len, jint timeout)
  64 {
  65     char BUF[MAX_BUFFER_LEN];
  66     char *bufP;
  67     jint fd, nread;
  68 
  69     if (IS_NULL(fdObj)) {
  70         /* shouldn't this be a NullPointerException? -br */
  71         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
  72                         "Socket closed");
  73         return -1;
  74     } else {


  81             return -1;
  82         }
  83     }
  84 
  85     /*
  86      * If the read is greater than our stack allocated buffer then
  87      * we allocate from the heap (up to a limit)
  88      */
  89     if (len > MAX_BUFFER_LEN) {
  90         if (len > MAX_HEAP_BUFFER_LEN) {
  91             len = MAX_HEAP_BUFFER_LEN;
  92         }
  93         bufP = (char *)malloc((size_t)len);
  94         if (bufP == NULL) {
  95             bufP = BUF;
  96             len = MAX_BUFFER_LEN;
  97         }
  98     } else {
  99         bufP = BUF;
 100     }
 101 
 102     if (timeout) {
 103         nread = NET_Timeout(fd, timeout);
 104         if (nread <= 0) {
 105             if (nread == 0) {
 106                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 107                             "Read timed out");
 108             } else if (nread == -1) {
 109                 if (errno == EBADF) {
 110                      JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 111                 } else if (errno == ENOMEM) {
 112                     JNU_ThrowOutOfMemoryError(env, "NET_Timeout native heap allocation failed");
 113                 } else {
 114                     JNU_ThrowByNameWithMessageAndLastError
 115                         (env, JNU_JAVANETPKG "SocketException", "select/poll failed");
 116                 }
 117             }
 118             if (bufP != BUF) {
 119                 free(bufP);
 120             }
 121             return -1;
 122         }
 123     }
 124 
 125     nread = NET_Read(fd, bufP, len);
 126 
 127     if (nread <= 0) {
 128         if (nread < 0) {
 129 
 130             switch (errno) {
 131                 case ECONNRESET:
 132                 case EPIPE:
 133                     JNU_ThrowByName(env, "sun/net/ConnectionResetException",
 134                         "Connection reset");
 135                     break;
 136 
 137                 case EBADF:
 138                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 139                         "Socket closed");
 140                     break;
 141 
 142                 case EINTR:
 143                      JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 144                            "Operation interrupted");
 145                      break;
 146 
 147                 default:
 148                     JNU_ThrowByNameWithMessageAndLastError
 149                         (env, JNU_JAVANETPKG "SocketException", "Read failed");
 150             }
 151         }
 152     } else {
 153         (*env)->SetByteArrayRegion(env, data, off, nread, (jbyte *)bufP);
 154     }
 155 
 156     if (bufP != BUF) {
 157         free(bufP);
 158     }
 159     return nread;
 160 }


  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/time.h>
  32 #include "jvm.h"
  33 #include "jni_util.h"
  34 #include "net_util.h"
  35 
  36 #include "java_net_SocketInputStream.h"
  37 

  38 /************************************************************************
  39  * SocketInputStream
  40  */
  41 
  42 static jfieldID IO_fd_fdID;
  43 
  44 /*
  45  * Class:     java_net_SocketInputStream
  46  * Method:    init
  47  * Signature: ()V
  48  */
  49 JNIEXPORT void JNICALL
  50 Java_java_net_SocketInputStream_init(JNIEnv *env, jclass cls) {
  51     IO_fd_fdID = NET_GetFileDescriptorID(env);
  52 }
  53 
  54 static long getCurrentTime() {
  55     struct timeval time;
  56     gettimeofday(&time, NULL);
  57     return (time.tv_sec * 1000 + time.tv_usec / 1000);
  58 }
  59 
  60 static int NET_ReadWithTimeout(JNIEnv *env, int fd, char *bufP, int len, long timeout) {
  61     int result;
  62     long prevtime = getCurrentTime(), newtime;
  63     while (timeout > 0) {
  64         result = NET_TimeoutWithCurrentTime(fd, timeout, prevtime);
  65         if (result <= 0) {
  66             if (result == 0) {
  67                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException", "Read timed out");
  68             } else if (result == -1) {
  69                 if (errno == EBADF) {
  70                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
  71                 } else if (errno == ENOMEM) {
  72                     JNU_ThrowOutOfMemoryError(env, "NET_Timeout native heap allocation failed");
  73                 } else {
  74                     JNU_ThrowByNameWithMessageAndLastError
  75                             (env, JNU_JAVANETPKG "SocketException", "select/poll failed");
  76                 }
  77             }
  78             return -1;
  79         }
  80         result = NET_NonBlockingRead(fd, bufP, len);
  81         if (result == -1 && ((errno == EAGAIN) || (errno == EWOULDBLOCK))) {
  82             newtime = getCurrentTime();
  83             timeout -= newtime - prevtime;
  84             if (timeout > 0) {
  85                 prevtime = newtime;
  86             }
  87         } else {
  88             break;
  89         }
  90     }
  91     return result;
  92 }
  93 
  94 /*
  95  * Class:     java_net_SocketInputStream
  96  * Method:    socketRead0
  97  * Signature: (Ljava/io/FileDescriptor;[BIII)I
  98  */
  99 JNIEXPORT jint JNICALL
 100 Java_java_net_SocketInputStream_socketRead0(JNIEnv *env, jobject this,
 101                                             jobject fdObj, jbyteArray data,
 102                                             jint off, jint len, jint timeout)
 103 {
 104     char BUF[MAX_BUFFER_LEN];
 105     char *bufP;
 106     jint fd, nread;
 107     
 108     if (IS_NULL(fdObj)) {
 109         /* shouldn't this be a NullPointerException? -br */
 110         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 111                         "Socket closed");
 112         return -1;
 113     } else {


 120             return -1;
 121         }
 122     }
 123 
 124     /*
 125      * If the read is greater than our stack allocated buffer then
 126      * we allocate from the heap (up to a limit)
 127      */
 128     if (len > MAX_BUFFER_LEN) {
 129         if (len > MAX_HEAP_BUFFER_LEN) {
 130             len = MAX_HEAP_BUFFER_LEN;
 131         }
 132         bufP = (char *)malloc((size_t)len);
 133         if (bufP == NULL) {
 134             bufP = BUF;
 135             len = MAX_BUFFER_LEN;
 136         }
 137     } else {
 138         bufP = BUF;
 139     }

 140     if (timeout) {
 141         nread = NET_ReadWithTimeout(env, fd, bufP, len, timeout);









 142     } else {











 143         nread = NET_Read(fd, bufP, len);
 144     }
 145     if (nread <= 0) {
 146         if (nread < 0) {
 147 
 148             switch (errno) {
 149                 case ECONNRESET:
 150                 case EPIPE:
 151                     JNU_ThrowByName(env, "sun/net/ConnectionResetException",
 152                         "Connection reset");
 153                     break;
 154 
 155                 case EBADF:
 156                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 157                         "Socket closed");
 158                     break;
 159 
 160                 case EINTR:
 161                      JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 162                            "Operation interrupted");
 163                      break;

 164                 default:
 165                     JNU_ThrowByNameWithMessageAndLastError
 166                         (env, JNU_JAVANETPKG "SocketException", "Read failed");
 167             }
 168         }
 169     } else {
 170         (*env)->SetByteArrayRegion(env, data, off, nread, (jbyte *)bufP);
 171     }
 172 
 173     if (bufP != BUF) {
 174         free(bufP);
 175     }
 176     return nread;
 177 }
< prev index next >