Print this page


Split Close
Expand all
Collapse all
          --- old/src/windows/native/java/net/TwoStacksPlainSocketImpl.c
          +++ new/src/windows/native/java/net/TwoStacksPlainSocketImpl.c
↓ open down ↓ 114 lines elided ↑ open up ↑
 115  115      CHECK_NULL(psi_localportID);
 116  116      psi_timeoutID = (*env)->GetFieldID(env, cls, "timeout", "I");
 117  117      CHECK_NULL(psi_timeoutID);
 118  118      psi_trafficClassID = (*env)->GetFieldID(env, cls, "trafficClass", "I");
 119  119      CHECK_NULL(psi_trafficClassID);
 120  120      psi_serverSocketID = (*env)->GetFieldID(env, cls, "serverSocket",
 121  121                                              "Ljava/net/ServerSocket;");
 122  122      CHECK_NULL(psi_serverSocketID);
 123  123      IO_fd_fdID = NET_GetFileDescriptorID(env);
 124  124      CHECK_NULL(IO_fd_fdID);
      125 +
      126 +    init(env);
 125  127  }
 126  128  
 127  129  /*
 128  130   * Class:     java_net_TwoStacksPlainSocketImpl
 129  131   * Method:    socketCreate
 130  132   * Signature: (Z)V
 131  133   */
 132  134  JNIEXPORT void JNICALL
 133  135  Java_java_net_TwoStacksPlainSocketImpl_socketCreate(JNIEnv *env, jobject this,
 134  136                                             jboolean stream) {
 135  137      jobject fdObj, fd1Obj;
 136  138      int fd, fd1;
 137  139  
 138  140      fdObj = (*env)->GetObjectField(env, this, psi_fdID);
 139  141  
 140  142      if (IS_NULL(fdObj)) {
 141  143          JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 142  144                          "null fd object");
 143  145          return;
 144  146      }
 145      -    fd = socket(AF_INET, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);
      147 +    fd = (int)socket(AF_INET, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);
 146  148      if (fd == -1) {
 147  149          NET_ThrowCurrent(env, "create");
 148  150          return;
 149  151      } else {
 150  152          /* Set socket attribute so it is not passed to any child process */
 151  153          SetHandleInformation((HANDLE)(UINT_PTR)fd, HANDLE_FLAG_INHERIT, FALSE);
 152  154          (*env)->SetIntField(env, fdObj, IO_fd_fdID, (int)fd);
 153  155      }
 154  156      if (ipv6_available()) {
 155  157          fd1Obj = (*env)->GetObjectField(env, this, psi_fd1ID);
 156  158  
 157  159          if (IS_NULL(fd1Obj)) {
 158  160              JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 159  161                              "null fd1 object");
 160  162              (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
 161  163              NET_SocketClose(fd);
 162  164              return;
 163  165          }
 164      -        fd1 = socket(AF_INET6, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);
      166 +        fd1 = (int)socket(AF_INET6, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);
 165  167          if (fd1 == -1) {
 166  168              NET_ThrowCurrent(env, "create");
 167  169              (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
 168  170              NET_SocketClose(fd);
 169  171              return;
 170  172          } else {
 171  173              /* Set socket attribute so it is not passed to any child process */
 172  174              SetHandleInformation((HANDLE)(UINT_PTR)fd1, HANDLE_FLAG_INHERIT, FALSE);
 173  175              (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);
 174  176          }
↓ open down ↓ 267 lines elided ↑ open up ↑
 442  444  
 443  445      if (ipv6_supported) {
 444  446          struct ipv6bind v6bind;
 445  447          v6bind.addr = &him;
 446  448          v6bind.ipv4_fd = fd;
 447  449          v6bind.ipv6_fd = fd1;
 448  450          rv = NET_BindV6(&v6bind);
 449  451          if (rv != -1) {
 450  452              /* check if the fds have changed */
 451  453              if (v6bind.ipv4_fd != fd) {
 452      -                fd = v6bind.ipv4_fd;
      454 +                fd = (int)v6bind.ipv4_fd;
 453  455                  if (fd == -1) {
 454  456                      /* socket is closed. */
 455  457                      (*env)->SetObjectField(env, this, psi_fdID, NULL);
 456  458                  } else {
 457  459                      /* socket was re-created */
 458  460                      (*env)->SetIntField(env, fdObj, IO_fd_fdID, fd);
 459  461                  }
 460  462              }
 461  463              if (v6bind.ipv6_fd != fd1) {
 462      -                fd1 = v6bind.ipv6_fd;
      464 +                fd1 = (int)v6bind.ipv6_fd;
 463  465                  if (fd1 == -1) {
 464  466                      /* socket is closed. */
 465  467                      (*env)->SetObjectField(env, this, psi_fd1ID, NULL);
 466  468                  } else {
 467  469                      /* socket was re-created */
 468  470                      (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);
 469  471                  }
 470  472              }
 471  473          }
 472  474      } else {
↓ open down ↓ 103 lines elided ↑ open up ↑
 576  578  {
 577  579      /* fields on this */
 578  580      jint port;
 579  581      jint timeout = (*env)->GetIntField(env, this, psi_timeoutID);
 580  582      jobject fdObj = (*env)->GetObjectField(env, this, psi_fdID);
 581  583      jobject fd1Obj = (*env)->GetObjectField(env, this, psi_fd1ID);
 582  584  
 583  585      /* the FileDescriptor field on socket */
 584  586      jobject socketFdObj;
 585  587  
 586      -    /* cache the Inet4/6Address classes */
 587      -    static jclass inet4Cls;
 588      -    static jclass inet6Cls;
 589      -
 590  588      /* the InetAddress field on socket */
 591  589      jobject socketAddressObj;
 592  590  
 593  591      /* the fd int field on fdObj */
 594  592      jint fd=-1, fd1=-1;
 595  593  
 596  594      SOCKETADDRESS him;
 597  595      jint len;
 598  596  
 599  597      if (IS_NULL(fdObj) && IS_NULL(fd1Obj)) {
↓ open down ↓ 77 lines elided ↑ open up ↑
 677  675              /* REMIND: SOCKET CLOSED PROBLEM */
 678  676      /*        NET_ThrowCurrent(env, "Accept failed"); */
 679  677                  return;
 680  678              } else if (ret == -2) {
 681  679                  JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 682  680                                  "operation interrupted");
 683  681                  return;
 684  682              }
 685  683          }
 686  684      }
 687      -    fd = accept(fd, (struct sockaddr *)&him, &len);
      685 +    fd = (jint)accept(fd, (struct sockaddr *)&him, &len);
 688  686      if (fd < 0) {
 689  687          /* REMIND: SOCKET CLOSED PROBLEM */
 690  688          if (fd == -2) {
 691  689              JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 692  690                              "operation interrupted");
 693  691          } else {
 694  692              JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 695  693                              "socket closed");
 696  694          }
 697  695          return;
 698  696      }
 699  697      (*env)->SetIntField(env, socketFdObj, IO_fd_fdID, fd);
 700  698  
 701  699      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  700          /*
 711  701           * fill up the remote peer port and address in the new socket structure
 712  702           */
 713      -        if (inet4Cls != NULL) {
 714      -            socketAddressObj = (*env)->NewObject(env, inet4Cls, ia4_ctrID);
 715      -        } else {
 716      -            socketAddressObj = NULL;
 717      -        }
      703 +        socketAddressObj = (*env)->NewObject(env, ia4_class, ia4_ctrID);
      704 +
 718  705          if (socketAddressObj == NULL) {
 719  706              /*
 720  707               * FindClass or NewObject failed so close connection and
 721  708               * exist (there will be a pending exception).
 722  709               */
 723  710              NET_SocketClose(fd);
 724  711              return;
 725  712          }
 726  713  
 727  714          (*env)->SetIntField(env, socketAddressObj, ia_addressID,
 728  715                              ntohl(him.him4.sin_addr.s_addr));
 729  716          (*env)->SetIntField(env, socketAddressObj, ia_familyID, IPv4);
 730  717          (*env)->SetObjectField(env, socket, psi_addressID, socketAddressObj);
 731  718      } else {
 732  719          jbyteArray addr;
 733  720          /* 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      -        }
      721 +        socketAddressObj = (*env)->NewObject(env, ia6_class, ia6_ctrID);
 741  722  
 742      -        if (inet6Cls != NULL) {
 743      -            socketAddressObj = (*env)->NewObject(env, inet6Cls, ia6_ctrID);
 744      -        } else {
 745      -            socketAddressObj = NULL;
 746      -        }
 747  723          if (socketAddressObj == NULL) {
 748  724              /*
 749  725               * FindClass or NewObject failed so close connection and
 750  726               * exist (there will be a pending exception).
 751  727               */
 752  728              NET_SocketClose(fd);
 753  729              return;
 754  730          }
 755  731          addr = (*env)->GetObjectField (env, socketAddressObj, ia6_ipaddressID);
 756  732          (*env)->SetByteArrayRegion (env, addr, 0, 16, (const char *)&him.him6.sin6_addr);
↓ open down ↓ 384 lines elided ↑ open up ↑
1141 1117   * Class:     java_net_TwoStacksPlainSocketImpl
1142 1118   * Method:    socketSendUrgentData
1143 1119   * Signature: (B)V
1144 1120   */
1145 1121  JNIEXPORT void JNICALL
1146 1122  Java_java_net_TwoStacksPlainSocketImpl_socketSendUrgentData(JNIEnv *env, jobject this,
1147 1123                                               jint data) {
1148 1124      /* The fd field */
1149 1125      jobject fdObj = (*env)->GetObjectField(env, this, psi_fdID);
1150 1126      int n, fd;
1151      -    unsigned char d = data & 0xff;
     1127 +    unsigned char d = (unsigned char)data & 0xff;
1152 1128  
1153 1129      if (IS_NULL(fdObj)) {
1154 1130          JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
1155 1131          return;
1156 1132      } else {
1157 1133          fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1158 1134          /* Bug 4086704 - If the Socket associated with this file descriptor
1159 1135           * was closed (sysCloseFD), the the file descriptor is set to -1.
1160 1136           */
1161 1137          if (fd == -1) {
↓ open down ↓ 15 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX