src/windows/native/java/net/TwoStacksPlainSocketImpl.c

Print this page




 105     psi_fd1ID =(*env)->GetFieldID(env, cls , "fd1", "Ljava/io/FileDescriptor;");
 106     CHECK_NULL(psi_fd1ID);
 107     psi_addressID = (*env)->GetFieldID(env, cls, "address",
 108                                           "Ljava/net/InetAddress;");
 109     CHECK_NULL(psi_addressID);
 110     psi_portID = (*env)->GetFieldID(env, cls, "port", "I");
 111     CHECK_NULL(psi_portID);
 112     psi_lastfdID = (*env)->GetFieldID(env, cls, "lastfd", "I");
 113     CHECK_NULL(psi_portID);
 114     psi_localportID = (*env)->GetFieldID(env, cls, "localport", "I");
 115     CHECK_NULL(psi_localportID);
 116     psi_timeoutID = (*env)->GetFieldID(env, cls, "timeout", "I");
 117     CHECK_NULL(psi_timeoutID);
 118     psi_trafficClassID = (*env)->GetFieldID(env, cls, "trafficClass", "I");
 119     CHECK_NULL(psi_trafficClassID);
 120     psi_serverSocketID = (*env)->GetFieldID(env, cls, "serverSocket",
 121                                             "Ljava/net/ServerSocket;");
 122     CHECK_NULL(psi_serverSocketID);
 123     IO_fd_fdID = NET_GetFileDescriptorID(env);
 124     CHECK_NULL(IO_fd_fdID);


 125 }
 126 
 127 /*
 128  * Class:     java_net_TwoStacksPlainSocketImpl
 129  * Method:    socketCreate
 130  * Signature: (Z)V
 131  */
 132 JNIEXPORT void JNICALL
 133 Java_java_net_TwoStacksPlainSocketImpl_socketCreate(JNIEnv *env, jobject this,
 134                                            jboolean stream) {
 135     jobject fdObj, fd1Obj;
 136     int fd, fd1;
 137 
 138     fdObj = (*env)->GetObjectField(env, this, psi_fdID);
 139 
 140     if (IS_NULL(fdObj)) {
 141         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 142                         "null fd object");
 143         return;
 144     }
 145     fd = socket(AF_INET, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);
 146     if (fd == -1) {
 147         NET_ThrowCurrent(env, "create");
 148         return;
 149     } else {
 150         /* Set socket attribute so it is not passed to any child process */
 151         SetHandleInformation((HANDLE)(UINT_PTR)fd, HANDLE_FLAG_INHERIT, FALSE);
 152         (*env)->SetIntField(env, fdObj, IO_fd_fdID, (int)fd);
 153     }
 154     if (ipv6_available()) {
 155         fd1Obj = (*env)->GetObjectField(env, this, psi_fd1ID);
 156 
 157         if (IS_NULL(fd1Obj)) {
 158             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 159                             "null fd1 object");
 160             (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
 161             NET_SocketClose(fd);
 162             return;
 163         }
 164         fd1 = socket(AF_INET6, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);
 165         if (fd1 == -1) {
 166             NET_ThrowCurrent(env, "create");
 167             (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
 168             NET_SocketClose(fd);
 169             return;
 170         } else {
 171             /* Set socket attribute so it is not passed to any child process */
 172             SetHandleInformation((HANDLE)(UINT_PTR)fd1, HANDLE_FLAG_INHERIT, FALSE);
 173             (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);
 174         }
 175     } else {
 176         (*env)->SetObjectField(env, this, psi_fd1ID, NULL);
 177     }
 178 }
 179 
 180 /*
 181  * inetAddress is the address object passed to the socket connect
 182  * call.
 183  *
 184  * Class:     java_net_TwoStacksPlainSocketImpl


 432     }
 433     if (IS_NULL(iaObj)) {
 434         JNU_ThrowNullPointerException(env, "inet address argument");
 435         return;
 436     }
 437 
 438     if (NET_InetAddressToSockaddr(env, iaObj, localport,
 439                           (struct sockaddr *)&him, &len, JNI_FALSE) != 0) {
 440       return;
 441     }
 442 
 443     if (ipv6_supported) {
 444         struct ipv6bind v6bind;
 445         v6bind.addr = &him;
 446         v6bind.ipv4_fd = fd;
 447         v6bind.ipv6_fd = fd1;
 448         rv = NET_BindV6(&v6bind);
 449         if (rv != -1) {
 450             /* check if the fds have changed */
 451             if (v6bind.ipv4_fd != fd) {
 452                 fd = v6bind.ipv4_fd;
 453                 if (fd == -1) {
 454                     /* socket is closed. */
 455                     (*env)->SetObjectField(env, this, psi_fdID, NULL);
 456                 } else {
 457                     /* socket was re-created */
 458                     (*env)->SetIntField(env, fdObj, IO_fd_fdID, fd);
 459                 }
 460             }
 461             if (v6bind.ipv6_fd != fd1) {
 462                 fd1 = v6bind.ipv6_fd;
 463                 if (fd1 == -1) {
 464                     /* socket is closed. */
 465                     (*env)->SetObjectField(env, this, psi_fd1ID, NULL);
 466                 } else {
 467                     /* socket was re-created */
 468                     (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);
 469                 }
 470             }
 471         }
 472     } else {
 473         rv = NET_Bind(fd, (struct sockaddr *)&him, len);
 474     }
 475 
 476     if (rv == -1) {
 477         NET_ThrowCurrent(env, "JVM_Bind");
 478         return;
 479     }
 480 
 481     /* set the address */
 482     (*env)->SetObjectField(env, this, psi_addressID, iaObj);


 566 }
 567 
 568 /*
 569  * Class:     java_net_TwoStacksPlainSocketImpl
 570  * Method:    socketAccept
 571  * Signature: (Ljava/net/SocketImpl;)V
 572  */
 573 JNIEXPORT void JNICALL
 574 Java_java_net_TwoStacksPlainSocketImpl_socketAccept(JNIEnv *env, jobject this,
 575                                            jobject socket)
 576 {
 577     /* fields on this */
 578     jint port;
 579     jint timeout = (*env)->GetIntField(env, this, psi_timeoutID);
 580     jobject fdObj = (*env)->GetObjectField(env, this, psi_fdID);
 581     jobject fd1Obj = (*env)->GetObjectField(env, this, psi_fd1ID);
 582 
 583     /* the FileDescriptor field on socket */
 584     jobject socketFdObj;
 585 
 586     /* cache the Inet4/6Address classes */
 587     static jclass inet4Cls;
 588     static jclass inet6Cls;
 589 
 590     /* the InetAddress field on socket */
 591     jobject socketAddressObj;
 592 
 593     /* the fd int field on fdObj */
 594     jint fd=-1, fd1=-1;
 595 
 596     SOCKETADDRESS him;
 597     jint len;
 598 
 599     if (IS_NULL(fdObj) && IS_NULL(fd1Obj)) {
 600         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 601                         "Socket closed");
 602         return;
 603     }
 604     if (!IS_NULL(fdObj)) {
 605         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 606     }
 607     if (!IS_NULL(fd1Obj)) {
 608         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
 609     }


 667             len = sizeof (struct sockaddr_in);
 668         }
 669         if (timeout) {
 670             ret = NET_Timeout(fd, timeout);
 671             if (ret == 0) {
 672                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 673                                 "Accept timed out");
 674                 return;
 675             } else if (ret == -1) {
 676                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "socket closed");
 677             /* REMIND: SOCKET CLOSED PROBLEM */
 678     /*        NET_ThrowCurrent(env, "Accept failed"); */
 679                 return;
 680             } else if (ret == -2) {
 681                 JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 682                                 "operation interrupted");
 683                 return;
 684             }
 685         }
 686     }
 687     fd = accept(fd, (struct sockaddr *)&him, &len);
 688     if (fd < 0) {
 689         /* REMIND: SOCKET CLOSED PROBLEM */
 690         if (fd == -2) {
 691             JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 692                             "operation interrupted");
 693         } else {
 694             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 695                             "socket closed");
 696         }
 697         return;
 698     }
 699     (*env)->SetIntField(env, socketFdObj, IO_fd_fdID, fd);
 700 
 701     if (him.him.sa_family == AF_INET) {
 702         if (inet4Cls == NULL) {
 703             jclass c = (*env)->FindClass(env, "java/net/Inet4Address");
 704             if (c != NULL) {
 705                 inet4Cls = (*env)->NewGlobalRef(env, c);
 706                 (*env)->DeleteLocalRef(env, c);
 707             }
 708         }
 709 
 710         /*
 711          * fill up the remote peer port and address in the new socket structure
 712          */
 713         if (inet4Cls != NULL) {
 714             socketAddressObj = (*env)->NewObject(env, inet4Cls, ia4_ctrID);
 715         } else {
 716             socketAddressObj = NULL;
 717         }
 718         if (socketAddressObj == NULL) {
 719             /*
 720              * FindClass or NewObject failed so close connection and
 721              * exist (there will be a pending exception).
 722              */
 723             NET_SocketClose(fd);
 724             return;
 725         }
 726 
 727         (*env)->SetIntField(env, socketAddressObj, ia_addressID,
 728                             ntohl(him.him4.sin_addr.s_addr));
 729         (*env)->SetIntField(env, socketAddressObj, ia_familyID, IPv4);
 730         (*env)->SetObjectField(env, socket, psi_addressID, socketAddressObj);
 731     } else {
 732         jbyteArray addr;
 733         /* AF_INET6 -> Inet6Address */
 734         if (inet6Cls == 0) {
 735             jclass c = (*env)->FindClass(env, "java/net/Inet6Address");
 736             if (c != NULL) {
 737                 inet6Cls = (*env)->NewGlobalRef(env, c);
 738                 (*env)->DeleteLocalRef(env, c);
 739             }
 740         }
 741 
 742         if (inet6Cls != NULL) {
 743             socketAddressObj = (*env)->NewObject(env, inet6Cls, ia6_ctrID);
 744         } else {
 745             socketAddressObj = NULL;
 746         }
 747         if (socketAddressObj == NULL) {
 748             /*
 749              * FindClass or NewObject failed so close connection and
 750              * exist (there will be a pending exception).
 751              */
 752             NET_SocketClose(fd);
 753             return;
 754         }
 755         addr = (*env)->GetObjectField (env, socketAddressObj, ia6_ipaddressID);
 756         (*env)->SetByteArrayRegion (env, addr, 0, 16, (const char *)&him.him6.sin6_addr);
 757         (*env)->SetIntField(env, socketAddressObj, ia_familyID, IPv6);
 758         (*env)->SetIntField(env, socketAddressObj, ia6_scopeidID, him.him6.sin6_scope_id);
 759     }
 760     /* fields common to AF_INET and AF_INET6 */
 761 
 762     port = ntohs ((u_short) GET_PORT (&him));
 763     (*env)->SetIntField(env, socket, psi_portID, (int)port);
 764     port = (*env)->GetIntField(env, this, psi_localportID);
 765     (*env)->SetIntField(env, socket, psi_localportID, port);
 766     (*env)->SetObjectField(env, socket, psi_addressID, socketAddressObj);


