jdk-sandbox: comparison src/java.net.http/share/classes/java/net/http/HttpResponse.java

equal deleted inserted replaced

-:dd867826d55b
+:4f92b988600e
 import java.net.URI;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.nio.channels.FileChannel;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.nio.file.OpenOption;
 import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import jdk.internal.net.http.LineSubscriberAdapter;
 import jdk.internal.net.http.ResponseBodyHandlers.FileDownloadBodyHandler;
 import jdk.internal.net.http.ResponseBodyHandlers.PathBodyHandler;
 import jdk.internal.net.http.ResponseBodyHandlers.PushPromisesHandlerWithMap;
 import jdk.internal.net.http.ResponseSubscribers;
+import jdk.internal.net.http.ResponseSubscribers.PathSubscriber;
+import static java.nio.file.StandardOpenOption.*;
 import static jdk.internal.net.http.common.Utils.charsetFrom;
 /**
 * An HTTP response.
 *
 *
 * <p> When the {@code HttpResponse} object is returned, the body has
 * been completely written to the file, and {@link #body()} returns a
 * reference to its {@link Path}.
 *
-* @param file the filename to store the body in
+* <p> Security manager permission checks are performed in this factory
+* method, when a {@code BodyHandler} is created. Care must be taken
+* that the {@code BodyHandler} is not shared with untrusted code.
+*
+* @param file the file to store the body in
 * @param openOptions any options to use when opening/creating the file
 * @return a response body handler
+* @throws IllegalArgumentException if an invalid set of open options
+*          are specified
 * @throws SecurityException If a security manager has been installed
 *          and it denies {@link SecurityManager#checkWrite(String)
-*          write access} to the file. The {@link
+*          write access} to the file.
-*          SecurityManager#checkDelete(String) checkDelete} method is
-*          invoked to check delete access if the file is opened with
-*          the {@code DELETE_ON_CLOSE} option.
 */
 public static BodyHandler<Path> asFile(Path file, OpenOption... openOptions) {
 Objects.requireNonNull(file);
 List<OpenOption> opts = List.of(openOptions);
+if (opts.contains(DELETE_ON_CLOSE) || opts.contains(READ)) {
+// these options make no sense, since the FileChannel is not exposed
+throw new IllegalArgumentException("invalid openOptions: " + opts);
+}
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 String fn = pathForSecurityCheck(file);
 sm.checkWrite(fn);
-if (opts.contains(StandardOpenOption.DELETE_ON_CLOSE))
-sm.checkDelete(fn);
-if (opts.contains(StandardOpenOption.READ))
-sm.checkRead(fn);
 }
-return new PathBodyHandler(file, openOptions);
+return new PathBodyHandler(file, opts);
 }
 /**
 * Returns a {@code BodyHandler<Path>} that returns a
-* {@link BodySubscriber BodySubscriber}{@code <Path>} obtained from
+* {@link BodySubscriber BodySubscriber}{@code <Path>}.
-* {@link BodySubscriber#asFile(Path) BodySubscriber.asFile(Path)}.
+*
-*
+* <p> Equivalent to: {@code asFile(file, CREATE, WRITE)}
-* <p> When the {@code HttpResponse} object is returned, the body has
+*
-* been completely written to the file, and {@link #body()} returns a
+* <p> Security manager permission checks are performed in this factory
-* reference to its {@link Path}.
+* method, when a {@code BodyHandler} is created. Care must be taken
+* that the {@code BodyHandler} is not shared with untrusted code.
 *
 * @param file the file to store the body in
 * @return a response body handler
-* @throws SecurityException if a security manager has been installed
+* @throws SecurityException If a security manager has been installed
 *          and it denies {@link SecurityManager#checkWrite(String)
-*          write access} to the file
+*          write access} to the file.
 */
 public static BodyHandler<Path> asFile(Path file) {
-return BodyHandler.asFile(file, StandardOpenOption.CREATE,
+return BodyHandler.asFile(file, CREATE, WRITE);
-StandardOpenOption.WRITE);
 }
 /**
 * Returns a {@code BodyHandler<Path>} that returns a
 * {@link BodySubscriber BodySubscriber}&lt;{@link Path}&gt;
 * {@code Path} object for the file. The returned {@code Path} is the
 * combination of the supplied directory name and the file name supplied
 * by the server. If the destination directory does not exist or cannot
 * be written to, then the response will fail with an {@link IOException}.
 *
+* <p> Security manager permission checks are performed in this factory
+* method, when a {@code BodyHandler} is created. Care must be taken
+* that the {@code BodyHandler} is not shared with untrusted code.
+*
 * @param directory the directory to store the file in
-* @param openOptions open options
+* @param openOptions open options used when opening the file
 * @return a response body handler
+* @throws IllegalArgumentException if the given path does not exist,
+*          is not a directory, is not writable, or if an invalid set
+*          of open options are specified
 * @throws SecurityException If a security manager has been installed
-*          and it denies {@link SecurityManager#checkWrite(String)
+*          and it denies {@linkplain SecurityManager#checkRead(String)
-*          write access} to the file. The {@link
+*          read access} or {@linkplain SecurityManager#checkWrite(String)
-*          SecurityManager#checkDelete(String) checkDelete} method is
+*          write access} to the directory.
-*          invoked to check delete access if the file is opened with
+*/
-*          the {@code DELETE_ON_CLOSE} option.
-*/
-//####: check if the dir exists and is writable??
 public static BodyHandler<Path> asFileDownload(Path directory,
 OpenOption... openOptions) {
 Objects.requireNonNull(directory);
 List<OpenOption> opts = List.of(openOptions);
+if (opts.contains(DELETE_ON_CLOSE)) {
+throw new IllegalArgumentException("invalid option: " + DELETE_ON_CLOSE);
+}
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 String fn = pathForSecurityCheck(directory);
 sm.checkWrite(fn);
-if (opts.contains(StandardOpenOption.DELETE_ON_CLOSE))
+sm.checkRead(fn);
-sm.checkDelete(fn);
-if (opts.contains(StandardOpenOption.READ))
-sm.checkRead(fn);
 }
