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
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "android_webview/native/input_stream_impl.h"
#include "base/android/jni_android.h"
// Disable "Warnings treated as errors" for input_stream_jni as it's a Java
// system class and we have to generate C++ hooks for all methods in the class
// even if they're unused.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#include "jni/InputStreamUtil_jni.h"
#pragma GCC diagnostic pop
#include "net/base/io_buffer.h"
using base::android::AttachCurrentThread;
using base::android::ClearException;
using base::android::JavaRef;
namespace android_webview {
namespace {
// This should be the same as InputStramUtil.EXCEPTION_THROWN_STATUS.
const int kExceptionThrownStatusCode = -2;
}
bool RegisterInputStream(JNIEnv* env) {
return RegisterNativesImpl(env);
}
// Maximum number of bytes to be read in a single read.
const int InputStreamImpl::kBufferSize = 4096;
// static
const InputStreamImpl* InputStreamImpl::FromInputStream(
const InputStream* input_stream) {
return static_cast<const InputStreamImpl*>(input_stream);
}
// TODO: Use unsafe version for all Java_InputStream methods in this file
// once BUG 157880 is fixed and implement graceful exception handling.
InputStreamImpl::InputStreamImpl() {
}
InputStreamImpl::InputStreamImpl(const JavaRef<jobject>& stream)
: jobject_(stream) {
DCHECK(!stream.is_null());
}
InputStreamImpl::~InputStreamImpl() {
JNIEnv* env = AttachCurrentThread();
Java_InputStreamUtil_close(env, jobject_.obj());
}
bool InputStreamImpl::BytesAvailable(int* bytes_available) const {
JNIEnv* env = AttachCurrentThread();
int bytes = Java_InputStreamUtil_available(env, jobject_.obj());
if (bytes == kExceptionThrownStatusCode)
return false;
*bytes_available = bytes;
return true;
}
bool InputStreamImpl::Skip(int64_t n, int64_t* bytes_skipped) {
JNIEnv* env = AttachCurrentThread();
int bytes = Java_InputStreamUtil_skip(env, jobject_.obj(), n);
if (bytes < 0)
return false;
if (bytes > n)
return false;
*bytes_skipped = bytes;
return true;
}
bool InputStreamImpl::Read(net::IOBuffer* dest, int length, int* bytes_read) {
JNIEnv* env = AttachCurrentThread();
if (!buffer_.obj()) {
// Allocate transfer buffer.
base::android::ScopedJavaLocalRef<jbyteArray> temp(
env, env->NewByteArray(kBufferSize));
buffer_.Reset(temp);
if (ClearException(env))
return false;
}
int remaining_length = length;
char* dest_write_ptr = dest->data();
jbyteArray buffer = buffer_.obj();
*bytes_read = 0;
while (remaining_length > 0) {
const int max_transfer_length = std::min(remaining_length, kBufferSize);
const int transfer_length = Java_InputStreamUtil_read(
env, jobject_.obj(), buffer, 0, max_transfer_length);
if (transfer_length == kExceptionThrownStatusCode)
return false;
if (transfer_length < 0) // EOF
break;
// Note: it is possible, yet unlikely, that the Java InputStream returns
// a transfer_length == 0 from time to time. In such cases we just continue
// the read until we get either valid data or reach EOF.
if (transfer_length == 0)
continue;
DCHECK_GE(max_transfer_length, transfer_length);
DCHECK_GE(env->GetArrayLength(buffer), transfer_length);
// This check is to prevent a malicious InputStream implementation from
// overrunning the |dest| buffer.
if (transfer_length > max_transfer_length)
return false;
// Copy the data over to the provided C++ IOBuffer.
DCHECK_GE(remaining_length, transfer_length);
env->GetByteArrayRegion(buffer, 0, transfer_length,
reinterpret_cast<jbyte*>(dest_write_ptr));
if (ClearException(env))
return false;
remaining_length -= transfer_length;
dest_write_ptr += transfer_length;
}
// bytes_read can be strictly less than the req. length if EOF is encountered.
DCHECK_GE(remaining_length, 0);
DCHECK_LE(remaining_length, length);
*bytes_read = length - remaining_length;
return true;
}
} // namespace android_webview
|