1131         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1132                         "socket already closed");
1133         return;
1134     } else {
1135         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1136     }
1137     shutdown(fd, howto);
1138 }
1139 
1140 /*
1141  * Class:     java_net_TwoStacksPlainSocketImpl
1142  * Method:    socketSendUrgentData
1143  * Signature: (B)V
1144  */
1145 JNIEXPORT void JNICALL
1146 Java_java_net_TwoStacksPlainSocketImpl_socketSendUrgentData(JNIEnv *env, jobject this,
1147                                              jint data) {
1148     /* The fd field */
1149     jobject fdObj = (*env)->GetObjectField(env, this, psi_fdID);
1150     int n, fd;
1151     unsigned char d = data & 0xff;
1152 
1153     if (IS_NULL(fdObj)) {
1154         JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
1155         return;
1156     } else {
1157         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1158         /* Bug 4086704 - If the Socket associated with this file descriptor
1159          * was closed (sysCloseFD), the the file descriptor is set to -1.
1160          */
1161         if (fd == -1) {
1162             JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
1163             return;
1164         }
1165 
1166     }
1167     n = send(fd, (char *)&data, 1, MSG_OOB);
1168     if (n == JVM_IO_ERR) {
1169         NET_ThrowCurrent(env, "send");
1170         return;
1171     }


 105     psi_fd1ID =(*env)->GetFieldID(env, cls , "fd1", "Ljava/io/FileDescriptor;");
 106     CHECK_NULL(psi_fd1ID);
 107     psi_addressID = (*env)->GetFieldID(env, cls, "address",
 108                                           "Ljava/net/InetAddress;");
 109     CHECK_NULL(psi_addressID);
 110     psi_portID = (*env)->GetFieldID(env, cls, "port", "I");
 111     CHECK_NULL(psi_portID);
 112     psi_lastfdID = (*env)->GetFieldID(env, cls, "lastfd", "I");
 113     CHECK_NULL(psi_portID);
 114     psi_localportID = (*env)->GetFieldID(env, cls, "localport", "I");
 115     CHECK_NULL(psi_localportID);
 116     psi_timeoutID = (*env)->GetFieldID(env, cls, "timeout", "I");
 117     CHECK_NULL(psi_timeoutID);
 118     psi_trafficClassID = (*env)->GetFieldID(env, cls, "trafficClass", "I");
 119     CHECK_NULL(psi_trafficClassID);
 120     psi_serverSocketID = (*env)->GetFieldID(env, cls, "serverSocket",
 121                                             "Ljava/net/ServerSocket;");
 122     CHECK_NULL(psi_serverSocketID);
 123     IO_fd_fdID = NET_GetFileDescriptorID(env);
 124     CHECK_NULL(IO_fd_fdID);
 125 
 126     init(env);
 127 }
 128 
 129 /*
 130  * Class:     java_net_TwoStacksPlainSocketImpl
 131  * Method:    socketCreate
 132  * Signature: (Z)V
 133  */
 134 JNIEXPORT void JNICALL
 135 Java_java_net_TwoStacksPlainSocketImpl_socketCreate(JNIEnv *env, jobject this,
 136                                            jboolean stream) {
 137     jobject fdObj, fd1Obj;
 138     int fd, fd1;
 139 
 140     fdObj = (*env)->GetObjectField(env, this, psi_fdID);
 141 
 142     if (IS_NULL(fdObj)) {
 143         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 144                         "null fd object");
 145         return;
 146     }
 147     fd = (int)socket(AF_INET, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);
 148     if (fd == -1) {
 149         NET_ThrowCurrent(env, "create");
 150         return;
 151     } else {
 152         /* Set socket attribute so it is not passed to any child process */
 153         SetHandleInformation((HANDLE)(UINT_PTR)fd, HANDLE_FLAG_INHERIT, FALSE);
 154         (*env)->SetIntField(env, fdObj, IO_fd_fdID, (int)fd);
 155     }
 156     if (ipv6_available()) {
 157         fd1Obj = (*env)->GetObjectField(env, this, psi_fd1ID);
 158 
 159         if (IS_NULL(fd1Obj)) {
 160             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 161                             "null fd1 object");
 162             (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
 163             NET_SocketClose(fd);
 164             return;
 165         }
 166         fd1 = (int)socket(AF_INET6, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);
 167         if (fd1 == -1) {
 168             NET_ThrowCurrent(env, "create");
 169             (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
 170             NET_SocketClose(fd);
 171             return;
 172         } else {
 173             /* Set socket attribute so it is not passed to any child process */
 174             SetHandleInformation((HANDLE)(UINT_PTR)fd1, HANDLE_FLAG_INHERIT, FALSE);
 175             (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);
 176         }
 177     } else {
 178         (*env)->SetObjectField(env, this, psi_fd1ID, NULL);
 179     }
 180 }
 181 
 182 /*
 183  * inetAddress is the address object passed to the socket connect
 184  * call.
 185  *
 186  * Class:     java_net_TwoStacksPlainSocketImpl


 434     }
 435     if (IS_NULL(iaObj)) {
 436         JNU_ThrowNullPointerException(env, "inet address argument");
 437         return;
 438     }
 439 
 440     if (NET_InetAddressToSockaddr(env, iaObj, localport,
 441                           (struct sockaddr *)&him, &len, JNI_FALSE) != 0) {
 442       return;
 443     }
 444 
 445     if (ipv6_supported) {
 446         struct ipv6bind v6bind;
 447         v6bind.addr = &him;
 448         v6bind.ipv4_fd = fd;
 449         v6bind.ipv6_fd = fd1;
 450         rv = NET_BindV6(&v6bind);
 451         if (rv != -1) {
 452             /* check if the fds have changed */
 453             if (v6bind.ipv4_fd != fd) {
 454                 fd = (int)v6bind.ipv4_fd;
 455                 if (fd == -1) {
 456                     /* socket is closed. */
 457                     (*env)->SetObjectField(env, this, psi_fdID, NULL);
 458                 } else {
 459                     /* socket was re-created */
 460                     (*env)->SetIntField(env, fdObj, IO_fd_fdID, fd);
 461                 }
 462             }
 463             if (v6bind.ipv6_fd != fd1) {
 464                 fd1 = (int)v6bind.ipv6_fd;
 465                 if (fd1 == -1) {
 466                     /* socket is closed. */
 467                     (*env)->SetObjectField(env, this, psi_fd1ID, NULL);
 468                 } else {
 469                     /* socket was re-created */
 470                     (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);
 471                 }
 472             }
 473         }
 474     } else {
 475         rv = NET_Bind(fd, (struct sockaddr *)&him, len);
 476     }
 477 
 478     if (rv == -1) {
 479         NET_ThrowCurrent(env, "JVM_Bind");
 480         return;
 481     }
 482 
 483     /* set the address */
 484     (*env)->SetObjectField(env, this, psi_addressID, iaObj);


 568 }
 569 
 570 /*
 571  * Class:     java_net_TwoStacksPlainSocketImpl
 572  * Method:    socketAccept
 573  * Signature: (Ljava/net/SocketImpl;)V
 574  */
 575 JNIEXPORT void JNICALL
 576 Java_java_net_TwoStacksPlainSocketImpl_socketAccept(JNIEnv *env, jobject this,
 577                                            jobject socket)
 578 {
 579     /* fields on this */
 580     jint port;
 581     jint timeout = (*env)->GetIntField(env, this, psi_timeoutID);
 582     jobject fdObj = (*env)->GetObjectField(env, this, psi_fdID);
 583     jobject fd1Obj = (*env)->GetObjectField(env, this, psi_fd1ID);
 584 
 585     /* the FileDescriptor field on socket */
 586     jobject socketFdObj;
 587 




 588     /* the InetAddress field on socket */
 589     jobject socketAddressObj;
 590 
 591     /* the fd int field on fdObj */
 592     jint fd=-1, fd1=-1;
 593 
 594     SOCKETADDRESS him;
 595     jint len;
 596 
 597     if (IS_NULL(fdObj) && IS_NULL(fd1Obj)) {
 598         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 599                         "Socket closed");
 600         return;
 601     }
 602     if (!IS_NULL(fdObj)) {
 603         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 604     }
 605     if (!IS_NULL(fd1Obj)) {
 606         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
 607     }


 665             len = sizeof (struct sockaddr_in);
 666         }
 667         if (timeout) {
 668             ret = NET_Timeout(fd, timeout);
 669             if (ret == 0) {
 670                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 671                                 "Accept timed out");
 672                 return;
 673             } else if (ret == -1) {
 674                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "socket closed");
 675             /* REMIND: SOCKET CLOSED PROBLEM */
 676     /*        NET_ThrowCurrent(env, "Accept failed"); */
 677                 return;
 678             } else if (ret == -2) {
 679                 JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 680                                 "operation interrupted");
 681                 return;
 682             }
 683         }
 684     }
 685     fd = (jint)accept(fd, (struct sockaddr *)&him, &len);
 686     if (fd < 0) {
 687         /* REMIND: SOCKET CLOSED PROBLEM */
 688         if (fd == -2) {
 689             JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 690                             "operation interrupted");
 691         } else {
 692             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 693                             "socket closed");
 694         }
 695         return;
 696     }
 697     (*env)->SetIntField(env, socketFdObj, IO_fd_fdID, fd);
 698 
 699     if (him.him.sa_family == AF_INET) {








 700         /*
 701          * fill up the remote peer port and address in the new socket structure
 702          */
 703         socketAddressObj = (*env)->NewObject(env, ia4_class, ia4_ctrID);
 704 



 705         if (socketAddressObj == NULL) {
 706             /*
 707              * FindClass or NewObject failed so close connection and
 708              * exist (there will be a pending exception).
 709              */
 710             NET_SocketClose(fd);
 711             return;
 712         }
 713 
 714         (*env)->SetIntField(env, socketAddressObj, ia_addressID,
 715                             ntohl(him.him4.sin_addr.s_addr));
 716         (*env)->SetIntField(env, socketAddressObj, ia_familyID, IPv4);
 717         (*env)->SetObjectField(env, socket, psi_addressID, socketAddressObj);
 718     } else {
 719         jbyteArray addr;
 720         /* AF_INET6 -> Inet6Address */
 721         socketAddressObj = (*env)->NewObject(env, ia6_class, ia6_ctrID);






 722 





 723         if (socketAddressObj == NULL) {
 724             /*
 725              * FindClass or NewObject failed so close connection and
 726              * exist (there will be a pending exception).
 727              */
 728             NET_SocketClose(fd);
 729             return;
 730         }
 731         addr = (*env)->GetObjectField (env, socketAddressObj, ia6_ipaddressID);
 732         (*env)->SetByteArrayRegion (env, addr, 0, 16, (const char *)&him.him6.sin6_addr);
 733         (*env)->SetIntField(env, socketAddressObj, ia_familyID, IPv6);
 734         (*env)->SetIntField(env, socketAddressObj, ia6_scopeidID, him.him6.sin6_scope_id);
 735     }
 736     /* fields common to AF_INET and AF_INET6 */
 737 
 738     port = ntohs ((u_short) GET_PORT (&him));
 739     (*env)->SetIntField(env, socket, psi_portID, (int)port);
 740     port = (*env)->GetIntField(env, this, psi_localportID);
 741     (*env)->SetIntField(env, socket, psi_localportID, port);
 742     (*env)->SetObjectField(env, socket, psi_addressID, socketAddressObj);