-return new FileDownloadBodyHandler(directory, openOptions);
+if (Files.notExists(directory))
+throw new IllegalArgumentException("non-existent directory: " + directory);
+if (!Files.isDirectory(directory))
+throw new IllegalArgumentException("not a directory: " + directory);
+if (!Files.isWritable(directory))
+throw new IllegalArgumentException("non-writable directory: " + directory);
+return new FileDownloadBodyHandler(directory, opts);
 }
 /**
 * Returns a {@code BodyHandler<InputStream>} that returns a
 * {@link BodySubscriber BodySubscriber}{@code <InputStream>} obtained
 return new ResponseSubscribers.ByteArraySubscriber<>(
 Function.identity() // no conversion
 );
 }
-// no security check
-private static BodySubscriber<Path> asFileImpl(Path file, OpenOption... openOptions) {
-return new ResponseSubscribers.PathSubscriber(file, openOptions);
-}
 /**
 * Returns a {@code BodySubscriber} which stores the response body in a
 * file opened with the given options and name. The file will be opened
 * with the given options using {@link FileChannel#open(Path,OpenOption...)
 * FileChannel.open} just before the body is read. Any exception thrown
 * BodyHandler) HttpClient::sendAsync} as appropriate.
 *
 * <p> The {@link HttpResponse} using this subscriber is available after
 * the entire response has been read.
 *
+* <p> Security manager permission checks are performed in this factory
+* method, when a {@code BodySubscriber} is created. Care must be taken
+* that the {@code BodyHandler} is not shared with untrusted code.
+*
 * @param file the file to store the body in
 * @param openOptions the list of options to open the file with
 * @return a body subscriber
-* @throws SecurityException If a security manager has been installed
+* @throws IllegalArgumentException if an invalid set of open options
+*          are specified
+* @throws SecurityException if a security manager has been installed
 *          and it denies {@link SecurityManager#checkWrite(String)
-*          write access} to the file. The {@link
+*          write access} to the file
-*          SecurityManager#checkDelete(String) checkDelete} method is
-*          invoked to check delete access if the file is opened with the
-*          {@code DELETE_ON_CLOSE} option.
 */
 public static BodySubscriber<Path> asFile(Path file, OpenOption... openOptions) {
 Objects.requireNonNull(file);
 List<OpenOption> opts = List.of(openOptions);
+if (opts.contains(DELETE_ON_CLOSE) || opts.contains(READ)) {
+// these options make no sense, since the FileChannel is not exposed
+throw new IllegalArgumentException("invalid openOptions: " + opts);
+}
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 String fn = pathForSecurityCheck(file);
 sm.checkWrite(fn);
-if (opts.contains(StandardOpenOption.DELETE_ON_CLOSE))
-sm.checkDelete(fn);
-if (opts.contains(StandardOpenOption.READ))
-sm.checkRead(fn);
 }
-return asFileImpl(file, openOptions);
+return new PathSubscriber(file, opts);
 }
 /**
 * Returns a {@code BodySubscriber} which stores the response body in a
-* file opened with the given name. Has the same effect as calling
+* file opened with the given name.
-* {@link #asFile(Path, OpenOption...) asFile} with the standard open
+*
-* options {@code CREATE} and {@code WRITE}
+* <p> Equivalent to: {@code asFile(file, CREATE, WRITE)}
 *
-* <p> The {@link HttpResponse} using this subscriber is available after
+* <p> Security manager permission checks are performed in this factory
-* the entire response has been read.
+* method, when a {@code BodySubscriber} is created. Care must be taken
+* that the {@code BodyHandler} is not shared with untrusted code.
 *
 * @param file the file to store the body in
 * @return a body subscriber
 * @throws SecurityException if a security manager has been installed
 *          and it denies {@link SecurityManager#checkWrite(String)
 *          write access} to the file
 */
 public static BodySubscriber<Path> asFile(Path file) {
-return asFile(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+return asFile(file, CREATE, WRITE);
 }
 /**
 * Returns a {@code BodySubscriber} which provides the incoming body
 * data to the provided Consumer of {@code Optional<byte[]>}. Each

branch	http-client-branch
changeset 56138	4f92b988600e
parent 56131	99f144742013
child 56139	b3d6203051df