jdk-sandbox: comparison jdk/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java

equal deleted inserted replaced

-:c5be3e19fbab
+:39b3a979e600
 * questions.
 */
 package sun.net.www.protocol.http;
+import java.util.Arrays;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.ProtocolException;
 import java.net.HttpRetryException;
 import java.net.PasswordAuthentication;
 "sun.net.http.errorstream.bufferSize", 4096)).intValue();
 if (bufSize4ES <= 0) {
 bufSize4ES = 4096; // use the default
 }
-allowRestrictedHeaders = ((Boolean)java.security.AccessController.doPrivileged(
+allowRestrictedHeaders = java.security.AccessController.doPrivileged(
 new sun.security.action.GetBooleanAction(
-"sun.net.http.allowRestrictedHeaders"))).booleanValue();
+"sun.net.http.allowRestrictedHeaders")).booleanValue();
 if (!allowRestrictedHeaders) {
 restrictedHeaderSet = new HashSet<String>(restrictedHeaders.length);
 for (int i=0; i < restrictedHeaders.length; i++) {
 restrictedHeaderSet.add(restrictedHeaders[i].toLowerCase());
 }
 /* We only have a single static authenticator for now.
 * REMIND:  backwards compatibility with JDK 1.1.  Should be
 * eliminated for JDK 2.0.
 */
+@Deprecated
 private static HttpAuthenticator defaultAuth;
 /* all the headers we send
 * NOTE: do *NOT* dump out the content of 'requests' in the
 * output or stacktrace since it may contain security-sensitive
 }
 /**
 * @deprecated.  Use java.net.Authenticator.setDefault() instead.
 */
+@Deprecated
 public static void setDefaultAuthenticator(HttpAuthenticator a) {
 defaultAuth = a;
 }
 /**
 public Void run() {
 try {
 InetAddress a1 = InetAddress.getByName(h1);
 InetAddress a2 = InetAddress.getByName(h2);
 result[0] = a1.equals(a2);
-} catch(UnknownHostException e) {
+} catch(UnknownHostException | SecurityException e) {
-} catch(SecurityException e) {
 }
 return null;
 }
 });
 RETRY_MSG1, HTTP_PROXY_AUTH);
 }
 // Read comments labeled "Failed Negotiate" for details.
 boolean dontUseNegotiate = false;
-Iterator iter = responses.multiValueIterator("Proxy-Authenticate");
+Iterator<String> iter = responses.multiValueIterator("Proxy-Authenticate");
 while (iter.hasNext()) {
-String value = ((String)iter.next()).trim();
+String value = iter.next().trim();
 if (value.equalsIgnoreCase("Negotiate") ||
 value.equalsIgnoreCase("Kerberos")) {
 if (!inNegotiateProxy) {
 inNegotiateProxy = true;
 } else {
 RETRY_MSG2, HTTP_UNAUTHORIZED);
 }
 // Read comments labeled "Failed Negotiate" for details.
 boolean dontUseNegotiate = false;
-Iterator iter = responses.multiValueIterator("WWW-Authenticate");
+Iterator<String> iter = responses.multiValueIterator("WWW-Authenticate");
 while (iter.hasNext()) {
-String value = ((String)iter.next()).trim();
+String value = iter.next().trim();
 if (value.equalsIgnoreCase("Negotiate") ||
 value.equalsIgnoreCase("Kerberos")) {
 if (!inNegotiate) {
 inNegotiate = true;
 } else {
 try {
 // use reflection to get to the public
 // HttpsURLConnection instance saved in
 // DelegateHttpsURLConnection
 uconn = (URLConnection)this.getClass().getField("httpsURLConnection").get(this);
-} catch (IllegalAccessException iae) {
+} catch (IllegalAccessException |
-// ignored; use 'this'
+NoSuchFieldException e) {
-} catch (NoSuchFieldException nsfe) {
 // ignored; use 'this'
 }
 }
 CacheRequest cacheRequest =
 cacheHandler.put(uri, uconn);
 st.nextToken();
 respCode = Integer.parseInt(st.nextToken().trim());
 if (respCode == HTTP_PROXY_AUTH) {
 // Read comments labeled "Failed Negotiate" for details.
 boolean dontUseNegotiate = false;
-Iterator iter = responses.multiValueIterator("Proxy-Authenticate");
+Iterator<String> iter = responses.multiValueIterator("Proxy-Authenticate");
 while (iter.hasNext()) {
-String value = ((String)iter.next()).trim();
+String value = iter.next().trim();
 if (value.equalsIgnoreCase("Negotiate") ||
 value.equalsIgnoreCase("Kerberos")) {
 if (!inNegotiateProxy) {
 inNegotiateProxy = true;
 } else {
 /**
 * Gets the authentication for an HTTP proxy, and applies it to
 * the connection.
 */
+@SuppressWarnings("fallthrough")
 private AuthenticationInfo getHttpProxyAuthentication (AuthenticationHeader authhdr) {
 /* get authorization from authenticator */
 AuthenticationInfo ret = null;
 String raw = authhdr.raw();
 String host = http.getProxyHostUsed();
 ret = new DigestAuthentication(true, host, port, realm,
 scheme, a, params);
 }
 break;
 case NTLM:
-if (NTLMAuthenticationProxy.proxy.supported) {
+if (NTLMAuthenticationProxy.supported) {
 /* tryTransparentNTLMProxy will always be true the first
 * time around, but verify that the platform supports it
 * otherwise don't try. */
 if (tryTransparentNTLMProxy) {
 tryTransparentNTLMProxy =
-NTLMAuthenticationProxy.proxy.supportsTransparentAuth;
+NTLMAuthenticationProxy.supportsTransparentAuth;
 }
 a = null;
 if (tryTransparentNTLMProxy) {
 logger.finest("Trying Transparent NTLM authentication");
 } else {
 case KERBEROS:
 ret = new NegotiateAuthentication(new HttpCallerInfo(authhdr.getHttpCallerInfo(), "Kerberos"));
 break;
 case UNKNOWN:
 logger.finest("Unknown/Unsupported authentication scheme: " + scheme);
+/*fall through*/
 default:
 throw new AssertionError("should not reach here");
 }
 }
 // For backwards compatibility, we also try defaultAuth
 * Gets the authentication for an HTTP server, and applies it to
 * the connection.
 * @param authHdr the AuthenticationHeader which tells what auth scheme is
 * prefered.
 */
+@SuppressWarnings("fallthrough")
 private AuthenticationInfo getServerAuthentication (AuthenticationHeader authhdr) {
 /* get authorization from authenticator */
 AuthenticationInfo ret = null;
 String raw = authhdr.raw();
 /* When we get an NTLM auth from cache, don't set any special headers */
 digestparams = new DigestAuthentication.Parameters();
 ret = new DigestAuthentication(false, url, realm, scheme, a, digestparams);
 }
 break;
 case NTLM:
-if (NTLMAuthenticationProxy.proxy.supported) {
+if (NTLMAuthenticationProxy.supported) {
 URL url1;
 try {
 url1 = new URL (url, "/"); /* truncate the path */
 } catch (Exception e) {
 url1 = url;
 /* tryTransparentNTLMServer will always be true the first
 * time around, but verify that the platform supports it
 * otherwise don't try. */
 if (tryTransparentNTLMServer) {
 tryTransparentNTLMServer =
-NTLMAuthenticationProxy.proxy.supportsTransparentAuth;
+NTLMAuthenticationProxy.supportsTransparentAuth;
 /* If the platform supports transparent authentication
 * then check if we are in a secure environment
 * whether, or not, we should try transparent authentication.*/
 if (tryTransparentNTLMServer) {
 tryTransparentNTLMServer =
-NTLMAuthenticationProxy.proxy.isTrustedSite(url);
+NTLMAuthenticationProxy.isTrustedSite(url);
 }
 }
 a = null;
 if (tryTransparentNTLMServer) {
 logger.finest("Trying Transparent NTLM authentication");
 tryTransparentNTLMServer = false;
 }
 break;
 case UNKNOWN:
 logger.finest("Unknown/Unsupported authentication scheme: " + scheme);
+/*fall through*/
 default:
 throw new AssertionError("should not reach here");
 }
 }
 }
 /*
 * The cookies in the requests message headers may have
 * been modified. Use the saved user cookies instead.
 */
-Map userCookiesMap = null;
+Map<String, List<String>> userCookiesMap = null;
 if (userCookies != null || userCookies2 != null) {
-userCookiesMap = new HashMap();
+userCookiesMap = new HashMap<>();
 if (userCookies != null) {
-userCookiesMap.put("Cookie", userCookies);
+userCookiesMap.put("Cookie", Arrays.asList(userCookies));
 }
 if (userCookies2 != null) {
-userCookiesMap.put("Cookie2", userCookies2);
+userCookiesMap.put("Cookie2", Arrays.asList(userCookies2));
 }
 }
 return requests.filterAndAddHeaders(EXCLUDE_HEADERS2, userCookiesMap);
 }

changeset 10596	39b3a979e600
parent 10136	af9631156b25
child 10701	2c8dde454979