1107         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1108                         "socket already closed");
1109         return;
1110     } else {
1111         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1112     }
1113     shutdown(fd, howto);
1114 }
1115 
1116 /*
1117  * Class:     java_net_TwoStacksPlainSocketImpl
1118  * Method:    socketSendUrgentData
1119  * Signature: (B)V
1120  */
1121 JNIEXPORT void JNICALL
1122 Java_java_net_TwoStacksPlainSocketImpl_socketSendUrgentData(JNIEnv *env, jobject this,
1123                                              jint data) {
1124     /* The fd field */
1125     jobject fdObj = (*env)->GetObjectField(env, this, psi_fdID);
1126     int n, fd;
1127     unsigned char d = (unsigned char)data & 0xff;
1128 
1129     if (IS_NULL(fdObj)) {
1130         JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
1131         return;
1132     } else {
1133         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1134         /* Bug 4086704 - If the Socket associated with this file descriptor
1135          * was closed (sysCloseFD), the the file descriptor is set to -1.
1136          */
1137         if (fd == -1) {
1138             JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
1139             return;
1140         }
1141 
1142     }
1143     n = send(fd, (char *)&data, 1, MSG_OOB);
1144     if (n == JVM_IO_ERR) {
1145         NET_ThrowCurrent(env, "send");
1146         return;
1147     }