1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <binder/Status.h> 18 19 namespace android { 20 namespace binder { 21 22 Status Status::ok() { 23 return Status(); 24 } 25 26 Status Status::fromExceptionCode(int32_t exceptionCode) { 27 if (exceptionCode == EX_TRANSACTION_FAILED) { 28 return Status(exceptionCode, FAILED_TRANSACTION); 29 } 30 return Status(exceptionCode, OK); 31 } 32 33 Status Status::fromExceptionCode(int32_t exceptionCode, 34 const String8& message) { 35 if (exceptionCode == EX_TRANSACTION_FAILED) { 36 return Status(exceptionCode, FAILED_TRANSACTION, message); 37 } 38 return Status(exceptionCode, OK, message); 39 } 40 41 Status Status::fromExceptionCode(int32_t exceptionCode, 42 const char* message) { 43 return fromExceptionCode(exceptionCode, String8(message)); 44 } 45 46 Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode) { 47 return Status(EX_SERVICE_SPECIFIC, serviceSpecificErrorCode); 48 } 49 50 Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode, 51 const String8& message) { 52 return Status(EX_SERVICE_SPECIFIC, serviceSpecificErrorCode, message); 53 } 54 55 Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode, 56 const char* message) { 57 return fromServiceSpecificError(serviceSpecificErrorCode, String8(message)); 58 } 59 60 Status Status::fromStatusT(status_t status) { 61 Status ret; 62 ret.setFromStatusT(status); 63 return ret; 64 } 65 66 std::string Status::exceptionToString(int32_t exceptionCode) { 67 switch (exceptionCode) { 68 #define EXCEPTION_TO_CASE(EXCEPTION) case EXCEPTION: return #EXCEPTION; 69 EXCEPTION_TO_CASE(EX_NONE) 70 EXCEPTION_TO_CASE(EX_SECURITY) 71 EXCEPTION_TO_CASE(EX_BAD_PARCELABLE) 72 EXCEPTION_TO_CASE(EX_ILLEGAL_ARGUMENT) 73 EXCEPTION_TO_CASE(EX_NULL_POINTER) 74 EXCEPTION_TO_CASE(EX_ILLEGAL_STATE) 75 EXCEPTION_TO_CASE(EX_NETWORK_MAIN_THREAD) 76 EXCEPTION_TO_CASE(EX_UNSUPPORTED_OPERATION) 77 EXCEPTION_TO_CASE(EX_SERVICE_SPECIFIC) 78 EXCEPTION_TO_CASE(EX_PARCELABLE) 79 EXCEPTION_TO_CASE(EX_HAS_REPLY_HEADER) 80 EXCEPTION_TO_CASE(EX_TRANSACTION_FAILED) 81 #undef EXCEPTION_TO_CASE 82 default: return std::to_string(exceptionCode); 83 } 84 } 85 86 Status::Status(int32_t exceptionCode, int32_t errorCode) 87 : mException(exceptionCode), 88 mErrorCode(errorCode) {} 89 90 Status::Status(int32_t exceptionCode, int32_t errorCode, const String8& message) 91 : mException(exceptionCode), 92 mErrorCode(errorCode), 93 mMessage(message) {} 94 95 status_t Status::readFromParcel(const Parcel& parcel) { 96 status_t status = parcel.readInt32(&mException); 97 if (status != OK) { 98 setFromStatusT(status); 99 return status; 100 } 101 102 // Skip over fat response headers. Not used (or propagated) in native code. 103 if (mException == EX_HAS_REPLY_HEADER) { 104 // Note that the header size includes the 4 byte size field. 105 const size_t header_start = parcel.dataPosition(); 106 // Get available size before reading more 107 const size_t header_avail = parcel.dataAvail(); 108 109 int32_t header_size; 110 status = parcel.readInt32(&header_size); 111 if (status != OK) { 112 setFromStatusT(status); 113 return status; 114 } 115 116 if (header_size < 0 || static_cast<size_t>(header_size) > header_avail) { 117 android_errorWriteLog(0x534e4554, "132650049"); 118 setFromStatusT(UNKNOWN_ERROR); 119 return UNKNOWN_ERROR; 120 } 121 122 parcel.setDataPosition(header_start + header_size); 123 // And fat response headers are currently only used when there are no 124 // exceptions, so act like there was no error. 125 mException = EX_NONE; 126 } 127 128 if (mException == EX_NONE) { 129 return status; 130 } 131 132 // The remote threw an exception. Get the message back. 133 String16 message; 134 status = parcel.readString16(&message); 135 if (status != OK) { 136 setFromStatusT(status); 137 return status; 138 } 139 mMessage = String8(message); 140 141 // Skip over the remote stack trace data 142 int32_t remote_stack_trace_header_size; 143 status = parcel.readInt32(&remote_stack_trace_header_size); 144 if (status != OK) { 145 setFromStatusT(status); 146 return status; 147 } 148 if (remote_stack_trace_header_size < 0 || 149 static_cast<size_t>(remote_stack_trace_header_size) > parcel.dataAvail()) { 150 151 android_errorWriteLog(0x534e4554, "132650049"); 152 setFromStatusT(UNKNOWN_ERROR); 153 return UNKNOWN_ERROR; 154 } 155 parcel.setDataPosition(parcel.dataPosition() + remote_stack_trace_header_size); 156 157 if (mException == EX_SERVICE_SPECIFIC) { 158 status = parcel.readInt32(&mErrorCode); 159 } else if (mException == EX_PARCELABLE) { 160 // Skip over the blob of Parcelable data 161 const size_t header_start = parcel.dataPosition(); 162 // Get available size before reading more 163 const size_t header_avail = parcel.dataAvail(); 164 165 int32_t header_size; 166 status = parcel.readInt32(&header_size); 167 if (status != OK) { 168 setFromStatusT(status); 169 return status; 170 } 171 172 if (header_size < 0 || static_cast<size_t>(header_size) > header_avail) { 173 android_errorWriteLog(0x534e4554, "132650049"); 174 setFromStatusT(UNKNOWN_ERROR); 175 return UNKNOWN_ERROR; 176 } 177 178 parcel.setDataPosition(header_start + header_size); 179 } 180 if (status != OK) { 181 setFromStatusT(status); 182 return status; 183 } 184 185 return status; 186 } 187 188 status_t Status::writeToParcel(Parcel* parcel) const { 189 // Something really bad has happened, and we're not going to even 190 // try returning rich error data. 191 if (mException == EX_TRANSACTION_FAILED) { 192 return mErrorCode; 193 } 194 195 status_t status = parcel->writeInt32(mException); 196 if (status != OK) { return status; } 197 if (mException == EX_NONE) { 198 // We have no more information to write. 199 return status; 200 } 201 status = parcel->writeString16(String16(mMessage)); 202 status = parcel->writeInt32(0); // Empty remote stack trace header 203 if (mException == EX_SERVICE_SPECIFIC) { 204 status = parcel->writeInt32(mErrorCode); 205 } else if (mException == EX_PARCELABLE) { 206 // Sending Parcelable blobs currently not supported 207 status = parcel->writeInt32(0); 208 } 209 return status; 210 } 211 212 void Status::setException(int32_t ex, const String8& message) { 213 mException = ex; 214 mErrorCode = ex == EX_TRANSACTION_FAILED ? FAILED_TRANSACTION : NO_ERROR; 215 mMessage.setTo(message); 216 } 217 218 void Status::setServiceSpecificError(int32_t errorCode, const String8& message) { 219 setException(EX_SERVICE_SPECIFIC, message); 220 mErrorCode = errorCode; 221 } 222 223 void Status::setFromStatusT(status_t status) { 224 mException = (status == NO_ERROR) ? EX_NONE : EX_TRANSACTION_FAILED; 225 mErrorCode = status; 226 mMessage.clear(); 227 } 228 229 String8 Status::toString8() const { 230 String8 ret; 231 if (mException == EX_NONE) { 232 ret.append("No error"); 233 } else { 234 ret.appendFormat("Status(%d, %s): '", mException, exceptionToString(mException).c_str()); 235 if (mException == EX_SERVICE_SPECIFIC || 236 mException == EX_TRANSACTION_FAILED) { 237 ret.appendFormat("%d: ", mErrorCode); 238 } 239 ret.append(String8(mMessage)); 240 ret.append("'"); 241 } 242 return ret; 243 } 244 245 std::stringstream& operator<< (std::stringstream& stream, const Status& s) { 246 stream << s.toString8().string(); 247 return stream; 248 } 249 250 } // namespace binder 251 } // namespace android 252
