src/solaris/native/java/net/PlainDatagramSocketImpl.c

Print this page




 484     jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);
 485     jint fd;
 486     ssize_t n;
 487     SOCKADDR remote_addr;
 488     socklen_t slen = SOCKADDR_LEN;
 489     char buf[1];
 490     jint family;
 491     jobject iaObj;
 492     int port;
 493     if (IS_NULL(fdObj)) {
 494         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 495         return -1;
 496     } else {
 497         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 498     }
 499     if (IS_NULL(addressObj)) {
 500         JNU_ThrowNullPointerException(env, "Null address in peek()");
 501         return -1;
 502     }
 503     if (timeout) {
 504         int ret = NET_Timeout(fd, timeout);

 505         if (ret == 0) {
 506             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 507                             "Peek timed out");
 508             return ret;
 509         } else if (ret == -1) {
 510             if (errno == EBADF) {
 511                  JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 512             } else {
 513                  NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Peek failed");
 514             }
 515             return ret;
 516         }
 517     }
 518 
 519     n = NET_RecvFrom(fd, buf, 1, MSG_PEEK, (struct sockaddr *)&remote_addr, &slen);
 520 
 521     if (n == -1) {
 522 
 523 #ifdef __solaris__
 524         if (errno == ECONNREFUSED) {


 577         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 578                         "Socket closed");
 579         return -1;
 580     }
 581 
 582     fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 583 
 584     if (IS_NULL(packet)) {
 585         JNU_ThrowNullPointerException(env, "packet");
 586         return -1;
 587     }
 588 
 589     packetBuffer = (*env)->GetObjectField(env, packet, dp_bufID);
 590     if (IS_NULL(packetBuffer)) {
 591         JNU_ThrowNullPointerException(env, "packet buffer");
 592         return -1;
 593     }
 594     packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);
 595     packetBufferLen = (*env)->GetIntField(env, packet, dp_bufLengthID);
 596     if (timeout) {
 597         int ret = NET_Timeout(fd, timeout);

 598         if (ret == 0) {
 599             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 600                             "Receive timed out");
 601             return -1;
 602         } else if (ret == -1) {
 603 #ifdef __linux__
 604             if (errno == EBADF) {
 605                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 606             } else {
 607                 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Receive failed");
 608             }
 609 #else
 610             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 611 #endif
 612             return -1;
 613         }
 614     }
 615 
 616     if (packetBufferLen > MAX_BUFFER_LEN) {
 617 


 785          */
 786         if (packetBufferLen > MAX_PACKET_LEN) {
 787             packetBufferLen = MAX_PACKET_LEN;
 788         }
 789         fullPacket = (char *)malloc(packetBufferLen);
 790 
 791         if (!fullPacket) {
 792             JNU_ThrowOutOfMemoryError(env, "Receive buffer native heap allocation failed");
 793             return;
 794         } else {
 795             mallocedPacket = JNI_TRUE;
 796         }
 797     } else {
 798         fullPacket = &(BUF[0]);
 799     }
 800 
 801     do {
 802         retry = JNI_FALSE;
 803 
 804         if (timeout) {
 805             int ret = NET_Timeout(fd, timeout);
 806             if (ret <= 0) {
 807                 if (ret == 0) {


 808                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 809                                     "Receive timed out");
 810                 } else if (ret == -1) {
 811 #ifdef __linux__
 812                     if (errno == EBADF) {
 813                          JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 814                      } else {
 815                          NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Receive failed");
 816                      }
 817 #else
 818                      JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 819 #endif
 820                 }
 821 
 822                 if (mallocedPacket) {
 823                     free(fullPacket);
 824                 }
 825 
 826                 return;
 827             }




 484     jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);
 485     jint fd;
 486     ssize_t n;
 487     SOCKADDR remote_addr;
 488     socklen_t slen = SOCKADDR_LEN;
 489     char buf[1];
 490     jint family;
 491     jobject iaObj;
 492     int port;
 493     if (IS_NULL(fdObj)) {
 494         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 495         return -1;
 496     } else {
 497         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 498     }
 499     if (IS_NULL(addressObj)) {
 500         JNU_ThrowNullPointerException(env, "Null address in peek()");
 501         return -1;
 502     }
 503     if (timeout) {
 504         int ret = NET_Timeout(env, fd, timeout);
 505         JNU_CHECK_EXCEPTION_RETURN(env, -1);
 506         if (ret == 0) {
 507             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 508                             "Peek timed out");
 509             return ret;
 510         } else if (ret == -1) {
 511             if (errno == EBADF) {
 512                  JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 513             } else {
 514                  NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Peek failed");
 515             }
 516             return ret;
 517         }
 518     }
 519 
 520     n = NET_RecvFrom(fd, buf, 1, MSG_PEEK, (struct sockaddr *)&remote_addr, &slen);
 521 
 522     if (n == -1) {
 523 
 524 #ifdef __solaris__
 525         if (errno == ECONNREFUSED) {


 578         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 579                         "Socket closed");
 580         return -1;
 581     }
 582 
 583     fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 584 
 585     if (IS_NULL(packet)) {
 586         JNU_ThrowNullPointerException(env, "packet");
 587         return -1;
 588     }
 589 
 590     packetBuffer = (*env)->GetObjectField(env, packet, dp_bufID);
 591     if (IS_NULL(packetBuffer)) {
 592         JNU_ThrowNullPointerException(env, "packet buffer");
 593         return -1;
 594     }
 595     packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);
 596     packetBufferLen = (*env)->GetIntField(env, packet, dp_bufLengthID);
 597     if (timeout) {
 598         int ret = NET_Timeout(env, fd, timeout);
 599         JNU_CHECK_EXCEPTION_RETURN(env, -1);
 600         if (ret == 0) {
 601             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 602                             "Receive timed out");
 603             return -1;
 604         } else if (ret == -1) {
 605 #ifdef __linux__
 606             if (errno == EBADF) {
 607                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 608             } else {
 609                 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Receive failed");
 610             }
 611 #else
 612             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 613 #endif
 614             return -1;
 615         }
 616     }
 617 
 618     if (packetBufferLen > MAX_BUFFER_LEN) {
 619 


 787          */
 788         if (packetBufferLen > MAX_PACKET_LEN) {
 789             packetBufferLen = MAX_PACKET_LEN;
 790         }
 791         fullPacket = (char *)malloc(packetBufferLen);
 792 
 793         if (!fullPacket) {
 794             JNU_ThrowOutOfMemoryError(env, "Receive buffer native heap allocation failed");
 795             return;
 796         } else {
 797             mallocedPacket = JNI_TRUE;
 798         }
 799     } else {
 800         fullPacket = &(BUF[0]);
 801     }
 802 
 803     do {
 804         retry = JNI_FALSE;
 805 
 806         if (timeout) {
 807             int ret = NET_Timeout(env, fd, timeout);
 808             if (ret <= 0) {
 809                 if ((*env)->ExceptionCheck(env)) {
 810                     // fall-through, to potentially free, then return
 811                 } else if (ret == 0) {
 812                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 813                                     "Receive timed out");
 814                 } else if (ret == -1) {
 815 #ifdef __linux__
 816                     if (errno == EBADF) {
 817                          JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 818                      } else {
 819                          NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Receive failed");
 820                      }
 821 #else
 822                      JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 823 #endif
 824                 }
 825 
 826                 if (mallocedPacket) {
 827                     free(fullPacket);
 828                 }
 829 
 830                 return;
 831             }