1 /*
2 * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
47 private static final JavaIOFileDescriptorAccess fdAccess =
48 SharedSecrets.getJavaIOFileDescriptorAccess();
49
50 protected UnixChannelFactory() {
51 }
52
53 /**
54 * Represents the flags from a user-supplied set of open options.
55 */
56 protected static class Flags {
57 boolean read;
58 boolean write;
59 boolean append;
60 boolean truncateExisting;
61 boolean noFollowLinks;
62 boolean create;
63 boolean createNew;
64 boolean deleteOnClose;
65 boolean sync;
66 boolean dsync;
67
68 static Flags toFlags(Set<? extends OpenOption> options) {
69 Flags flags = new Flags();
70 for (OpenOption option: options) {
71 if (option instanceof StandardOpenOption) {
72 switch ((StandardOpenOption)option) {
73 case READ : flags.read = true; break;
74 case WRITE : flags.write = true; break;
75 case APPEND : flags.append = true; break;
76 case TRUNCATE_EXISTING : flags.truncateExisting = true; break;
77 case CREATE : flags.create = true; break;
78 case CREATE_NEW : flags.createNew = true; break;
79 case DELETE_ON_CLOSE : flags.deleteOnClose = true; break;
80 case SPARSE : /* ignore */ break;
81 case SYNC : flags.sync = true; break;
82 case DSYNC : flags.dsync = true; break;
83 default: throw new UnsupportedOperationException();
84 }
85 continue;
86 }
87 if (option == LinkOption.NOFOLLOW_LINKS && O_NOFOLLOW != 0) {
88 flags.noFollowLinks = true;
89 continue;
90 }
91 if (option == null)
92 throw new NullPointerException();
93 throw new UnsupportedOperationException(option + " not supported");
94 }
95 return flags;
96 }
97 }
98
99
100 /**
101 * Constructs a file channel from an existing (open) file descriptor
102 */
103 static FileChannel newFileChannel(int fd, String path, boolean reading, boolean writing) {
104 FileDescriptor fdObj = new FileDescriptor();
105 fdAccess.set(fdObj, fd);
106 return FileChannelImpl.open(fdObj, path, reading, writing, null);
107 }
108
109 /**
110 * Constructs a file channel by opening a file using a dfd/path pair
117 throws UnixException
118 {
119 Flags flags = Flags.toFlags(options);
120
121 // default is reading; append => writing
122 if (!flags.read && !flags.write) {
123 if (flags.append) {
124 flags.write = true;
125 } else {
126 flags.read = true;
127 }
128 }
129
130 // validation
131 if (flags.read && flags.append)
132 throw new IllegalArgumentException("READ + APPEND not allowed");
133 if (flags.append && flags.truncateExisting)
134 throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
135
136 FileDescriptor fdObj = open(dfd, path, pathForPermissionCheck, flags, mode);
137 return FileChannelImpl.open(fdObj, path.toString(), flags.read, flags.write, null);
138 }
139
140 /**
141 * Constructs a file channel by opening the given file.
142 */
143 static FileChannel newFileChannel(UnixPath path,
144 Set<? extends OpenOption> options,
145 int mode)
146 throws UnixException
147 {
148 return newFileChannel(-1, path, null, options, mode);
149 }
150
151 /**
152 * Constructs an asynchronous file channel by opening the given file.
153 */
154 static AsynchronousFileChannel newAsynchronousFileChannel(UnixPath path,
155 Set<? extends OpenOption> options,
156 int mode,
157 ThreadPool pool)
|
1 /*
2 * Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
47 private static final JavaIOFileDescriptorAccess fdAccess =
48 SharedSecrets.getJavaIOFileDescriptorAccess();
49
50 protected UnixChannelFactory() {
51 }
52
53 /**
54 * Represents the flags from a user-supplied set of open options.
55 */
56 protected static class Flags {
57 boolean read;
58 boolean write;
59 boolean append;
60 boolean truncateExisting;
61 boolean noFollowLinks;
62 boolean create;
63 boolean createNew;
64 boolean deleteOnClose;
65 boolean sync;
66 boolean dsync;
67 boolean direct;
68
69 static Flags toFlags(Set<? extends OpenOption> options) {
70 Flags flags = new Flags();
71 for (OpenOption option: options) {
72 if (option instanceof StandardOpenOption) {
73 switch ((StandardOpenOption)option) {
74 case READ : flags.read = true; break;
75 case WRITE : flags.write = true; break;
76 case APPEND : flags.append = true; break;
77 case TRUNCATE_EXISTING : flags.truncateExisting = true; break;
78 case CREATE : flags.create = true; break;
79 case CREATE_NEW : flags.createNew = true; break;
80 case DELETE_ON_CLOSE : flags.deleteOnClose = true; break;
81 case SPARSE : /* ignore */ break;
82 case SYNC : flags.sync = true; break;
83 case DSYNC : flags.dsync = true; break;
84 default: throw new UnsupportedOperationException();
85 }
86 continue;
87 }
88 if (option == LinkOption.NOFOLLOW_LINKS && O_NOFOLLOW != 0) {
89 flags.noFollowLinks = true;
90 continue;
91 }
92
93 if (ExtendedOptions.DIRECT.matches(option)) {
94 flags.direct = true;
95 continue;
96 }
97
98 if (option == null)
99 throw new NullPointerException();
100 throw new UnsupportedOperationException(option + " not supported");
101 }
102 return flags;
103 }
104 }
105
106
107 /**
108 * Constructs a file channel from an existing (open) file descriptor
109 */
110 static FileChannel newFileChannel(int fd, String path, boolean reading, boolean writing) {
111 FileDescriptor fdObj = new FileDescriptor();
112 fdAccess.set(fdObj, fd);
113 return FileChannelImpl.open(fdObj, path, reading, writing, null);
114 }
115
116 /**
117 * Constructs a file channel by opening a file using a dfd/path pair
124 throws UnixException
125 {
126 Flags flags = Flags.toFlags(options);
127
128 // default is reading; append => writing
129 if (!flags.read && !flags.write) {
130 if (flags.append) {
131 flags.write = true;
132 } else {
133 flags.read = true;
134 }
135 }
136
137 // validation
138 if (flags.read && flags.append)
139 throw new IllegalArgumentException("READ + APPEND not allowed");
140 if (flags.append && flags.truncateExisting)
141 throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
142
143 FileDescriptor fdObj = open(dfd, path, pathForPermissionCheck, flags, mode);
144 return FileChannelImpl.open(fdObj, path.toString(), flags.read,
145 flags.write, flags.direct, null);
146 }
147
148 /**
149 * Constructs a file channel by opening the given file.
150 */
151 static FileChannel newFileChannel(UnixPath path,
152 Set<? extends OpenOption> options,
153 int mode)
154 throws UnixException
155 {
156 return newFileChannel(-1, path, null, options, mode);
157 }
158
159 /**
160 * Constructs an asynchronous file channel by opening the given file.
161 */
162 static AsynchronousFileChannel newAsynchronousFileChannel(UnixPath path,
163 Set<? extends OpenOption> options,
164 int mode,
165 ThreadPool pool)
|