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

equal deleted inserted replaced

-:e89c7aaf2906
+:8595871a5446
 import java.util.TimeZone;
 import java.net.MalformedURLException;
 import java.nio.ByteBuffer;
 import java.util.Objects;
 import java.util.Properties;
+import java.util.concurrent.locks.ReentrantLock;
 import static sun.net.www.protocol.http.AuthScheme.BASIC;
 import static sun.net.www.protocol.http.AuthScheme.DIGEST;
 import static sun.net.www.protocol.http.AuthScheme.NTLM;
 import static sun.net.www.protocol.http.AuthScheme.NEGOTIATE;
 import static sun.net.www.protocol.http.AuthScheme.KERBEROS;
 */
 public class HttpURLConnection extends java.net.HttpURLConnection {
-static String HTTP_CONNECT = "CONNECT";
+static final String HTTP_CONNECT = "CONNECT";
 static final String version;
 public static final String userAgent;
 /* max # of allowed re-directs */
 /* Headers and request method cannot be changed
 * once this flag is set in :-
 *     - getOutputStream()
 *     - getInputStream())
 *     - connect()
-* Access synchronized on this.
+* Access synchronized on connectionLock.
 */
 private boolean connecting = false;
 /* The following two fields are only used with Digest Authentication */
 String domain;      /* The list of authentication domains */
 String serverAuthKey, proxyAuthKey;
 /* Progress source */
 protected ProgressSource pi;
+/* Lock */
+final ReentrantLock connectionLock = new ReentrantLock();
 /* all the response headers we get back */
 private MessageHeader responses;
 /* the stream _from_ the server */
 private InputStream inputStream = null;
 public void authObj(Object authObj) {
 this.authObj = authObj;
 }
 @Override
-public synchronized void setAuthenticator(Authenticator auth) {
+public void setAuthenticator(Authenticator auth) {
-if (connecting || connected) {
+connectionLock.lock();
-throw new IllegalStateException(
+try {
-"Authenticator must be set before connecting");
+if (connecting || connected) {
-}
+throw new IllegalStateException(
-authenticator = Objects.requireNonNull(auth);
+"Authenticator must be set before connecting");
-authenticatorKey = AuthenticatorKeys.getKey(authenticator);
+}
+authenticator = Objects.requireNonNull(auth);
+authenticatorKey = AuthenticatorKeys.getKey(authenticator);
+} finally {
+connectionLock.unlock();
+}
 }
 public String getAuthenticatorKey() {
 String k = authenticatorKey;
 if (k == null) return AuthenticatorKeys.getKey(authenticator);
 "Illegal character(s) in message header value: " + value);
 }
 }
 }
