FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
ViaLin/AndroidSource/FileOutputStream.java at main · resess/ViaLin · GitHub
Uh oh!
There was an error while loading.
Please reload this page
.
resess
/
ViaLin
Public
Notifications
You must be signed in to change notification settings
Fork
1
Star
6
Code
Issues
1
Pull requests
0
Actions
Projects
Security and quality
0
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Security and quality
Insights
Expand file tree
Breadcrumbs
ViaLin
/
AndroidSource
/
FileOutputStream.java
Copy path
More file actions
More file actions
Latest commit
History
History
History
executable file
·
449 lines (412 loc) · 16.7 KB
Breadcrumbs
ViaLin
/
AndroidSource
/
FileOutputStream.java
Copy path
File metadata and controls
executable file
·
449 lines (412 loc) · 16.7 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
/*
* Copyright (C) 2014 The Android Open Source Project
* Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package
java
.
io
;
import
java
.
nio
.
channels
.
FileChannel
;
import
dalvik
.
system
.
BlockGuard
;
import
dalvik
.
system
.
CloseGuard
;
import
sun
.
nio
.
ch
.
FileChannelImpl
;
import
libcore
.
io
.
IoBridge
;
import
libcore
.
io
.
IoTracker
;
/**
* A file output stream is an output stream for writing data to a
* <code>File</code> or to a <code>FileDescriptor</code>. Whether or not
* a file is available or may be created depends upon the underlying
* platform. Some platforms, in particular, allow a file to be opened
* for writing by only one <tt>FileOutputStream</tt> (or other
* file-writing object) at a time. In such situations the constructors in
* this class will fail if the file involved is already open.
*
* <p><code>FileOutputStream</code> is meant for writing streams of raw bytes
* such as image data. For writing streams of characters, consider using
* <code>FileWriter</code>.
*
* @author Arthur van Hoff
* @see java.io.File
* @see java.io.FileDescriptor
* @see java.io.FileInputStream
* @see java.nio.file.Files#newOutputStream
* @since JDK1.0
*/
public
class
FileOutputStream
extends
OutputStream
{
// Kevin taint: we keep track of the internal File object so that we can addFileTaint when
// we call FileOutputStream.write(byte[] data, ...)
private
File
file
=
null
;
// End Kevin
/**
* The system dependent file descriptor.
*/
private
final
FileDescriptor
fd
;
/**
* True if the file is opened for append.
*/
private
final
boolean
append
;
/**
* The associated channel, initialized lazily.
*/
private
FileChannel
channel
;
private
final
Object
closeLock
=
new
Object
();
private
volatile
boolean
closed
=
false
;
/**
* The path of the referenced file
* (null if the stream is created with a file descriptor)
*/
private
final
String
path
;
private
final
CloseGuard
guard
=
CloseGuard
.
get
();
private
final
boolean
isFdOwner
;
private
final
IoTracker
tracker
=
new
IoTracker
();
/**
* Creates a file output stream to write to the file with the
* specified name. A new <code>FileDescriptor</code> object is
* created to represent this file connection.
* <p>
* First, if there is a security manager, its <code>checkWrite</code>
* method is called with <code>name</code> as its argument.
* <p>
* If the file exists but is a directory rather than a regular file, does
* not exist but cannot be created, or cannot be opened for any other
* reason then a <code>FileNotFoundException</code> is thrown.
*
* @param name the system-dependent filename
* @exception FileNotFoundException if the file exists but is a directory
* rather than a regular file, does not exist but cannot
* be created, or cannot be opened for any other reason
* @exception SecurityException if a security manager exists and its
* <code>checkWrite</code> method denies write access
* to the file.
* @see java.lang.SecurityManager#checkWrite(java.lang.String)
*/
public
FileOutputStream
(
String
name
)
throws
FileNotFoundException
{
this
(
name
!=
null
?
new
File
(
name
) :
null
,
false
);
}
/**
* Creates a file output stream to write to the file with the specified
* name. If the second argument is <code>true</code>, then
* bytes will be written to the end of the file rather than the beginning.
* A new <code>FileDescriptor</code> object is created to represent this
* file connection.
* <p>
* First, if there is a security manager, its <code>checkWrite</code>
* method is called with <code>name</code> as its argument.
* <p>
* If the file exists but is a directory rather than a regular file, does
* not exist but cannot be created, or cannot be opened for any other
* reason then a <code>FileNotFoundException</code> is thrown.
*
* @param name the system-dependent file name
* @param append if <code>true</code>, then bytes will be written
* to the end of the file rather than the beginning
* @exception FileNotFoundException if the file exists but is a directory
* rather than a regular file, does not exist but cannot
* be created, or cannot be opened for any other reason.
* @exception SecurityException if a security manager exists and its
* <code>checkWrite</code> method denies write access
* to the file.
* @see java.lang.SecurityManager#checkWrite(java.lang.String)
* @since JDK1.1
*/
public
FileOutputStream
(
String
name
,
boolean
append
)
throws
FileNotFoundException
{
this
(
name
!=
null
?
new
File
(
name
) :
null
,
append
);
}
/**
* Creates a file output stream to write to the file represented by
* the specified <code>File</code> object. A new
* <code>FileDescriptor</code> object is created to represent this
* file connection.
* <p>
* First, if there is a security manager, its <code>checkWrite</code>
* method is called with the path represented by the <code>file</code>
* argument as its argument.
* <p>
* If the file exists but is a directory rather than a regular file, does
* not exist but cannot be created, or cannot be opened for any other
* reason then a <code>FileNotFoundException</code> is thrown.
*
* @param file the file to be opened for writing.
* @exception FileNotFoundException if the file exists but is a directory
* rather than a regular file, does not exist but cannot
* be created, or cannot be opened for any other reason
* @exception SecurityException if a security manager exists and its
* <code>checkWrite</code> method denies write access
* to the file.
* @see java.io.File#getPath()
* @see java.lang.SecurityException
* @see java.lang.SecurityManager#checkWrite(java.lang.String)
*/
public
FileOutputStream
(
File
file
)
throws
FileNotFoundException
{
this
(
file
,
false
);
}
/**
* Creates a file output stream to write to the file represented by
* the specified <code>File</code> object. If the second argument is
* <code>true</code>, then bytes will be written to the end of the file
* rather than the beginning. A new <code>FileDescriptor</code> object is
* created to represent this file connection.
* <p>
* First, if there is a security manager, its <code>checkWrite</code>
* method is called with the path represented by the <code>file</code>
* argument as its argument.
* <p>
* If the file exists but is a directory rather than a regular file, does
* not exist but cannot be created, or cannot be opened for any other
* reason then a <code>FileNotFoundException</code> is thrown.
*
* @param file the file to be opened for writing.
* @param append if <code>true</code>, then bytes will be written
* to the end of the file rather than the beginning
* @exception FileNotFoundException if the file exists but is a directory
* rather than a regular file, does not exist but cannot
* be created, or cannot be opened for any other reason
* @exception SecurityException if a security manager exists and its
* <code>checkWrite</code> method denies write access
* to the file.
* @see java.io.File#getPath()
* @see java.lang.SecurityException
* @see java.lang.SecurityManager#checkWrite(java.lang.String)
* @since 1.4
*/
public
FileOutputStream
(
File
file
,
boolean
append
)
throws
FileNotFoundException
{
String
name
= (
file
!=
null
?
file
.
getPath
() :
null
);
SecurityManager
security
=
System
.
getSecurityManager
();
if
(
security
!=
null
) {
security
.
checkWrite
(
name
);
}
if
(
name
==
null
) {
throw
new
NullPointerException
();
}
if
(
file
.
isInvalid
()) {
throw
new
FileNotFoundException
(
"Invalid file path"
);
}
this
.
fd
=
new
FileDescriptor
();
this
.
append
=
append
;
this
.
path
=
name
;
this
.
isFdOwner
=
true
;
// Kevin taint: save the internal File object
this
.
file
=
file
;
// End Kevin
BlockGuard
.
getThreadPolicy
().
onWriteToDisk
();
open
(
name
,
append
);
guard
.
open
(
"close"
);
}
// Kevin: taint
public
File
getFileOutputStreamTaintFile
(){
return
this
.
file
;
}
// end Kevin
/**
* Creates a file output stream to write to the specified file
* descriptor, which represents an existing connection to an actual
* file in the file system.
* <p>
* First, if there is a security manager, its <code>checkWrite</code>
* method is called with the file descriptor <code>fdObj</code>
* argument as its argument.
* <p>
* If <code>fdObj</code> is null then a <code>NullPointerException</code>
* is thrown.
* <p>
* This constructor does not throw an exception if <code>fdObj</code>
* is {@link java.io.FileDescriptor#valid() invalid}.
* However, if the methods are invoked on the resulting stream to attempt
* I/O on the stream, an <code>IOException</code> is thrown.
*
* @param fdObj the file descriptor to be opened for writing
* @exception SecurityException if a security manager exists and its
* <code>checkWrite</code> method denies
* write access to the file descriptor
* @see java.lang.SecurityManager#checkWrite(java.io.FileDescriptor)
*/
public
FileOutputStream
(
FileDescriptor
fdObj
) {
this
(
fdObj
,
false
/* isOwner */
);
}
/**
* Internal constructor for {@code FileOutputStream} objects where the file descriptor
* is owned by this tream.
*
* @hide
*/
public
FileOutputStream
(
FileDescriptor
fdObj
,
boolean
isFdOwner
) {
if
(
fdObj
==
null
) {
throw
new
NullPointerException
(
"fdObj == null"
);
}
this
.
fd
=
fdObj
;
this
.
path
=
null
;
this
.
append
=
false
;
this
.
isFdOwner
=
isFdOwner
;
}
/**
* Opens a file, with the specified name, for overwriting or appending.
* @param name name of file to be opened
* @param append whether the file is to be opened in append mode
*/
private
native
void
open0
(
String
name
,
boolean
append
)
throws
FileNotFoundException
;
// wrap native call to allow instrumentation
/**
* Opens a file, with the specified name, for overwriting or appending.
* @param name name of file to be opened
* @param append whether the file is to be opened in append mode
*/
private
void
open
(
String
name
,
boolean
append
)
throws
FileNotFoundException
{
open0
(
name
,
append
);
}
/**
* Writes the specified byte to this file output stream. Implements
* the <code>write</code> method of <code>OutputStream</code>.
*
* @param b the byte to be written.
* @exception IOException if an I/O error occurs.
*/
public
void
write
(
int
b
)
throws
IOException
{
write
(
new
byte
[] { (
byte
)
b
},
0
,
1
);
}
/**
* Writes <code>b.length</code> bytes from the specified byte array
* to this file output stream.
*
* @param b the data.
* @exception IOException if an I/O error occurs.
*/
public
void
write
(
byte
b
[])
throws
IOException
{
write
(
b
,
0
,
b
.
length
);
}
/**
* Writes <code>len</code> bytes from the specified byte array
* starting at offset <code>off</code> to this file output stream.
*
* @param b the data.
* @param off the start offset in the data.
* @param len the number of bytes to write.
* @exception IOException if an I/O error occurs.
*/
public
void
write
(
byte
b
[],
int
off
,
int
len
)
throws
IOException
{
if
(
closed
&&
len
>
0
) {
throw
new
IOException
(
"Stream Closed"
);
}
tracker
.
trackIo
(
len
);
IoBridge
.
write
(
fd
,
b
,
off
,
len
);
}
/**
* Closes this file output stream and releases any system resources
* associated with this stream. This file output stream may no longer
* be used for writing bytes.
*
* <p> If this stream has an associated channel then the channel is closed
* as well.
*
* @exception IOException if an I/O error occurs.
*
* @revised 1.4
* @spec JSR-51
*/
public
void
close
()
throws
IOException
{
synchronized
(
closeLock
) {
if
(
closed
) {
return
;
}
closed
=
true
;
}
guard
.
close
();
if
(
channel
!=
null
) {
/*
* Decrement FD use count associated with the channel
* The use count is incremented whenever a new channel
* is obtained from this stream.
*/
channel
.
close
();
}
if
(
isFdOwner
) {
IoBridge
.
closeAndSignalBlockedThreads
(
fd
);
}
}
/**
* Returns the file descriptor associated with this stream.
*
* @return the <code>FileDescriptor</code> object that represents
* the connection to the file in the file system being used
* by this <code>FileOutputStream</code> object.
*
* @exception IOException if an I/O error occurs.
* @see java.io.FileDescriptor
*/
public
final
FileDescriptor
getFD
()
throws
IOException
{
if
(
fd
!=
null
) {
return
fd
;
}
throw
new
IOException
();
}
/**
* Returns the unique {@link java.nio.channels.FileChannel FileChannel}
* object associated with this file output stream.
*
* <p> The initial {@link java.nio.channels.FileChannel#position()
* position} of the returned channel will be equal to the
* number of bytes written to the file so far unless this stream is in
* append mode, in which case it will be equal to the size of the file.
* Writing bytes to this stream will increment the channel's position
* accordingly. Changing the channel's position, either explicitly or by
* writing, will change this stream's file position.
*
* @return the file channel associated with this file output stream
*
* @since 1.4
* @spec JSR-51
*/
public
FileChannel
getChannel
() {
synchronized
(
this
) {
if
(
channel
==
null
) {
channel
=
FileChannelImpl
.
open
(
fd
,
path
,
false
,
true
,
append
,
this
);
}
return
channel
;
}
}
/**
* Cleans up the connection to the file, and ensures that the
* <code>close</code> method of this file output stream is
* called when there are no more references to this stream.
*
* @exception IOException if an I/O error occurs.
* @see java.io.FileInputStream#close()
*/
protected
void
finalize
()
throws
IOException
{
if
(
guard
!=
null
) {
guard
.
warnIfOpen
();
}
if
(
fd
!=
null
) {
if
(
fd
==
FileDescriptor
.
out
||
fd
==
FileDescriptor
.
err
) {
flush
();
}
else
{
close
();
}
}
}
}
Back
|
FazBrowse Home
|
New Git URL