-public synchronized void setRequestMethod(String method)
+public void setRequestMethod(String method)
 throws ProtocolException {
-if (connecting) {
+connectionLock.lock();
-throw new IllegalStateException("connect in progress");
+try {
-}
+if (connecting) {
-super.setRequestMethod(method);
+throw new IllegalStateException("connect in progress");
+}
+super.setRequestMethod(method);
+} finally {
+connectionLock.unlock();
+}
 }
 /* adds the standard key/val pairs to reqests if necessary & write to
 * given PrintStream
 */
 String.valueOf(fixedContentLength));
 }
 }
 } else if (poster != null) {
 /* add Content-Length & POST/PUT data */
+// safe to synchronize on poster: this is
+// a simple subclass of ByteArrayOutputStream
 synchronized (poster) {
 /* close it, so no more data can be added */
 poster.close();
 requests.set("Content-Length",
 String.valueOf(poster.size()));
 }
 // overridden in HTTPS subclass
 public void connect() throws IOException {
-synchronized (this) {
+connectionLock.lock();
+try {
 connecting = true;
+} finally {
+connectionLock.unlock();
 }
 plainConnect();
 }
 private boolean checkReuseConnection () {
 }
 return host + ":" + Integer.toString(port);
 }
 protected void plainConnect()  throws IOException {
-synchronized (this) {
+connectionLock.lock();
+try {
 if (connected) {
 return;
 }
+} finally {
+connectionLock.unlock();
 }
 SocketPermission p = URLtoSocketPermission(this.url);
 if (p != null) {
 try {
 AccessController.doPrivilegedWithCombiner(
 * Disallowed:
 * - get input, [read input,] get output, [write output]
 */
 @Override
-public synchronized OutputStream getOutputStream() throws IOException {
+public OutputStream getOutputStream() throws IOException {
-connecting = true;
+connectionLock.lock();
-SocketPermission p = URLtoSocketPermission(this.url);
+try {
+connecting = true;
-if (p != null) {
+SocketPermission p = URLtoSocketPermission(this.url);
-try {
-return AccessController.doPrivilegedWithCombiner(
+if (p != null) {
-new PrivilegedExceptionAction<>() {
+try {
-public OutputStream run() throws IOException {
+return AccessController.doPrivilegedWithCombiner(
-return getOutputStream0();
+new PrivilegedExceptionAction<>() {
-}
+public OutputStream run() throws IOException {
-}, null, p
+return getOutputStream0();
-);
+}
-} catch (PrivilegedActionException e) {
+}, null, p
-throw (IOException) e.getException();
+);
-}
+} catch (PrivilegedActionException e) {
-} else {
+throw (IOException) e.getException();
-return getOutputStream0();
+}
-}
+} else {
-}
+return getOutputStream0();
+}
-private synchronized OutputStream getOutputStream0() throws IOException {
+} finally {
+connectionLock.unlock();
+}
+}
+private OutputStream getOutputStream0() throws IOException {
+assert connectionLock.isHeldByCurrentThread();
 try {
 if (!doOutput) {
 throw new ProtocolException("cannot write to a URLConnection"
 + " if doOutput=false - call setDoOutput(true)");
 }
 private void setCookieHeader() throws IOException {
 if (cookieHandler != null) {
 // we only want to capture the user defined Cookies once, as
 // they cannot be changed by user code after we are connected,
 // only internally.
-synchronized (this) {
+if (setUserCookies) {
-if (setUserCookies) {
+// we should only reach here when called from
-int k = requests.getKey("Cookie");
+// writeRequest, which in turn is only called by
-if (k != -1)
+// getInputStream0
-userCookies = requests.getValue(k);
+assert connectionLock.isHeldByCurrentThread();
-k = requests.getKey("Cookie2");
+int k = requests.getKey("Cookie");
 if (k != -1)
-userCookies2 = requests.getValue(k);
+userCookies = requests.getValue(k);
-setUserCookies = false;
+k = requests.getKey("Cookie2");
-}
+if (k != -1)
-}
+userCookies2 = requests.getValue(k);
+setUserCookies = false;
+}
 // remove old Cookie header before setting new one.
 requests.remove("Cookie");
 requests.remove("Cookie2");
 } // end of getting cookies
 }
 @Override
-public synchronized InputStream getInputStream() throws IOException {
+public InputStream getInputStream() throws IOException {
-connecting = true;
+connectionLock.lock();
-SocketPermission p = URLtoSocketPermission(this.url);
+try {
+connecting = true;
-if (p != null) {
+SocketPermission p = URLtoSocketPermission(this.url);
-try {
-return AccessController.doPrivilegedWithCombiner(
+if (p != null) {
-new PrivilegedExceptionAction<>() {
+try {
-public InputStream run() throws IOException {
+return AccessController.doPrivilegedWithCombiner(
-return getInputStream0();
+new PrivilegedExceptionAction<>() {
-}
+public InputStream run() throws IOException {
-}, null, p
+return getInputStream0();
-);
+}
-} catch (PrivilegedActionException e) {
+}, null, p
-throw (IOException) e.getException();
+);
-}
+} catch (PrivilegedActionException e) {
-} else {
+throw (IOException) e.getException();
-return getInputStream0();
+}
+} else {
+return getInputStream0();
+}
+} finally {
+connectionLock.unlock();
 }
 }
 @SuppressWarnings("empty-statement")
-private synchronized InputStream getInputStream0() throws IOException {
+private InputStream getInputStream0() throws IOException {
+assert connectionLock.isHeldByCurrentThread();
 if (!doInput) {
 throw new ProtocolException("Cannot read from URLConnection"
 + " if doInput=false (call setDoInput(true))");
 }
 }
 /**
 * establish a tunnel through proxy server
 */
-public synchronized void doTunneling() throws IOException {
+public void doTunneling() throws IOException {
+connectionLock.lock();
+try {
+doTunneling0();
+} finally{
+connectionLock.unlock();
+}
+}
+private void doTunneling0() throws IOException {
 int retryTunnel = 0;
 String statusLine = "";
 int respCode = 0;
 AuthenticationInfo proxyAuthentication = null;
 String proxyHost = null;
 }
 /**
 * Gets the authentication for an HTTP server, and applies it to
 * the connection.
-* @param authHdr the AuthenticationHeader which tells what auth scheme is
+* @param authhdr the AuthenticationHeader which tells what auth scheme is
 * preferred.
 */
 @SuppressWarnings("fallthrough")
 private AuthenticationInfo getServerAuthentication (AuthenticationHeader authhdr) {
 /* get authorization from authenticator */
 * Sets request property. If a property with the key already
 * exists, overwrite its value with the new value.
 * @param value the value to be set
 */
 @Override
-public synchronized void setRequestProperty(String key, String value) {
+public void setRequestProperty(String key, String value) {
-if (connected || connecting)
+connectionLock.lock();
-throw new IllegalStateException("Already connected");
+try {
-if (key == null)
+if (connected || connecting)
-throw new NullPointerException ("key is null");
+throw new IllegalStateException("Already connected");
+if (key == null)
-if (isExternalMessageHeaderAllowed(key, value)) {
+throw new NullPointerException("key is null");
-requests.set(key, value);
-if (!key.equalsIgnoreCase("Content-Type")) {
+if (isExternalMessageHeaderAllowed(key, value)) {
-userHeaders.set(key, value);
+requests.set(key, value);
-}
+if (!key.equalsIgnoreCase("Content-Type")) {
+userHeaders.set(key, value);
+}
+}
+} finally {
+connectionLock.unlock();
 }
 }
 MessageHeader getUserSetHeaders() {
 return userHeaders;
 * existing values associated with the same key.
 *
 * @param   key     the keyword by which the request is known
 *                  (e.g., "<code>accept</code>").
 * @param   value  the value associated with it.
-* @see #getRequestProperties(java.lang.String)
+* @see #getRequestProperty(java.lang.String)
 * @since 1.4
 */
 @Override
-public synchronized void addRequestProperty(String key, String value) {
+public void addRequestProperty(String key, String value) {
-if (connected || connecting)
+connectionLock.lock();
-throw new IllegalStateException("Already connected");
+try {
-if (key == null)
+if (connected || connecting)
-throw new NullPointerException ("key is null");
+throw new IllegalStateException("Already connected");
+if (key == null)
-if (isExternalMessageHeaderAllowed(key, value)) {
+throw new NullPointerException("key is null");
-requests.add(key, value);
-if (!key.equalsIgnoreCase("Content-Type")) {
+if (isExternalMessageHeaderAllowed(key, value)) {
+requests.add(key, value);
+if (!key.equalsIgnoreCase("Content-Type")) {
 userHeaders.add(key, value);
 }
+}
+} finally {
+connectionLock.unlock();
 }
 }
 //
 // Set a property for authentication.  This can safely disregard
 // the connected test.
 //
 public void setAuthenticationProperty(String key, String value) {
-checkMessageHeader(key, value);
+// use lock here to avoid the need for external synchronization
-requests.set(key, value);
+// in AuthenticationInfo subclasses
+connectionLock.lock();
+try {
+checkMessageHeader(key, value);
+requests.set(key, value);
+} finally {
+connectionLock.unlock();
+}
 }
 @Override
-public synchronized String getRequestProperty (String key) {
+public String getRequestProperty (String key) {
-if (key == null) {
+connectionLock.lock();
-return null;
+try {
-}
+if (key == null) {
-// don't return headers containing security sensitive information
-for (int i=0; i < EXCLUDE_HEADERS.length; i++) {
-if (key.equalsIgnoreCase(EXCLUDE_HEADERS[i])) {
 return null;
 }
-}
-if (!setUserCookies) {
+// don't return headers containing security sensitive information
-if (key.equalsIgnoreCase("Cookie")) {
+for (int i = 0; i < EXCLUDE_HEADERS.length; i++) {
-return userCookies;
+if (key.equalsIgnoreCase(EXCLUDE_HEADERS[i])) {
-}
+return null;
-if (key.equalsIgnoreCase("Cookie2")) {
+}
-return userCookies2;
+}
-}
+if (!setUserCookies) {
-}
+if (key.equalsIgnoreCase("Cookie")) {
-return requests.findValue(key);
+return userCookies;
+}
+if (key.equalsIgnoreCase("Cookie2")) {
+return userCookies2;
+}
+}
+return requests.findValue(key);
+} finally {
+connectionLock.unlock();
+}
 }
 /**
 * Returns an unmodifiable Map of general request
 * properties for this connection. The Map keys
 * @return  a Map of the general request properties for this connection.
 * @throws IllegalStateException if already connected
 * @since 1.4
 */
 @Override
-public synchronized Map<String, List<String>> getRequestProperties() {
+public Map<String, List<String>> getRequestProperties() {
-if (connected)
+connectionLock.lock();
-throw new IllegalStateException("Already connected");
+try {
+if (connected)
-// exclude headers containing security-sensitive info
+throw new IllegalStateException("Already connected");
-if (setUserCookies) {
-return requests.getHeaders(EXCLUDE_HEADERS);
+// exclude headers containing security-sensitive info
-}
+if (setUserCookies) {
-/*
+return requests.getHeaders(EXCLUDE_HEADERS);
-* The cookies in the requests message headers may have
+}
-* been modified. Use the saved user cookies instead.
+/*
-*/
+* The cookies in the requests message headers may have
-Map<String, List<String>> userCookiesMap = null;
+* been modified. Use the saved user cookies instead.
-if (userCookies != null || userCookies2 != null) {
+*/
-userCookiesMap = new HashMap<>();
+Map<String, List<String>> userCookiesMap = null;
-if (userCookies != null) {
+if (userCookies != null || userCookies2 != null) {
-userCookiesMap.put("Cookie", Arrays.asList(userCookies));
+userCookiesMap = new HashMap<>();
-}
+if (userCookies != null) {
-if (userCookies2 != null) {
+userCookiesMap.put("Cookie", Arrays.asList(userCookies));
-userCookiesMap.put("Cookie2", Arrays.asList(userCookies2));
+}
-}
+if (userCookies2 != null) {
-}
+userCookiesMap.put("Cookie2", Arrays.asList(userCookies2));
-return requests.filterAndAddHeaders(EXCLUDE_HEADERS2, userCookiesMap);
+}
+}
+return requests.filterAndAddHeaders(EXCLUDE_HEADERS2, userCookiesMap);
+} finally {
+connectionLock.unlock();
+}
 }
 @Override
 public void setConnectTimeout(int timeout) {
 if (timeout < 0)
 *
 * @param timeout an <code>int</code> that specifies the timeout
 * value to be used in milliseconds
 * @throws IllegalArgumentException if the timeout parameter is negative
 *
-* @see java.net.URLConnectiongetReadTimeout()
+* @see java.net.URLConnection#getReadTimeout()
 * @see java.io.InputStream#read()
 * @since 1.5
 */
 @Override
 public void setReadTimeout(int timeout) {
 * @param   readlimit   the maximum limit of bytes that can be read before
 *                      the mark position becomes invalid.
 * @see     java.io.FilterInputStream#in
 * @see     java.io.FilterInputStream#reset()
 */
+// safe to use synchronized here: super method is synchronized too
 @Override
 public synchronized void mark(int readlimit) {
 super.mark(readlimit);
 if (cacheRequest != null) {
 marked = true;
 * @exception  IOException  if the stream has not been marked or if the
 *               mark has been invalidated.
 * @see        java.io.FilterInputStream#in
 * @see        java.io.FilterInputStream#mark(int)
 */
+// safe to use synchronized here: super method is synchronized too
 @Override
 public synchronized void reset() throws IOException {
 super.reset();
 if (cacheRequest != null) {
 marked = false;

branch	JDK-8229867-branch
changeset 57968	8595871a5446
parent 57879	095c2f21dd10