Merge "Handles synchronous failures of transactions"
diff --git a/Android.bp b/Android.bp
index 2ea4894..d8027c1 100644
--- a/Android.bp
+++ b/Android.bp
@@ -65,6 +65,7 @@
"core/proto/android/os/procrank.proto",
"core/proto/android/os/system_properties.proto",
"core/proto/android/service/graphicsstats.proto",
+ "libs/incident/proto/android/privacy.proto",
"tools/streaming_proto/stream.proto",
],
shared: {
diff --git a/cmds/incidentd/src/Privacy.cpp b/cmds/incidentd/src/Privacy.cpp
index 140b12c..5db2239 100644
--- a/cmds/incidentd/src/Privacy.cpp
+++ b/cmds/incidentd/src/Privacy.cpp
@@ -16,37 +16,18 @@
#include "Privacy.h"
+#include <android/os/IncidentReportArgs.h>
#include <stdlib.h>
-// DESTINATION enum value
-const uint8_t DEST_LOCAL = 0;
-const uint8_t DEST_EXPLICIT = 1;
-const uint8_t DEST_AUTOMATIC = 2;
+uint64_t encode_field_id(const Privacy* p) { return (uint64_t)p->type << 32 | p->field_id; }
-// type of the field, identitical to protobuf definition
-const uint8_t TYPE_STRING = 9;
-const uint8_t TYPE_MESSAGE = 11;
-
-bool
-Privacy::IsMessageType() const { return type == TYPE_MESSAGE; }
-
-uint64_t
-Privacy::EncodedFieldId() const { return (uint64_t)type << 32 | field_id; }
-
-bool
-Privacy::IsStringType() const { return type == TYPE_STRING; }
-
-bool
-Privacy::HasChildren() const { return children != NULL && children[0] != NULL; }
-
-const Privacy*
-Privacy::lookup(uint32_t fieldId) const
+const Privacy* lookup(const Privacy* p, uint32_t fieldId)
{
- if (children == NULL) return NULL;
- for (int i=0; children[i] != NULL; i++) {
- if (children[i]->field_id == fieldId) return children[i];
- // This assumes the list's field id is in ascending order and must be true.
- if (children[i]->field_id > fieldId) return NULL;
+ if (p->children == NULL) return NULL;
+ for (int i=0; p->children[i] != NULL; i++) { // NULL-terminated.
+ if (p->children[i]->field_id == fieldId) return p->children[i];
+ // Incident section gen tool guarantees field ids in ascending order.
+ if (p->children[i]->field_id > fieldId) return NULL;
}
return NULL;
}
@@ -54,11 +35,14 @@
static bool allowDest(const uint8_t dest, const uint8_t policy)
{
switch (policy) {
- case DEST_LOCAL:
- return dest == DEST_LOCAL;
- case DEST_EXPLICIT:
- return dest == DEST_LOCAL || dest == DEST_EXPLICIT;
- case DEST_AUTOMATIC:
+ case android::os::DEST_LOCAL:
+ return dest == android::os::DEST_LOCAL;
+ case android::os::DEST_EXPLICIT:
+ case DEST_UNSET:
+ return dest == android::os::DEST_LOCAL ||
+ dest == android::os::DEST_EXPLICIT ||
+ dest == DEST_UNSET;
+ case android::os::DEST_AUTOMATIC:
return true;
default:
return false;
@@ -72,18 +56,19 @@
}
bool
-PrivacySpec::CheckPremission(const Privacy* privacy) const
+PrivacySpec::CheckPremission(const Privacy* privacy, const uint8_t defaultDest) const
{
- uint8_t policy = privacy == NULL ? DEST_DEFAULT_VALUE : privacy->dest;
+ uint8_t policy = privacy != NULL ? privacy->dest : defaultDest;
return allowDest(dest, policy);
}
bool
-PrivacySpec::RequireAll() const { return dest == DEST_LOCAL; }
+PrivacySpec::RequireAll() const { return dest == android::os::DEST_LOCAL; }
-PrivacySpec new_spec_from_args(int dest) {
+PrivacySpec new_spec_from_args(int dest)
+{
if (dest < 0) return PrivacySpec();
return PrivacySpec(dest);
}
-PrivacySpec get_default_dropbox_spec() { return PrivacySpec(DEST_AUTOMATIC); }
\ No newline at end of file
+PrivacySpec get_default_dropbox_spec() { return PrivacySpec(android::os::DEST_AUTOMATIC); }
\ No newline at end of file
diff --git a/cmds/incidentd/src/Privacy.h b/cmds/incidentd/src/Privacy.h
index f514f19..9e15ff4 100644
--- a/cmds/incidentd/src/Privacy.h
+++ b/cmds/incidentd/src/Privacy.h
@@ -19,35 +19,46 @@
#include <stdint.h>
-// This is the default value of DEST enum
-const uint8_t DEST_DEFAULT_VALUE = 1;
+// This is the default value of DEST enum, sync with privacy.proto
+const uint8_t DEST_UNSET = 255; // DEST_UNSET is not exposed to libincident
+const uint8_t DEST_DEFAULT_VALUE = DEST_UNSET;
/*
- * In order not to depend on libprotobuf-cpp-full nor libplatformprotos in incidentd,
- * privacy options's data structure are explicitly redefined in this file.
+ * In order to NOT auto-generate large chuck of code by proto compiler in incidentd,
+ * privacy options's data structure are explicitly redefined here and
+ * the values are populated by incident_section_gen tool.
+ *
+ * Each proto field will have a Privacy when it is different from its parent, otherwise
+ * it uses its parent's tag. A message type will have an array of Privacy.
*/
struct Privacy {
+ // The field number
uint32_t field_id;
+
+ // The field type, see external/protobuf/src/google/protobuf/descriptor.h
uint8_t type;
- // ignore parent's privacy flags if children are set, NULL-terminated
+
+ // If children is null, it is a primitive field,
+ // otherwise it is a message field which could have overridden privacy tags here.
+ // This array is NULL-terminated.
Privacy** children;
- // the following fields are identitical to
- // frameworks/base/libs/incident/proto/android/privacy.proto
+ // DESTINATION Enum in frameworks/base/libs/incident/proto/android/privacy.proto.
uint8_t dest;
- const char** patterns; // only set when type is string
-
- bool IsMessageType() const;
- bool IsStringType() const;
- bool HasChildren() const;
- uint64_t EncodedFieldId() const;
-
- const Privacy* lookup(uint32_t fieldId) const;
+ // A list of regexp rules for stripping string fields in proto.
+ const char** patterns;
};
+// Encode field id used by ProtoOutputStream.
+uint64_t encode_field_id(const Privacy* p);
+
+// Look up the child with given fieldId, if not found, return NULL.
+const Privacy* lookup(const Privacy* p, uint32_t fieldId);
+
/**
* PrivacySpec defines the request has what level of privacy authorization.
* For example, a device without user consent should only be able to upload AUTOMATIC fields.
+ * DEST_UNSET are treated as DEST_EXPLICIT.
*/
class PrivacySpec {
public:
@@ -58,7 +69,10 @@
bool operator<(const PrivacySpec& other) const;
- bool CheckPremission(const Privacy* privacy) const;
+ // check permission of a policy, if returns true, don't strip the data.
+ bool CheckPremission(const Privacy* privacy, const uint8_t defaultDest = DEST_DEFAULT_VALUE) const;
+
+ // if returns true, no data need to be stripped.
bool RequireAll() const;
};
diff --git a/cmds/incidentd/src/PrivacyBuffer.cpp b/cmds/incidentd/src/PrivacyBuffer.cpp
index 77ae1a7..03faa92 100644
--- a/cmds/incidentd/src/PrivacyBuffer.cpp
+++ b/cmds/incidentd/src/PrivacyBuffer.cpp
@@ -14,15 +14,18 @@
* limitations under the License.
*/
-
+#define LOG_TAG "incidentd"
#include "PrivacyBuffer.h"
#include "io_util.h"
#include <android/util/protobuf.h>
+#include <cutils/log.h>
using namespace android::util;
+const bool DEBUG = false;
+
/**
* Write the field to buf based on the wire type, iterator will point to next field.
* If skip is set to true, no data will be written to buf. Return number of bytes written.
@@ -30,6 +33,9 @@
void
PrivacyBuffer::writeFieldOrSkip(uint32_t fieldTag, bool skip)
{
+ if (DEBUG) ALOGD("%s field %d (wiretype = %d)", skip ? "skip" : "write",
+ read_field_id(fieldTag), read_wire_type(fieldTag));
+
uint8_t wireType = read_wire_type(fieldTag);
size_t bytesToWrite = 0;
uint32_t varint = 0;
@@ -55,6 +61,7 @@
bytesToWrite = 4;
break;
}
+ if (DEBUG) ALOGD("%s %d bytes of data", skip ? "skip" : "write", (int)bytesToWrite);
if (skip) {
mData.rp()->move(bytesToWrite);
} else {
@@ -76,10 +83,13 @@
{
if (!mData.hasNext() || parentPolicy == NULL) return BAD_VALUE;
uint32_t fieldTag = mData.readRawVarint();
- const Privacy* policy = parentPolicy->lookup(read_field_id(fieldTag));
+ const Privacy* policy = lookup(parentPolicy, read_field_id(fieldTag));
- if (policy == NULL || !policy->IsMessageType() || !policy->HasChildren()) {
- bool skip = !spec.CheckPremission(policy);
+ if (policy == NULL || policy->children == NULL) {
+ if (DEBUG) ALOGD("Not a message field %d: dest(%d)", read_field_id(fieldTag),
+ policy != NULL ? policy->dest : parentPolicy->dest);
+
+ bool skip = !spec.CheckPremission(policy, parentPolicy->dest);
// iterator will point to head of next field
writeFieldOrSkip(fieldTag, skip);
return NO_ERROR;
@@ -87,7 +97,7 @@
// current field is message type and its sub-fields have extra privacy policies
uint32_t msgSize = mData.readRawVarint();
EncodedBuffer::Pointer start = mData.rp()->copy();
- long long token = mProto.start(policy->EncodedFieldId());
+ long long token = mProto.start(encode_field_id(policy));
while (mData.rp()->pos() - start.pos() != msgSize) {
status_t err = stripField(policy, spec);
if (err != NO_ERROR) return err;
@@ -112,8 +122,9 @@
status_t
PrivacyBuffer::strip(const PrivacySpec& spec)
{
+ if (DEBUG) ALOGD("Strip with spec %d", spec.dest);
// optimization when no strip happens
- if (mPolicy == NULL || !mPolicy->HasChildren() || spec.RequireAll()) {
+ if (mPolicy == NULL || mPolicy->children == NULL || spec.RequireAll()) {
if (spec.CheckPremission(mPolicy)) mSize = mData.size();
return NO_ERROR;
}
diff --git a/cmds/incidentd/src/Section.cpp b/cmds/incidentd/src/Section.cpp
index c08b9ea..1bf795b 100644
--- a/cmds/incidentd/src/Section.cpp
+++ b/cmds/incidentd/src/Section.cpp
@@ -210,9 +210,9 @@
{
for (ReportRequestSet::iterator it=requests->begin(); it!=requests->end(); it++) {
const sp<ReportRequest> request = *it;
- const vector<vector<int8_t>>& headers = request->args.headers();
+ const vector<vector<uint8_t>>& headers = request->args.headers();
- for (vector<vector<int8_t>>::const_iterator buf=headers.begin(); buf!=headers.end(); buf++) {
+ for (vector<vector<uint8_t>>::const_iterator buf=headers.begin(); buf!=headers.end(); buf++) {
if (buf->empty()) continue;
// So the idea is only requests with negative fd are written to dropbox file.
diff --git a/cmds/incidentd/src/io_util.cpp b/cmds/incidentd/src/io_util.cpp
index f043d36..af4a35c 100644
--- a/cmds/incidentd/src/io_util.cpp
+++ b/cmds/incidentd/src/io_util.cpp
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#define LOG_TAG "incidentd"
+
#include "io_util.h"
#include <unistd.h>
diff --git a/cmds/incidentd/tests/PrivacyBuffer_test.cpp b/cmds/incidentd/tests/PrivacyBuffer_test.cpp
index ca94623..32b9e42 100644
--- a/cmds/incidentd/tests/PrivacyBuffer_test.cpp
+++ b/cmds/incidentd/tests/PrivacyBuffer_test.cpp
@@ -12,27 +12,27 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#define LOG_TAG "incidentd"
+
#include "FdBuffer.h"
#include "PrivacyBuffer.h"
#include <android-base/file.h>
#include <android-base/test_utils.h>
+#include <android/os/IncidentReportArgs.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <string.h>
using namespace android;
using namespace android::base;
+using namespace android::os;
using namespace std;
using ::testing::StrEq;
using ::testing::Test;
using ::testing::internal::CaptureStdout;
using ::testing::internal::GetCapturedStdout;
-const uint8_t LOCAL = 0;
-const uint8_t EXPLICIT = 1;
-const uint8_t AUTOMATIC = 2;
-
const uint8_t OTHER_TYPE = 1;
const uint8_t STRING_TYPE = 9;
const uint8_t MESSAGE_TYPE = 11;
@@ -109,21 +109,11 @@
p->field_id = field_id;
p->type = MESSAGE_TYPE;
p->children = children;
- p->dest = EXPLICIT;
+ p->dest = DEST_DEFAULT_VALUE;
p->patterns = NULL;
return p;
}
- Privacy* create_string_privacy(uint32_t field_id, uint8_t dest, const char** patterns) {
- Privacy* p = new_uninit_privacy();
- p->field_id = field_id;
- p->type = STRING_TYPE;
- p->children = NULL;
- p->dest = dest;
- p->patterns = patterns;
- return p;
- }
-
FdBuffer buffer;
private:
TemporaryFile tf;
@@ -138,103 +128,103 @@
}
};
-TEST_F(PrivacyBufferTest, NullFieldPolicy) {
+TEST_F(PrivacyBufferTest, NullPolicy) {
writeToFdBuffer(STRING_FIELD_0);
- assertStrip(EXPLICIT, STRING_FIELD_0, create_string_privacy(300, AUTOMATIC, NULL));
+ assertStrip(DEST_EXPLICIT, STRING_FIELD_0, NULL);
}
-TEST_F(PrivacyBufferTest, StripSpecNotAllowed) {
+TEST_F(PrivacyBufferTest, StripUnsetField) {
writeToFdBuffer(STRING_FIELD_0);
- assertStripByFields(AUTOMATIC, "", 1, create_privacy(0, STRING_TYPE, EXPLICIT));
+ assertStripByFields(DEST_AUTOMATIC, "", 1, create_privacy(0, STRING_TYPE, DEST_UNSET));
}
TEST_F(PrivacyBufferTest, StripVarintField) {
writeToFdBuffer(VARINT_FIELD_1);
- assertStripByFields(EXPLICIT, "", 1, create_privacy(1, OTHER_TYPE, LOCAL));
+ assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(1, OTHER_TYPE, DEST_LOCAL));
}
TEST_F(PrivacyBufferTest, StripLengthDelimitedField_String) {
writeToFdBuffer(STRING_FIELD_2);
- assertStripByFields(EXPLICIT, "", 1, create_privacy(2, STRING_TYPE, LOCAL));
+ assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(2, STRING_TYPE, DEST_LOCAL));
}
TEST_F(PrivacyBufferTest, StripFixed64Field) {
writeToFdBuffer(FIX64_FIELD_3);
- assertStripByFields(EXPLICIT, "", 1, create_privacy(3, OTHER_TYPE, LOCAL));
+ assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(3, OTHER_TYPE, DEST_LOCAL));
}
TEST_F(PrivacyBufferTest, StripFixed32Field) {
writeToFdBuffer(FIX32_FIELD_4);
- assertStripByFields(EXPLICIT, "", 1, create_privacy(4, OTHER_TYPE, LOCAL));
+ assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(4, OTHER_TYPE, DEST_LOCAL));
}
TEST_F(PrivacyBufferTest, StripLengthDelimitedField_Message) {
writeToFdBuffer(MESSAGE_FIELD_5);
- assertStripByFields(EXPLICIT, "", 1, create_privacy(5, MESSAGE_TYPE, LOCAL));
+ assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(5, MESSAGE_TYPE, DEST_LOCAL));
}
TEST_F(PrivacyBufferTest, NoStripVarintField) {
writeToFdBuffer(VARINT_FIELD_1);
- assertStripByFields(EXPLICIT, VARINT_FIELD_1, 1, create_privacy(1, OTHER_TYPE, AUTOMATIC));
+ assertStripByFields(DEST_EXPLICIT, VARINT_FIELD_1, 1, create_privacy(1, OTHER_TYPE, DEST_AUTOMATIC));
}
TEST_F(PrivacyBufferTest, NoStripLengthDelimitedField_String) {
writeToFdBuffer(STRING_FIELD_2);
- assertStripByFields(EXPLICIT, STRING_FIELD_2, 1, create_privacy(2, STRING_TYPE, AUTOMATIC));
+ assertStripByFields(DEST_EXPLICIT, STRING_FIELD_2, 1, create_privacy(2, STRING_TYPE, DEST_AUTOMATIC));
}
TEST_F(PrivacyBufferTest, NoStripFixed64Field) {
writeToFdBuffer(FIX64_FIELD_3);
- assertStripByFields(EXPLICIT, FIX64_FIELD_3, 1, create_privacy(3, OTHER_TYPE, AUTOMATIC));
+ assertStripByFields(DEST_EXPLICIT, FIX64_FIELD_3, 1, create_privacy(3, OTHER_TYPE, DEST_AUTOMATIC));
}
TEST_F(PrivacyBufferTest, NoStripFixed32Field) {
writeToFdBuffer(FIX32_FIELD_4);
- assertStripByFields(EXPLICIT, FIX32_FIELD_4, 1, create_privacy(4, OTHER_TYPE, AUTOMATIC));
+ assertStripByFields(DEST_EXPLICIT, FIX32_FIELD_4, 1, create_privacy(4, OTHER_TYPE, DEST_AUTOMATIC));
}
TEST_F(PrivacyBufferTest, NoStripLengthDelimitedField_Message) {
writeToFdBuffer(MESSAGE_FIELD_5);
- assertStripByFields(EXPLICIT, MESSAGE_FIELD_5, 1, create_privacy(5, MESSAGE_TYPE, AUTOMATIC));
+ assertStripByFields(DEST_EXPLICIT, MESSAGE_FIELD_5, 1, create_privacy(5, MESSAGE_TYPE, DEST_AUTOMATIC));
}
TEST_F(PrivacyBufferTest, StripVarintAndString) {
writeToFdBuffer(STRING_FIELD_0 + VARINT_FIELD_1 + STRING_FIELD_2
+ FIX64_FIELD_3 + FIX32_FIELD_4);
string expected = STRING_FIELD_0 + FIX64_FIELD_3 + FIX32_FIELD_4;
- assertStripByFields(EXPLICIT, expected, 2,
- create_privacy(1, OTHER_TYPE, LOCAL), create_privacy(2, STRING_TYPE, LOCAL));
+ assertStripByFields(DEST_EXPLICIT, expected, 2,
+ create_privacy(1, OTHER_TYPE, DEST_LOCAL), create_privacy(2, STRING_TYPE, DEST_LOCAL));
}
TEST_F(PrivacyBufferTest, StripVarintAndFixed64) {
writeToFdBuffer(STRING_FIELD_0 + VARINT_FIELD_1 + STRING_FIELD_2
+ FIX64_FIELD_3 + FIX32_FIELD_4);
string expected = STRING_FIELD_0 + STRING_FIELD_2 + FIX32_FIELD_4;
- assertStripByFields(EXPLICIT, expected, 2,
- create_privacy(1, OTHER_TYPE, LOCAL), create_privacy(3, OTHER_TYPE, LOCAL));
+ assertStripByFields(DEST_EXPLICIT, expected, 2,
+ create_privacy(1, OTHER_TYPE, DEST_LOCAL), create_privacy(3, OTHER_TYPE, DEST_LOCAL));
}
TEST_F(PrivacyBufferTest, StripVarintInNestedMessage) {
writeToFdBuffer(STRING_FIELD_0 + MESSAGE_FIELD_5);
- Privacy* list[] = { create_privacy(1, OTHER_TYPE, LOCAL), NULL };
+ Privacy* list[] = { create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL };
string expected = STRING_FIELD_0 + "\x2a\xd" + STRING_FIELD_2;
- assertStripByFields(EXPLICIT, expected, 1, create_message_privacy(5, list));
+ assertStripByFields(DEST_EXPLICIT, expected, 1, create_message_privacy(5, list));
}
TEST_F(PrivacyBufferTest, StripFix64AndVarintInNestedMessage) {
writeToFdBuffer(STRING_FIELD_0 + FIX64_FIELD_3 + MESSAGE_FIELD_5);
- Privacy* list[] = { create_privacy(1, OTHER_TYPE, LOCAL), NULL };
+ Privacy* list[] = { create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL };
string expected = STRING_FIELD_0 + "\x2a\xd" + STRING_FIELD_2;
- assertStripByFields(EXPLICIT, expected, 2, create_privacy(3, OTHER_TYPE, LOCAL), create_message_privacy(5, list));
+ assertStripByFields(DEST_EXPLICIT, expected, 2, create_privacy(3, OTHER_TYPE, DEST_LOCAL), create_message_privacy(5, list));
}
TEST_F(PrivacyBufferTest, ClearAndStrip) {
string data = STRING_FIELD_0 + VARINT_FIELD_1;
writeToFdBuffer(data);
- Privacy* list[] = { create_privacy(1, OTHER_TYPE, LOCAL), NULL };
+ Privacy* list[] = { create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL };
EncodedBuffer::iterator bufData = buffer.data();
PrivacyBuffer privacyBuf(create_message_privacy(300, list), bufData);
- PrivacySpec spec1(EXPLICIT), spec2(LOCAL);
+ PrivacySpec spec1(DEST_EXPLICIT), spec2(DEST_LOCAL);
ASSERT_EQ(privacyBuf.strip(spec1), NO_ERROR);
assertBuffer(privacyBuf, STRING_FIELD_0);
@@ -244,7 +234,7 @@
TEST_F(PrivacyBufferTest, BadDataInFdBuffer) {
writeToFdBuffer("iambaddata");
- Privacy* list[] = { create_privacy(4, OTHER_TYPE, AUTOMATIC), NULL };
+ Privacy* list[] = { create_privacy(4, OTHER_TYPE, DEST_AUTOMATIC), NULL };
EncodedBuffer::iterator bufData = buffer.data();
PrivacyBuffer privacyBuf(create_message_privacy(300, list), bufData);
PrivacySpec spec;
@@ -253,7 +243,7 @@
TEST_F(PrivacyBufferTest, BadDataInNestedMessage) {
writeToFdBuffer(STRING_FIELD_0 + MESSAGE_FIELD_5 + "aoeoe");
- Privacy* list[] = { create_privacy(1, OTHER_TYPE, LOCAL), NULL };
+ Privacy* list[] = { create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL };
Privacy* field5[] = { create_message_privacy(5, list), NULL };
EncodedBuffer::iterator bufData = buffer.data();
PrivacyBuffer privacyBuf(create_message_privacy(300, field5), bufData);
@@ -265,8 +255,17 @@
string input = "\x2a\"" + VARINT_FIELD_1 + STRING_FIELD_2 + MESSAGE_FIELD_5;
writeToFdBuffer(input);
Privacy* field5 = create_message_privacy(5, NULL);
- Privacy* list[] = { create_privacy(1, OTHER_TYPE, LOCAL), field5, NULL };
+ Privacy* list[] = { create_privacy(1, OTHER_TYPE, DEST_LOCAL), field5, NULL };
field5->children = list;
string expected = "\x2a\x1c" + STRING_FIELD_2 + "\x2a\xd" + STRING_FIELD_2;
- assertStrip(EXPLICIT, expected, field5);
+ assertStrip(DEST_EXPLICIT, expected, field5);
}
+
+TEST_F(PrivacyBufferTest, AutoMessage) {
+ writeToFdBuffer(STRING_FIELD_2 + MESSAGE_FIELD_5);
+ Privacy* list[] = { create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL };
+ Privacy* autoMsg = create_privacy(5, MESSAGE_TYPE, DEST_AUTOMATIC);
+ autoMsg->children = list;
+ string expected = "\x2a\xd" + STRING_FIELD_2;
+ assertStripByFields(DEST_AUTOMATIC, expected, 1, autoMsg);
+}
\ No newline at end of file
diff --git a/cmds/incidentd/tests/Reporter_test.cpp b/cmds/incidentd/tests/Reporter_test.cpp
index 8d99fc7..531c9f2 100644
--- a/cmds/incidentd/tests/Reporter_test.cpp
+++ b/cmds/incidentd/tests/Reporter_test.cpp
@@ -141,7 +141,7 @@
IncidentReportArgs args1, args2;
args1.addSection(1);
args2.addSection(2);
- std::vector<int8_t> header {'a', 'b', 'c', 'd', 'e'};
+ std::vector<uint8_t> header {'a', 'b', 'c', 'd', 'e'};
args2.addHeader(header);
sp<ReportRequest> r1 = new ReportRequest(args1, l, tf.fd);
sp<ReportRequest> r2 = new ReportRequest(args2, l, tf.fd);
diff --git a/cmds/incidentd/tests/Section_test.cpp b/cmds/incidentd/tests/Section_test.cpp
index 649e908..0c7876c 100644
--- a/cmds/incidentd/tests/Section_test.cpp
+++ b/cmds/incidentd/tests/Section_test.cpp
@@ -66,12 +66,12 @@
args1.addSection(2);
args2.setAll(true);
- vector<int8_t> head1;
+ vector<uint8_t> head1;
head1.push_back('a');
head1.push_back('x');
head1.push_back('e');
- vector<int8_t> head2;
+ vector<uint8_t> head2;
head2.push_back('p');
head2.push_back('u');
head2.push_back('p');
diff --git a/cmds/incidentd/tests/section_list.cpp b/cmds/incidentd/tests/section_list.cpp
index 4acc429..1d6213f 100644
--- a/cmds/incidentd/tests/section_list.cpp
+++ b/cmds/incidentd/tests/section_list.cpp
@@ -5,20 +5,16 @@
NULL
};
-const uint8_t LOCAL = 0;
-const uint8_t EXPLICIT = 1;
-const uint8_t AUTOMATIC = 2;
-
-Privacy sub_field_1 { 1, 1, NULL, LOCAL, NULL };
-Privacy sub_field_2 { 2, 9, NULL, AUTOMATIC, NULL };
+Privacy sub_field_1 { 1, 1, NULL, DEST_LOCAL, NULL };
+Privacy sub_field_2 { 2, 9, NULL, DEST_AUTOMATIC, NULL };
Privacy* list[] = {
&sub_field_1,
&sub_field_2,
NULL };
-Privacy field_0 { 0, 11, list, EXPLICIT, NULL };
-Privacy field_1 { 1, 9, NULL, AUTOMATIC, NULL };
+Privacy field_0 { 0, 11, list, DEST_EXPLICIT, NULL };
+Privacy field_1 { 1, 9, NULL, DEST_AUTOMATIC, NULL };
Privacy* final_list[] = {
&field_0,
diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java
index 19e24ad..71998ee 100644
--- a/core/java/android/content/Context.java
+++ b/core/java/android/content/Context.java
@@ -754,6 +754,8 @@
* to any callers for the same name, meaning they will see each other's
* edits as soon as they are made.
*
+ * This method is thead-safe.
+ *
* @param name Desired preferences file. If a preferences file by this name
* does not exist, it will be created when you retrieve an
* editor (SharedPreferences.edit()) and then commit changes (Editor.commit()).
diff --git a/core/java/android/content/res/AssetFileDescriptor.java b/core/java/android/content/res/AssetFileDescriptor.java
index 28edde0..be41036 100644
--- a/core/java/android/content/res/AssetFileDescriptor.java
+++ b/core/java/android/content/res/AssetFileDescriptor.java
@@ -195,7 +195,7 @@
/**
* An InputStream you can create on a ParcelFileDescriptor, which will
* take care of calling {@link ParcelFileDescriptor#close
- * ParcelFileDescritor.close()} for you when the stream is closed.
+ * ParcelFileDescriptor.close()} for you when the stream is closed.
*/
public static class AutoCloseInputStream
extends ParcelFileDescriptor.AutoCloseInputStream {
@@ -282,7 +282,7 @@
/**
* An OutputStream you can create on a ParcelFileDescriptor, which will
* take care of calling {@link ParcelFileDescriptor#close
- * ParcelFileDescritor.close()} for you when the stream is closed.
+ * ParcelFileDescriptor.close()} for you when the stream is closed.
*/
public static class AutoCloseOutputStream
extends ParcelFileDescriptor.AutoCloseOutputStream {
diff --git a/core/java/android/os/PowerManager.java b/core/java/android/os/PowerManager.java
index 068f5f7..01fe5bf 100644
--- a/core/java/android/os/PowerManager.java
+++ b/core/java/android/os/PowerManager.java
@@ -680,6 +680,26 @@
* as the user moves between applications and doesn't require a special permission.
* </p>
*
+ * <p>
+ * Recommended naming conventions for tags to make debugging easier:
+ * <ul>
+ * <li>use a unique prefix delimited by a colon for your app/library (e.g.
+ * gmail:mytag) to make it easier to understand where the wake locks comes
+ * from. This namespace will also avoid collision for tags inside your app
+ * coming from different libraries which will make debugging easier.
+ * <li>use constants (e.g. do not include timestamps in the tag) to make it
+ * easier for tools to aggregate similar wake locks. When collecting
+ * debugging data, the platform only monitors a finite number of tags,
+ * using constants will help tools to provide better debugging data.
+ * <li>avoid using Class#getName() or similar method since this class name
+ * can be transformed by java optimizer and obfuscator tools.
+ * <li>avoid wrapping the tag or a prefix to avoid collision with wake lock
+ * tags from the platform (e.g. *alarm*).
+ * <li>never include personnally identifiable information for privacy
+ * reasons.
+ * </ul>
+ * </p>
+ *
* @param levelAndFlags Combination of wake lock level and flag values defining
* the requested behavior of the WakeLock.
* @param tag Your class name (or other tag) for debugging purposes.
@@ -1509,6 +1529,13 @@
* cost of that work can be accounted to the application.
* </p>
*
+ * <p>
+ * Make sure to follow the tag naming convention when using WorkSource
+ * to make it easier for app developers to understand wake locks
+ * attributed to them. See {@link PowerManager#newWakeLock(int, String)}
+ * documentation.
+ * </p>
+ *
* @param ws The work source, or null if none.
*/
public void setWorkSource(WorkSource ws) {
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 1e0948a..c4c6798 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -8651,6 +8651,12 @@
"wifi_scan_always_enabled";
/**
+ * Whether soft AP will shut down after a timeout period when no devices are connected.
+ * @hide
+ */
+ public static final String SOFT_AP_TIMEOUT_ENABLED = "soft_ap_timeout_enabled";
+
+ /**
* Value to specify if Wi-Fi Wakeup feature is enabled.
*
* Type: int (0 for false, 1 for true)
@@ -10430,14 +10436,6 @@
"location_settings_link_to_permissions_enabled";
/**
- * Flag to enable use of RefactoredBackupManagerService.
- *
- * @hide
- */
- public static final String BACKUP_REFACTORED_SERVICE_DISABLED =
- "backup_refactored_service_disabled";
-
- /**
* Flag to set the waiting time for euicc factory reset inside System > Settings
* Type: long
*
@@ -10501,7 +10499,8 @@
LOW_POWER_MODE_TRIGGER_LEVEL,
BLUETOOTH_ON,
PRIVATE_DNS_MODE,
- PRIVATE_DNS_SPECIFIER
+ PRIVATE_DNS_SPECIFIER,
+ SOFT_AP_TIMEOUT_ENABLED
};
/** @hide */
diff --git a/core/java/com/android/internal/widget/ResolverDrawerLayout.java b/core/java/com/android/internal/widget/ResolverDrawerLayout.java
index 17c7ebd..7635a72 100644
--- a/core/java/com/android/internal/widget/ResolverDrawerLayout.java
+++ b/core/java/com/android/internal/widget/ResolverDrawerLayout.java
@@ -81,6 +81,7 @@
private int mCollapsibleHeightReserved;
private int mTopOffset;
+ private boolean mShowAtTop;
private boolean mIsDragging;
private boolean mOpenOnClick;
@@ -134,6 +135,7 @@
mMaxCollapsedHeightSmall = a.getDimensionPixelSize(
R.styleable.ResolverDrawerLayout_maxCollapsedHeightSmall,
mMaxCollapsedHeight);
+ mShowAtTop = a.getBoolean(R.styleable.ResolverDrawerLayout_showAtTop, false);
a.recycle();
mScrollIndicatorDrawable = mContext.getDrawable(R.drawable.scroll_indicator_material);
@@ -162,6 +164,16 @@
return mCollapseOffset > 0;
}
+ public void setShowAtTop(boolean showOnTop) {
+ mShowAtTop = showOnTop;
+ invalidate();
+ requestLayout();
+ }
+
+ public boolean getShowAtTop() {
+ return mShowAtTop;
+ }
+
public void setCollapsed(boolean collapsed) {
if (!isLaidOut()) {
mOpenOnLayout = collapsed;
@@ -206,6 +218,12 @@
return false;
}
+ if (getShowAtTop()) {
+ // Keep the drawer fully open.
+ mCollapseOffset = 0;
+ return false;
+ }
+
if (isLaidOut()) {
final boolean isCollapsedOld = mCollapseOffset != 0;
if (remainClosed && (oldCollapsibleHeight < mCollapsibleHeight
@@ -372,14 +390,23 @@
mVelocityTracker.computeCurrentVelocity(1000);
final float yvel = mVelocityTracker.getYVelocity(mActivePointerId);
if (Math.abs(yvel) > mMinFlingVelocity) {
- if (isDismissable()
- && yvel > 0 && mCollapseOffset > mCollapsibleHeight) {
- smoothScrollTo(mCollapsibleHeight + mUncollapsibleHeight, yvel);
- mDismissOnScrollerFinished = true;
+ if (getShowAtTop()) {
+ if (isDismissable() && yvel < 0) {
+ abortAnimation();
+ dismiss();
+ } else {
+ smoothScrollTo(yvel < 0 ? 0 : mCollapsibleHeight, yvel);
+ }
} else {
- smoothScrollTo(yvel < 0 ? 0 : mCollapsibleHeight, yvel);
+ if (isDismissable()
+ && yvel > 0 && mCollapseOffset > mCollapsibleHeight) {
+ smoothScrollTo(mCollapsibleHeight + mUncollapsibleHeight, yvel);
+ mDismissOnScrollerFinished = true;
+ } else {
+ smoothScrollTo(yvel < 0 ? 0 : mCollapsibleHeight, yvel);
+ }
}
- } else {
+ }else {
smoothScrollTo(
mCollapseOffset < mCollapsibleHeight / 2 ? 0 : mCollapsibleHeight, 0);
}
@@ -421,6 +448,11 @@
mVelocityTracker.clear();
}
+ private void dismiss() {
+ mRunOnDismissedListener = new RunOnDismissedListener();
+ post(mRunOnDismissedListener);
+ }
+
@Override
public void computeScroll() {
super.computeScroll();
@@ -430,8 +462,7 @@
if (keepGoing) {
postInvalidateOnAnimation();
} else if (mDismissOnScrollerFinished && mOnDismissedListener != null) {
- mRunOnDismissedListener = new RunOnDismissedListener();
- post(mRunOnDismissedListener);
+ dismiss();
}
}
}
@@ -443,6 +474,10 @@
}
private float performDrag(float dy) {
+ if (getShowAtTop()) {
+ return 0;
+ }
+
final float newPos = Math.max(0, Math.min(mCollapseOffset + dy,
mCollapsibleHeight + mUncollapsibleHeight));
if (newPos != mCollapseOffset) {
@@ -656,7 +691,7 @@
@Override
public boolean onNestedPreFling(View target, float velocityX, float velocityY) {
- if (velocityY > mMinFlingVelocity && mCollapseOffset != 0) {
+ if (!getShowAtTop() && velocityY > mMinFlingVelocity && mCollapseOffset != 0) {
smoothScrollTo(0, velocityY);
return true;
}
@@ -666,12 +701,21 @@
@Override
public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {
if (!consumed && Math.abs(velocityY) > mMinFlingVelocity) {
- if (isDismissable()
- && velocityY < 0 && mCollapseOffset > mCollapsibleHeight) {
- smoothScrollTo(mCollapsibleHeight + mUncollapsibleHeight, velocityY);
- mDismissOnScrollerFinished = true;
+ if (getShowAtTop()) {
+ if (isDismissable() && velocityY > 0) {
+ abortAnimation();
+ dismiss();
+ } else {
+ smoothScrollTo(velocityY < 0 ? mCollapsibleHeight : 0, velocityY);
+ }
} else {
- smoothScrollTo(velocityY > 0 ? 0 : mCollapsibleHeight, velocityY);
+ if (isDismissable()
+ && velocityY < 0 && mCollapseOffset > mCollapsibleHeight) {
+ smoothScrollTo(mCollapsibleHeight + mUncollapsibleHeight, velocityY);
+ mDismissOnScrollerFinished = true;
+ } else {
+ smoothScrollTo(velocityY > 0 ? 0 : mCollapsibleHeight, velocityY);
+ }
}
return true;
}
@@ -794,7 +838,11 @@
updateCollapseOffset(oldCollapsibleHeight, !isDragging());
- mTopOffset = Math.max(0, heightSize - heightUsed) + (int) mCollapseOffset;
+ if (getShowAtTop()) {
+ mTopOffset = 0;
+ } else {
+ mTopOffset = Math.max(0, heightSize - heightUsed) + (int) mCollapseOffset;
+ }
setMeasuredDimension(sourceWidth, heightSize);
}
diff --git a/core/proto/android/os/incident.proto b/core/proto/android/os/incident.proto
index 73a9fbb..8ed958d 100644
--- a/core/proto/android/os/incident.proto
+++ b/core/proto/android/os/incident.proto
@@ -18,8 +18,6 @@
option java_multiple_files = true;
option java_outer_classname = "IncidentProtoMetadata";
-import "frameworks/base/libs/incident/proto/android/privacy.proto";
-import "frameworks/base/libs/incident/proto/android/section.proto";
import "frameworks/base/core/proto/android/os/cpufreq.proto";
import "frameworks/base/core/proto/android/os/cpuinfo.proto";
import "frameworks/base/core/proto/android/os/incidentheader.proto";
@@ -42,6 +40,8 @@
import "frameworks/base/core/proto/android/service/package.proto";
import "frameworks/base/core/proto/android/service/print.proto";
import "frameworks/base/core/proto/android/service/procstats.proto";
+import "frameworks/base/libs/incident/proto/android/privacy.proto";
+import "frameworks/base/libs/incident/proto/android/section.proto";
package android.os;
diff --git a/core/proto/android/os/procrank.proto b/core/proto/android/os/procrank.proto
index 9945f2e..f684c84 100644
--- a/core/proto/android/os/procrank.proto
+++ b/core/proto/android/os/procrank.proto
@@ -18,12 +18,15 @@
option java_multiple_files = true;
option java_outer_classname = "ProcrankProto";
+import "frameworks/base/libs/incident/proto/android/privacy.proto";
import "frameworks/base/tools/streaming_proto/stream.proto";
package android.os;
//Memory usage of running processes
message Procrank {
+ option (android.msg_privacy).dest = DEST_AUTOMATIC;
+
// Currently running process
repeated ProcessProto processes = 1;
@@ -34,6 +37,7 @@
// Next Tag: 11
message ProcessProto {
option (stream_proto.stream_msg).enable_fields_mapping = true;
+ option (android.msg_privacy).dest = DEST_AUTOMATIC;
// ID of the process
optional int32 pid = 1;
@@ -68,6 +72,8 @@
// Next Tag: 3
message SummaryProto {
+ option (android.msg_privacy).dest = DEST_AUTOMATIC;
+
optional ProcessProto total = 1;
optional ZramProto zram = 2;
@@ -77,9 +83,13 @@
// TODO: sync on how to use these values
message ZramProto {
+ option (android.msg_privacy).dest = DEST_AUTOMATIC;
+
optional string raw_text = 1;
}
message RamProto {
+ option (android.msg_privacy).dest = DEST_AUTOMATIC;
+
optional string raw_text = 1;
}
diff --git a/core/proto/android/providers/settings.proto b/core/proto/android/providers/settings.proto
index 3229140..8d091ab 100644
--- a/core/proto/android/providers/settings.proto
+++ b/core/proto/android/providers/settings.proto
@@ -367,7 +367,7 @@
optional SettingProto database_creation_buildid = 330;
optional SettingProto contacts_database_wal_enabled = 275;
optional SettingProto location_settings_link_to_permissions_enabled = 331;
- optional SettingProto backup_refactored_service_disabled = 332;
+ reserved 332; // Removed backup_refactored_service_disabled
optional SettingProto euicc_factory_reset_timeout_millis = 333;
optional SettingProto storage_settings_clobber_threshold = 334;
optional SettingProto multi_sim_voice_call_subscription = 276;
diff --git a/core/proto/android/service/battery.proto b/core/proto/android/service/battery.proto
index 8382b82..4cb7fd3 100644
--- a/core/proto/android/service/battery.proto
+++ b/core/proto/android/service/battery.proto
@@ -46,9 +46,11 @@
optional bool are_updates_stopped = 1;
// Plugged status of power sources
optional android.os.BatteryManagerProto.PlugType plugged = 2;
- // Max current in microamperes
+ // Max current in microamperes. This may be 0 if the device's kernel drivers
+ // don't support it.
optional int32 max_charging_current = 3;
- // Max voltage
+ // Max voltage. This may be 0 if the device's kernel drivers don't support
+ // it.
optional int32 max_charging_voltage = 4;
// Battery capacity in microampere-hours
optional int32 charge_counter = 5;
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index d15c075..5906b27 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -1036,7 +1036,7 @@
<eat-comment />
<!-- Used for permissions that are associated with accessing
- camera or capturing images/video from the device. -->
+ body or environmental sensors. -->
<permission-group android:name="android.permission-group.SENSORS"
android:icon="@drawable/perm_group_sensors"
android:label="@string/permgrouplab_sensors"
@@ -2058,6 +2058,11 @@
<eat-comment />
<!-- Allows an application to install a shortcut in Launcher.
+ <p>In Android O (API level 26) and higher, the <code>INSTALL_SHORTCUT</code> broadcast no
+ longer has any effect on your app because it's a private, implicit
+ broadcast. Instead, you should create an app shortcut by using the
+ {@link android.content.pm.ShortcutManager#requestPinShortcut requestPinShortcut()}
+ method from the {@link android.content.pm.ShortcutManager} class.
<p>Protection level: normal
-->
<permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT"
diff --git a/core/res/res/values/attrs.xml b/core/res/res/values/attrs.xml
index da8a9cc..3b49d9d 100644
--- a/core/res/res/values/attrs.xml
+++ b/core/res/res/values/attrs.xml
@@ -8538,6 +8538,8 @@
<attr name="maxWidth" />
<attr name="maxCollapsedHeight" format="dimension" />
<attr name="maxCollapsedHeightSmall" format="dimension" />
+ <!-- Whether the Drawer should be positioned at the top rather than at the bottom. -->
+ <attr name="showAtTop" format="boolean" />
</declare-styleable>
<declare-styleable name="MessagingLinearLayout">
diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml
index 5f756fa..fc64918 100644
--- a/core/res/res/values/config.xml
+++ b/core/res/res/values/config.xml
@@ -565,6 +565,12 @@
<integer translatable="false" name="config_wifi_framework_wifi_score_good_link_speed_24">24</integer>
<integer translatable="false" name="config_wifi_framework_wifi_score_good_link_speed_5">36</integer>
+ <!-- Integer delay in milliseconds before shutting down soft AP when there
+ are no connected devices. Framework will enforce a minimum limit on
+ this value and this setting will be overridden if the provided value is
+ smaller than the limit. -->
+ <integer translatable="false" name="config_wifi_framework_soft_ap_timeout_delay">600000</integer>
+
<string translatable="false" name="config_wifi_random_mac_oui">DA-A1-19</string>
<string translatable="false" name="config_wifi_framework_sap_2G_channel_list">1,6,11</string>
diff --git a/core/res/res/values/strings.xml b/core/res/res/values/strings.xml
index 2f1d679..93bd4ec 100644
--- a/core/res/res/values/strings.xml
+++ b/core/res/res/values/strings.xml
@@ -4753,5 +4753,8 @@
<string name="shortcut_restore_unknown_issue">Couldn\u2019t restore shortcut</string>
<!--Battery saver warning. STOPSHIP: Remove it eventually. -->
- <string name="battery_saver_warning" translatable="false">Battery saver activated.\n\nSee go/extreme-battery-saver.\n\nThis contains aggressive experimental changes for P and may affect background app behavior.\n</string>
+ <string name="battery_saver_warning" translatable="false">\"Extreme\" battery saver activated.\n\nSee the details at: go/extreme-battery-saver\n\nEBS aggressively throttles background apps and changes screen-off behavior.\n</string>
+
+ <!--Battery saver warning. STOPSHIP: Remove it eventually. -->
+ <string name="battery_saver_warning_title" translatable="false">Extreme battery saver</string>
</resources>
diff --git a/core/res/res/values/symbols.xml b/core/res/res/values/symbols.xml
index ad947b7..d944e4b 100644
--- a/core/res/res/values/symbols.xml
+++ b/core/res/res/values/symbols.xml
@@ -391,6 +391,8 @@
<java-symbol type="integer" name="config_wifi_framework_min_tx_rate_for_staying_on_network" />
<java-symbol type="integer" name="config_wifi_framework_min_rx_rate_for_staying_on_network" />
+ <java-symbol type="integer" name="config_wifi_framework_soft_ap_timeout_delay" />
+
<java-symbol type="bool" name="config_wifi_framework_cellular_handover_enable_user_triggered_adjustment" />
<java-symbol type="integer" name="config_wifi_framework_associated_full_scan_tx_packet_threshold" />
<java-symbol type="integer" name="config_wifi_framework_associated_full_scan_rx_packet_threshold" />
@@ -3159,4 +3161,6 @@
<java-symbol type="layout" name="unsupported_compile_sdk_dialog_content" />
<java-symbol type="string" name="unsupported_compile_sdk_message" />
<java-symbol type="string" name="unsupported_compile_sdk_check_update" />
+
+ <java-symbol type="string" name="battery_saver_warning_title" />
</resources>
diff --git a/core/tests/coretests/src/android/provider/SettingsBackupTest.java b/core/tests/coretests/src/android/provider/SettingsBackupTest.java
index 4ce6029..4e0e5ed 100644
--- a/core/tests/coretests/src/android/provider/SettingsBackupTest.java
+++ b/core/tests/coretests/src/android/provider/SettingsBackupTest.java
@@ -108,7 +108,6 @@
Settings.Global.APP_IDLE_CONSTANTS,
Settings.Global.ASSISTED_GPS_ENABLED,
Settings.Global.AUDIO_SAFE_VOLUME_STATE,
- Settings.Global.BACKUP_REFACTORED_SERVICE_DISABLED,
Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD,
Settings.Global.BATTERY_DISCHARGE_THRESHOLD,
Settings.Global.BATTERY_SAVER_DEVICE_SPECIFIC_CONSTANTS,
diff --git a/core/tests/coretests/src/com/android/internal/app/ResolverActivityTest.java b/core/tests/coretests/src/com/android/internal/app/ResolverActivityTest.java
index 55e804b..9fcb06e 100644
--- a/core/tests/coretests/src/com/android/internal/app/ResolverActivityTest.java
+++ b/core/tests/coretests/src/com/android/internal/app/ResolverActivityTest.java
@@ -18,6 +18,7 @@
import com.android.internal.R;
import com.android.internal.app.ResolverActivity.ResolvedComponentInfo;
+import com.android.internal.widget.ResolverDrawerLayout;
import org.junit.Before;
import org.junit.Rule;
@@ -33,6 +34,8 @@
import android.support.test.InstrumentationRegistry;
import android.support.test.rule.ActivityTestRule;
import android.support.test.runner.AndroidJUnit4;
+import android.view.View;
+import android.widget.RelativeLayout;
import java.util.ArrayList;
import java.util.List;
@@ -100,6 +103,34 @@
}
@Test
+ public void setShowAtTopToTrue() throws Exception {
+ Intent sendIntent = createSendImageIntent();
+ List<ResolvedComponentInfo> resolvedComponentInfos = createResolvedComponentsForTest(2);
+
+ when(sOverrides.resolverListController.getResolversForIntent(Mockito.anyBoolean(),
+ Mockito.anyBoolean(),
+ Mockito.isA(List.class))).thenReturn(resolvedComponentInfos);
+ waitForIdle();
+
+ final ResolverWrapperActivity activity = mActivityRule.launchActivity(sendIntent);
+ final View resolverList = activity.findViewById(R.id.resolver_list);
+ final RelativeLayout profileView =
+ (RelativeLayout) activity.findViewById(R.id.profile_button).getParent();
+ assertThat("Drawer should show at bottom by default",
+ profileView.getBottom() == resolverList.getTop() && profileView.getTop() > 0);
+
+ activity.runOnUiThread(() -> {
+ ResolverDrawerLayout layout = (ResolverDrawerLayout)
+ activity.findViewById(
+ R.id.contentPanel);
+ layout.setShowAtTop(true);
+ });
+ waitForIdle();
+ assertThat("Drawer should show at top with new attribute",
+ profileView.getBottom() == resolverList.getTop() && profileView.getTop() == 0);
+ }
+
+ @Test
public void hasLastChosenActivity() throws Exception {
Intent sendIntent = createSendImageIntent();
List<ResolvedComponentInfo> resolvedComponentInfos = createResolvedComponentsForTest(2);
@@ -283,4 +314,4 @@
private void waitForIdle() {
InstrumentationRegistry.getInstrumentation().waitForIdleSync();
}
-}
\ No newline at end of file
+}
diff --git a/libs/incident/include/android/os/IncidentReportArgs.h b/libs/incident/include/android/os/IncidentReportArgs.h
index da80989..2849d58 100644
--- a/libs/incident/include/android/os/IncidentReportArgs.h
+++ b/libs/incident/include/android/os/IncidentReportArgs.h
@@ -29,6 +29,12 @@
using namespace std;
+// DESTINATION enum value, sync with proto/android/privacy.proto
+const uint8_t DEST_LOCAL = 0;
+const uint8_t DEST_EXPLICIT = 100;
+const uint8_t DEST_AUTOMATIC = 200;
+
+
class IncidentReportArgs : public Parcelable {
public:
IncidentReportArgs();
@@ -41,19 +47,19 @@
void setAll(bool all);
void setDest(int dest);
void addSection(int section);
- void addHeader(const vector<int8_t>& header);
+ void addHeader(const vector<uint8_t>& header);
inline bool all() const { return mAll; }
bool containsSection(int section) const;
inline int dest() const { return mDest; }
inline const set<int>& sections() const { return mSections; }
- inline const vector<vector<int8_t>>& headers() const { return mHeaders; }
+ inline const vector<vector<uint8_t>>& headers() const { return mHeaders; }
void merge(const IncidentReportArgs& that);
private:
set<int> mSections;
- vector<vector<int8_t>> mHeaders;
+ vector<vector<uint8_t>> mHeaders;
bool mAll;
int mDest;
};
diff --git a/libs/incident/proto/android/privacy.proto b/libs/incident/proto/android/privacy.proto
index 5fd75d6..7590b22 100644
--- a/libs/incident/proto/android/privacy.proto
+++ b/libs/incident/proto/android/privacy.proto
@@ -34,21 +34,23 @@
// Fields or messages annotated with DEST_EXPLICIT can be sent
// off the device with an explicit user action.
- DEST_EXPLICIT = 1;
+ DEST_EXPLICIT = 100;
// Fields or messages annotated with DEST_AUTOMATIC can be sent by
// automatic means, without per-sending user consent. The user
// still must have previously accepted a consent to share this
// information.
- DEST_AUTOMATIC = 2;
+ DEST_AUTOMATIC = 200;
- // There is no more permissive option than DEST_AUTOMATIC.
+ // This is the default value, which could be overridden by other values.
+ // The reason to pick 255 is it fits into one byte.
+ DEST_UNSET = 255;
+
+ // Currently use 0, 100, 200 and 255, values in between are reserved for futures.
}
message PrivacyFlags {
- optional Destination dest = 1 [
- default = DEST_EXPLICIT
- ];
+ optional Destination dest = 1 [ default = DEST_UNSET ];
// regex to filter pii sensitive info from a string field type
repeated string patterns = 2;
@@ -58,3 +60,8 @@
// Flags for automatically filtering statistics
optional PrivacyFlags privacy = 102672883;
}
+
+extend google.protobuf.MessageOptions {
+ // Flags used to annotate a message which all its unset primitive types inhert this tag.
+ optional PrivacyFlags msg_privacy = 102672883;
+}
diff --git a/libs/incident/src/IncidentReportArgs.cpp b/libs/incident/src/IncidentReportArgs.cpp
index e628722..bd9c8ee 100644
--- a/libs/incident/src/IncidentReportArgs.cpp
+++ b/libs/incident/src/IncidentReportArgs.cpp
@@ -69,7 +69,7 @@
return err;
}
- for (vector<vector<int8_t>>::const_iterator it = mHeaders.begin(); it != mHeaders.end(); it++) {
+ for (vector<vector<uint8_t>>::const_iterator it = mHeaders.begin(); it != mHeaders.end(); it++) {
err = out->writeByteVector(*it);
if (err != NO_ERROR) {
return err;
@@ -161,7 +161,7 @@
}
void
-IncidentReportArgs::addHeader(const vector<int8_t>& header)
+IncidentReportArgs::addHeader(const vector<uint8_t>& header)
{
mHeaders.push_back(header);
}
diff --git a/media/java/android/media/MediaMetadataRetriever.java b/media/java/android/media/MediaMetadataRetriever.java
index 0b86401..745eb74d 100644
--- a/media/java/android/media/MediaMetadataRetriever.java
+++ b/media/java/android/media/MediaMetadataRetriever.java
@@ -226,9 +226,12 @@
/**
* Call this method after setDataSource(). This method finds a
* representative frame close to the given time position by considering
- * the given option if possible, and returns it as a bitmap. This is
- * useful for generating a thumbnail for an input data source or just
- * obtain and display a frame at the given time position.
+ * the given option if possible, and returns it as a bitmap.
+ *
+ * <p>If you don't need a full-resolution
+ * frame (for example, because you need a thumbnail image), use
+ * {@link #getScaledFrameAtTime getScaledFrameAtTime()} instead of this
+ * method.</p>
*
* @param timeUs The time position where the frame will be retrieved.
* When retrieving the frame at the given time position, there is no
@@ -315,11 +318,15 @@
/**
* Call this method after setDataSource(). This method finds a
* representative frame close to the given time position if possible,
- * and returns it as a bitmap. This is useful for generating a thumbnail
- * for an input data source. Call this method if one does not care
+ * and returns it as a bitmap. Call this method if one does not care
* how the frame is found as long as it is close to the given time;
* otherwise, please call {@link #getFrameAtTime(long, int)}.
*
+ * <p>If you don't need a full-resolution
+ * frame (for example, because you need a thumbnail image), use
+ * {@link #getScaledFrameAtTime getScaledFrameAtTime()} instead of this
+ * method.</p>
+ *
* @param timeUs The time position where the frame will be retrieved.
* When retrieving the frame at the given time position, there is no
* guarentee that the data source has a frame located at the position.
@@ -339,11 +346,15 @@
/**
* Call this method after setDataSource(). This method finds a
* representative frame at any time position if possible,
- * and returns it as a bitmap. This is useful for generating a thumbnail
- * for an input data source. Call this method if one does not
+ * and returns it as a bitmap. Call this method if one does not
* care about where the frame is located; otherwise, please call
* {@link #getFrameAtTime(long)} or {@link #getFrameAtTime(long, int)}
*
+ * <p>If you don't need a full-resolution
+ * frame (for example, because you need a thumbnail image), use
+ * {@link #getScaledFrameAtTime getScaledFrameAtTime()} instead of this
+ * method.</p>
+ *
* @return A Bitmap containing a representative video frame, which
* can be null, if such a frame cannot be retrieved.
*
diff --git a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java
index 52b4f4d..fabdbd4 100644
--- a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java
+++ b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java
@@ -1057,9 +1057,6 @@
Settings.Global.LOCATION_SETTINGS_LINK_TO_PERMISSIONS_ENABLED,
GlobalSettingsProto.LOCATION_SETTINGS_LINK_TO_PERMISSIONS_ENABLED);
dumpSetting(s, p,
- Settings.Global.BACKUP_REFACTORED_SERVICE_DISABLED,
- GlobalSettingsProto.BACKUP_REFACTORED_SERVICE_DISABLED);
- dumpSetting(s, p,
Settings.Global.EUICC_FACTORY_RESET_TIMEOUT_MILLIS,
GlobalSettingsProto.EUICC_FACTORY_RESET_TIMEOUT_MILLIS);
dumpSetting(s, p,
diff --git a/proto/src/system_messages.proto b/proto/src/system_messages.proto
index 52f721b..75d080d 100644
--- a/proto/src/system_messages.proto
+++ b/proto/src/system_messages.proto
@@ -223,6 +223,9 @@
// Package: com.android.systemui
NOTE_TV_PIP = 1100;
+ // Extreme battery saver notifiaction.
+ NOTE_BATTERY_SAVER_WARNING = 1200;
+
// Notify the user that open Wi-Fi networks are available.
// Package: android
NOTE_NETWORK_AVAILABLE = 17303299;
diff --git a/services/backup/java/com/android/server/backup/BackupManagerService.java b/services/backup/java/com/android/server/backup/BackupManagerService.java
deleted file mode 100644
index b2c02b9..0000000
--- a/services/backup/java/com/android/server/backup/BackupManagerService.java
+++ /dev/null
@@ -1,11494 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.server.backup;
-
-import static android.app.backup.BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_NAME;
-import static android.app.backup.BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_VERSION;
-import static android.app.backup.BackupManagerMonitor.EXTRA_LOG_OLD_VERSION;
-import static android.app.backup.BackupManagerMonitor.EXTRA_LOG_POLICY_ALLOW_APKS;
-import static android.app.backup.BackupManagerMonitor.EXTRA_LOG_MANIFEST_PACKAGE_NAME;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_VERSION_OF_BACKUP_OLDER;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_FULL_RESTORE_SIGNATURE_MISMATCH;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_SYSTEM_APP_NO_AGENT;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_FULL_RESTORE_ALLOW_BACKUP_FALSE;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_APK_NOT_INSTALLED;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_CANNOT_RESTORE_WITHOUT_APK;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_MISSING_SIGNATURE;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_EXPECTED_DIFFERENT_PACKAGE;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_RESTORE_ANY_VERSION;
-import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_VERSIONS_MATCH;
-import static android.content.pm.ApplicationInfo.PRIVATE_FLAG_BACKUP_IN_FOREGROUND;
-
-import android.app.ActivityManager;
-import android.app.AlarmManager;
-import android.app.AppGlobals;
-import android.app.ApplicationThreadConstants;
-import android.app.IActivityManager;
-import android.app.IBackupAgent;
-import android.app.PackageInstallObserver;
-import android.app.PendingIntent;
-import android.app.backup.BackupAgent;
-import android.app.backup.BackupDataInput;
-import android.app.backup.BackupDataOutput;
-import android.app.backup.BackupManager;
-import android.app.backup.BackupManagerMonitor;
-import android.app.backup.BackupProgress;
-import android.app.backup.BackupTransport;
-import android.app.backup.FullBackup;
-import android.app.backup.FullBackupDataOutput;
-import android.app.backup.IBackupManager;
-import android.app.backup.IBackupManagerMonitor;
-import android.app.backup.IBackupObserver;
-import android.app.backup.IFullBackupRestoreObserver;
-import android.app.backup.IRestoreObserver;
-import android.app.backup.IRestoreSession;
-import android.app.backup.ISelectBackupTransportCallback;
-import android.app.backup.RestoreDescription;
-import android.app.backup.RestoreSet;
-import android.content.ActivityNotFoundException;
-import android.content.BroadcastReceiver;
-import android.content.ComponentName;
-import android.content.ContentResolver;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.content.ServiceConnection;
-import android.content.pm.ApplicationInfo;
-import android.content.pm.IPackageDataObserver;
-import android.content.pm.IPackageDeleteObserver;
-import android.content.pm.IPackageManager;
-import android.content.pm.PackageInfo;
-import android.content.pm.PackageManager;
-import android.content.pm.PackageManager.NameNotFoundException;
-import android.content.pm.Signature;
-import android.database.ContentObserver;
-import android.net.Uri;
-import android.os.PowerManager.ServiceType;
-import android.os.PowerSaveState;
-import android.os.Binder;
-import android.os.Build;
-import android.os.Bundle;
-import android.os.Environment;
-import android.os.Environment.UserEnvironment;
-import android.os.Handler;
-import android.os.HandlerThread;
-import android.os.IBinder;
-import android.os.Looper;
-import android.os.Message;
-import android.os.ParcelFileDescriptor;
-import android.os.PowerManager;
-import android.os.Process;
-import android.os.RemoteException;
-import android.os.SELinux;
-import android.os.ServiceManager;
-import android.os.SystemClock;
-import android.os.Trace;
-import android.os.UserHandle;
-import android.os.WorkSource;
-import android.os.storage.IStorageManager;
-import android.os.storage.StorageManager;
-import android.provider.Settings;
-import android.system.ErrnoException;
-import android.system.Os;
-import android.text.TextUtils;
-import android.util.ArraySet;
-import android.util.AtomicFile;
-import android.util.EventLog;
-import android.util.Log;
-import android.util.Pair;
-import android.util.Slog;
-import android.util.SparseArray;
-import android.util.StringBuilderPrinter;
-
-import com.android.internal.annotations.GuardedBy;
-import com.android.internal.backup.IBackupTransport;
-import com.android.internal.backup.IObbBackupService;
-import com.android.internal.util.ArrayUtils;
-import com.android.internal.util.DumpUtils;
-import com.android.server.AppWidgetBackupBridge;
-import com.android.server.EventLogTags;
-import com.android.server.SystemConfig;
-import com.android.server.SystemService;
-import com.android.server.backup.PackageManagerBackupAgent.Metadata;
-
-import libcore.io.IoUtils;
-
-import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.EOFException;
-import java.io.File;
-import java.io.FileDescriptor;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.PrintWriter;
-import java.io.RandomAccessFile;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.InvalidKeyException;
-import java.security.Key;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
-import java.security.spec.InvalidKeySpecException;
-import java.security.spec.KeySpec;
-import java.text.SimpleDateFormat;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Queue;
-import java.util.Random;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.zip.Deflater;
-import java.util.zip.DeflaterOutputStream;
-import java.util.zip.InflaterInputStream;
-
-import javax.crypto.BadPaddingException;
-import javax.crypto.Cipher;
-import javax.crypto.CipherInputStream;
-import javax.crypto.CipherOutputStream;
-import javax.crypto.IllegalBlockSizeException;
-import javax.crypto.NoSuchPaddingException;
-import javax.crypto.SecretKey;
-import javax.crypto.SecretKeyFactory;
-import javax.crypto.spec.IvParameterSpec;
-import javax.crypto.spec.PBEKeySpec;
-import javax.crypto.spec.SecretKeySpec;
-
-/**
- * @Deprecated Use RefactoredBackupManagerService instead. This class is only
- * kept for fallback and archeology reasons and will be removed soon.
- */
-public class BackupManagerService implements BackupManagerServiceInterface {
-
- private static final String TAG = "BackupManagerService";
- static final boolean DEBUG = true;
- static final boolean MORE_DEBUG = false;
- static final boolean DEBUG_SCHEDULING = MORE_DEBUG || true;
-
- // File containing backup-enabled state. Contains a single byte;
- // nonzero == enabled. File missing or contains a zero byte == disabled.
- static final String BACKUP_ENABLE_FILE = "backup_enabled";
-
- // System-private key used for backing up an app's widget state. Must
- // begin with U+FFxx by convention (we reserve all keys starting
- // with U+FF00 or higher for system use).
- static final String KEY_WIDGET_STATE = "\uffed\uffedwidget";
-
- // Historical and current algorithm names
- static final String PBKDF_CURRENT = "PBKDF2WithHmacSHA1";
- static final String PBKDF_FALLBACK = "PBKDF2WithHmacSHA1And8bit";
-
- // Name and current contents version of the full-backup manifest file
- //
- // Manifest version history:
- //
- // 1 : initial release
- static final String BACKUP_MANIFEST_FILENAME = "_manifest";
- static final int BACKUP_MANIFEST_VERSION = 1;
-
- // External archive format version history:
- //
- // 1 : initial release
- // 2 : no format change per se; version bump to facilitate PBKDF2 version skew detection
- // 3 : introduced "_meta" metadata file; no other format change per se
- // 4 : added support for new device-encrypted storage locations
- // 5 : added support for key-value packages
- static final int BACKUP_FILE_VERSION = 5;
- static final String BACKUP_FILE_HEADER_MAGIC = "ANDROID BACKUP\n";
- static final int BACKUP_PW_FILE_VERSION = 2;
- static final String BACKUP_METADATA_FILENAME = "_meta";
- static final int BACKUP_METADATA_VERSION = 1;
- static final int BACKUP_WIDGET_METADATA_TOKEN = 0x01FFED01;
-
- static final int TAR_HEADER_LONG_RADIX = 8;
- static final int TAR_HEADER_OFFSET_FILESIZE = 124;
- static final int TAR_HEADER_LENGTH_FILESIZE = 12;
- static final int TAR_HEADER_OFFSET_MODTIME = 136;
- static final int TAR_HEADER_LENGTH_MODTIME = 12;
- static final int TAR_HEADER_OFFSET_MODE = 100;
- static final int TAR_HEADER_LENGTH_MODE = 8;
- static final int TAR_HEADER_OFFSET_PATH_PREFIX = 345;
- static final int TAR_HEADER_LENGTH_PATH_PREFIX = 155;
- static final int TAR_HEADER_OFFSET_PATH = 0;
- static final int TAR_HEADER_LENGTH_PATH = 100;
- static final int TAR_HEADER_OFFSET_TYPE_CHAR = 156;
-
- static final boolean COMPRESS_FULL_BACKUPS = true; // should be true in production
-
- static final String SETTINGS_PACKAGE = "com.android.providers.settings";
- static final String SHARED_BACKUP_AGENT_PACKAGE = "com.android.sharedstoragebackup";
- static final String SERVICE_ACTION_TRANSPORT_HOST = "android.backup.TRANSPORT_HOST";
-
- // Retry interval for clear/init when the transport is unavailable
- private static final long TRANSPORT_RETRY_INTERVAL = 1 * AlarmManager.INTERVAL_HOUR;
-
- private static final String RUN_BACKUP_ACTION = "android.app.backup.intent.RUN";
- private static final String RUN_INITIALIZE_ACTION = "android.app.backup.intent.INIT";
- private static final int MSG_RUN_BACKUP = 1;
- private static final int MSG_RUN_ADB_BACKUP = 2;
- private static final int MSG_RUN_RESTORE = 3;
- private static final int MSG_RUN_CLEAR = 4;
- private static final int MSG_RUN_GET_RESTORE_SETS = 6;
- private static final int MSG_RESTORE_SESSION_TIMEOUT = 8;
- private static final int MSG_FULL_CONFIRMATION_TIMEOUT = 9;
- private static final int MSG_RUN_ADB_RESTORE = 10;
- private static final int MSG_RETRY_INIT = 11;
- private static final int MSG_RETRY_CLEAR = 12;
- private static final int MSG_WIDGET_BROADCAST = 13;
- private static final int MSG_RUN_FULL_TRANSPORT_BACKUP = 14;
- private static final int MSG_REQUEST_BACKUP = 15;
- private static final int MSG_SCHEDULE_BACKUP_PACKAGE = 16;
- private static final int MSG_BACKUP_OPERATION_TIMEOUT = 17;
- private static final int MSG_RESTORE_OPERATION_TIMEOUT = 18;
-
- // backup task state machine tick
- static final int MSG_BACKUP_RESTORE_STEP = 20;
- static final int MSG_OP_COMPLETE = 21;
-
- // Timeout interval for deciding that a bind or clear-data has taken too long
- static final long TIMEOUT_INTERVAL = 10 * 1000;
-
- // Timeout intervals for agent backup & restore operations
- static final long TIMEOUT_BACKUP_INTERVAL = 30 * 1000;
- static final long TIMEOUT_FULL_BACKUP_INTERVAL = 5 * 60 * 1000;
- static final long TIMEOUT_SHARED_BACKUP_INTERVAL = 30 * 60 * 1000;
- static final long TIMEOUT_RESTORE_INTERVAL = 60 * 1000;
- static final long TIMEOUT_RESTORE_FINISHED_INTERVAL = 30 * 1000;
-
- // User confirmation timeout for a full backup/restore operation. It's this long in
- // order to give them time to enter the backup password.
- static final long TIMEOUT_FULL_CONFIRMATION = 60 * 1000;
-
- // If an app is busy when we want to do a full-data backup, how long to defer the retry.
- // This is fuzzed, so there are two parameters; backoff_min + Rand[0, backoff_fuzz)
- static final long BUSY_BACKOFF_MIN_MILLIS = 1000 * 60 * 60; // one hour
- static final int BUSY_BACKOFF_FUZZ = 1000 * 60 * 60 * 2; // two hours
-
- BackupManagerConstants mConstants;
- Context mContext;
- private PackageManager mPackageManager;
- IPackageManager mPackageManagerBinder;
- private IActivityManager mActivityManager;
- private PowerManager mPowerManager;
- private AlarmManager mAlarmManager;
- private IStorageManager mStorageManager;
-
- IBackupManager mBackupManagerBinder;
-
- private final TransportManager mTransportManager;
-
- boolean mEnabled; // access to this is synchronized on 'this'
- boolean mProvisioned;
- boolean mAutoRestore;
- PowerManager.WakeLock mWakelock;
- BackupHandler mBackupHandler;
- PendingIntent mRunBackupIntent, mRunInitIntent;
- BroadcastReceiver mRunBackupReceiver, mRunInitReceiver;
- // map UIDs to the set of participating packages under that UID
- final SparseArray<HashSet<String>> mBackupParticipants
- = new SparseArray<HashSet<String>>();
- // set of backup services that have pending changes
- class BackupRequest {
- public String packageName;
-
- BackupRequest(String pkgName) {
- packageName = pkgName;
- }
-
- public String toString() {
- return "BackupRequest{pkg=" + packageName + "}";
- }
- }
- // Backups that we haven't started yet. Keys are package names.
- HashMap<String,BackupRequest> mPendingBackups
- = new HashMap<String,BackupRequest>();
-
- // Pseudoname that we use for the Package Manager metadata "package"
- static final String PACKAGE_MANAGER_SENTINEL = "@pm@";
-
- // locking around the pending-backup management
- final Object mQueueLock = new Object();
-
- // The thread performing the sequence of queued backups binds to each app's agent
- // in succession. Bind notifications are asynchronously delivered through the
- // Activity Manager; use this lock object to signal when a requested binding has
- // completed.
- final Object mAgentConnectLock = new Object();
- IBackupAgent mConnectedAgent;
- volatile boolean mBackupRunning;
- volatile boolean mConnecting;
- volatile long mLastBackupPass;
-
- // For debugging, we maintain a progress trace of operations during backup
- static final boolean DEBUG_BACKUP_TRACE = true;
- final List<String> mBackupTrace = new ArrayList<String>();
-
- // A similar synchronization mechanism around clearing apps' data for restore
- final Object mClearDataLock = new Object();
- volatile boolean mClearingData;
-
- @GuardedBy("mPendingRestores")
- private boolean mIsRestoreInProgress;
- @GuardedBy("mPendingRestores")
- private final Queue<PerformUnifiedRestoreTask> mPendingRestores = new ArrayDeque<>();
-
- ActiveRestoreSession mActiveRestoreSession;
-
- // Watch the device provisioning operation during setup
- ContentObserver mProvisionedObserver;
-
- // The published binder is actually to a singleton trampoline object that calls
- // through to the proper code. This indirection lets us turn down the heavy
- // implementation object on the fly without disturbing binders that have been
- // cached elsewhere in the system.
- static Trampoline sInstance;
- static Trampoline getInstance() {
- // Always constructed during system bringup, so no need to lazy-init
- return sInstance;
- }
-
- public static final class Lifecycle extends SystemService {
-
- public Lifecycle(Context context) {
- super(context);
- sInstance = new Trampoline(context);
- }
-
- @Override
- public void onStart() {
- publishBinderService(Context.BACKUP_SERVICE, sInstance);
- }
-
- @Override
- public void onUnlockUser(int userId) {
- if (userId == UserHandle.USER_SYSTEM) {
- sInstance.unlockSystemUser();
- }
- }
- }
-
- // Called through the trampoline from onUnlockUser(), then we buck the work
- // off to the background thread to keep the unlock time down.
- public void unlockSystemUser() {
- // Migrate legacy setting
- Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backup migrate");
- if (!backupSettingMigrated(UserHandle.USER_SYSTEM)) {
- if (DEBUG) {
- Slog.i(TAG, "Backup enable apparently not migrated");
- }
- final ContentResolver r = sInstance.mContext.getContentResolver();
- final int enableState = Settings.Secure.getIntForUser(r,
- Settings.Secure.BACKUP_ENABLED, -1, UserHandle.USER_SYSTEM);
- if (enableState >= 0) {
- if (DEBUG) {
- Slog.i(TAG, "Migrating enable state " + (enableState != 0));
- }
- writeBackupEnableState(enableState != 0, UserHandle.USER_SYSTEM);
- Settings.Secure.putStringForUser(r,
- Settings.Secure.BACKUP_ENABLED, null, UserHandle.USER_SYSTEM);
- } else {
- if (DEBUG) {
- Slog.i(TAG, "Backup not yet configured; retaining null enable state");
- }
- }
- }
- Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
-
- Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backup enable");
- try {
- sInstance.setBackupEnabled(readBackupEnableState(UserHandle.USER_SYSTEM));
- } catch (RemoteException e) {
- // can't happen; it's a local object
- }
- Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
- }
-
- class ProvisionedObserver extends ContentObserver {
- public ProvisionedObserver(Handler handler) {
- super(handler);
- }
-
- public void onChange(boolean selfChange) {
- final boolean wasProvisioned = mProvisioned;
- final boolean isProvisioned = deviceIsProvisioned();
- // latch: never unprovision
- mProvisioned = wasProvisioned || isProvisioned;
- if (MORE_DEBUG) {
- Slog.d(TAG, "Provisioning change: was=" + wasProvisioned
- + " is=" + isProvisioned + " now=" + mProvisioned);
- }
-
- synchronized (mQueueLock) {
- if (mProvisioned && !wasProvisioned && mEnabled) {
- // we're now good to go, so start the backup alarms
- if (MORE_DEBUG) Slog.d(TAG, "Now provisioned, so starting backups");
- KeyValueBackupJob.schedule(mContext, mConstants);
- scheduleNextFullBackupJob(0);
- }
- }
- }
- }
-
- class RestoreGetSetsParams {
- public IBackupTransport transport;
- public ActiveRestoreSession session;
- public IRestoreObserver observer;
- public IBackupManagerMonitor monitor;
-
- RestoreGetSetsParams(IBackupTransport _transport, ActiveRestoreSession _session,
- IRestoreObserver _observer, IBackupManagerMonitor _monitor) {
- transport = _transport;
- session = _session;
- observer = _observer;
- monitor = _monitor;
- }
- }
-
- class RestoreParams {
- public IBackupTransport transport;
- public String dirName;
- public IRestoreObserver observer;
- public IBackupManagerMonitor monitor;
- public long token;
- public PackageInfo pkgInfo;
- public int pmToken; // in post-install restore, the PM's token for this transaction
- public boolean isSystemRestore;
- public String[] filterSet;
-
- /**
- * Restore a single package; no kill after restore
- */
- RestoreParams(IBackupTransport _transport, String _dirName, IRestoreObserver _obs,
- IBackupManagerMonitor _monitor, long _token, PackageInfo _pkg) {
- transport = _transport;
- dirName = _dirName;
- observer = _obs;
- monitor = _monitor;
- token = _token;
- pkgInfo = _pkg;
- pmToken = 0;
- isSystemRestore = false;
- filterSet = null;
- }
-
- /**
- * Restore at install: PM token needed, kill after restore
- */
- RestoreParams(IBackupTransport _transport, String _dirName, IRestoreObserver _obs,
- IBackupManagerMonitor _monitor, long _token, String _pkgName, int _pmToken) {
- transport = _transport;
- dirName = _dirName;
- observer = _obs;
- monitor = _monitor;
- token = _token;
- pkgInfo = null;
- pmToken = _pmToken;
- isSystemRestore = false;
- filterSet = new String[] { _pkgName };
- }
-
- /**
- * Restore everything possible. This is the form that Setup Wizard or similar
- * restore UXes use.
- */
- RestoreParams(IBackupTransport _transport, String _dirName, IRestoreObserver _obs,
- IBackupManagerMonitor _monitor, long _token) {
- transport = _transport;
- dirName = _dirName;
- observer = _obs;
- monitor = _monitor;
- token = _token;
- pkgInfo = null;
- pmToken = 0;
- isSystemRestore = true;
- filterSet = null;
- }
-
- /**
- * Restore some set of packages. Leave this one up to the caller to specify
- * whether it's to be considered a system-level restore.
- */
- RestoreParams(IBackupTransport _transport, String _dirName, IRestoreObserver _obs,
- IBackupManagerMonitor _monitor, long _token,
- String[] _filterSet, boolean _isSystemRestore) {
- transport = _transport;
- dirName = _dirName;
- observer = _obs;
- monitor = _monitor;
- token = _token;
- pkgInfo = null;
- pmToken = 0;
- isSystemRestore = _isSystemRestore;
- filterSet = _filterSet;
- }
- }
-
- class ClearParams {
- public IBackupTransport transport;
- public PackageInfo packageInfo;
-
- ClearParams(IBackupTransport _transport, PackageInfo _info) {
- transport = _transport;
- packageInfo = _info;
- }
- }
-
- class ClearRetryParams {
- public String transportName;
- public String packageName;
-
- ClearRetryParams(String transport, String pkg) {
- transportName = transport;
- packageName = pkg;
- }
- }
-
- // Parameters used by adbBackup() and adbRestore()
- class AdbParams {
- public ParcelFileDescriptor fd;
- public final AtomicBoolean latch;
- public IFullBackupRestoreObserver observer;
- public String curPassword; // filled in by the confirmation step
- public String encryptPassword;
-
- AdbParams() {
- latch = new AtomicBoolean(false);
- }
- }
-
- class AdbBackupParams extends AdbParams {
- public boolean includeApks;
- public boolean includeObbs;
- public boolean includeShared;
- public boolean doWidgets;
- public boolean allApps;
- public boolean includeSystem;
- public boolean doCompress;
- public boolean includeKeyValue;
- public String[] packages;
-
- AdbBackupParams(ParcelFileDescriptor output, boolean saveApks, boolean saveObbs,
- boolean saveShared, boolean alsoWidgets, boolean doAllApps, boolean doSystem,
- boolean compress, boolean doKeyValue, String[] pkgList) {
- fd = output;
- includeApks = saveApks;
- includeObbs = saveObbs;
- includeShared = saveShared;
- doWidgets = alsoWidgets;
- allApps = doAllApps;
- includeSystem = doSystem;
- doCompress = compress;
- includeKeyValue = doKeyValue;
- packages = pkgList;
- }
- }
-
- class AdbRestoreParams extends AdbParams {
- AdbRestoreParams(ParcelFileDescriptor input) {
- fd = input;
- }
- }
-
- class BackupParams {
- public IBackupTransport transport;
- public String dirName;
- public ArrayList<String> kvPackages;
- public ArrayList<String> fullPackages;
- public IBackupObserver observer;
- public IBackupManagerMonitor monitor;
- public boolean userInitiated;
- public boolean nonIncrementalBackup;
-
- BackupParams(IBackupTransport transport, String dirName, ArrayList<String> kvPackages,
- ArrayList<String> fullPackages, IBackupObserver observer,
- IBackupManagerMonitor monitor,boolean userInitiated, boolean nonIncrementalBackup) {
- this.transport = transport;
- this.dirName = dirName;
- this.kvPackages = kvPackages;
- this.fullPackages = fullPackages;
- this.observer = observer;
- this.monitor = monitor;
- this.userInitiated = userInitiated;
- this.nonIncrementalBackup = nonIncrementalBackup;
- }
- }
-
- // Bookkeeping of in-flight operations for timeout etc. purposes. The operation
- // token is the index of the entry in the pending-operations list.
- static final int OP_PENDING = 0;
- static final int OP_ACKNOWLEDGED = 1;
- static final int OP_TIMEOUT = -1;
-
- // Waiting for backup agent to respond during backup operation.
- static final int OP_TYPE_BACKUP_WAIT = 0;
-
- // Waiting for backup agent to respond during restore operation.
- static final int OP_TYPE_RESTORE_WAIT = 1;
-
- // An entire backup operation spanning multiple packages.
- private static final int OP_TYPE_BACKUP = 2;
-
- class Operation {
- int state;
- final BackupRestoreTask callback;
- final int type;
-
- Operation(int initialState, BackupRestoreTask callbackObj, int type) {
- state = initialState;
- callback = callbackObj;
- this.type = type;
- }
- }
-
- /**
- * mCurrentOperations contains the list of currently active operations.
- *
- * If type of operation is OP_TYPE_WAIT, it are waiting for an ack or timeout.
- * An operation wraps a BackupRestoreTask within it.
- * It's the responsibility of this task to remove the operation from this array.
- *
- * A BackupRestore task gets notified of ack/timeout for the operation via
- * BackupRestoreTask#handleCancel, BackupRestoreTask#operationComplete and notifyAll called
- * on the mCurrentOpLock. {@link BackupManagerService#waitUntilOperationComplete(int)} is
- * used in various places to 'wait' for notifyAll and detect change of pending state of an
- * operation. So typically, an operation will be removed from this array by:
- * - BackupRestoreTask#handleCancel and
- * - BackupRestoreTask#operationComplete OR waitUntilOperationComplete. Do not remove at both
- * these places because waitUntilOperationComplete relies on the operation being present to
- * determine its completion status.
- *
- * If type of operation is OP_BACKUP, it is a task running backups. It provides a handle to
- * cancel backup tasks.
- */
- @GuardedBy("mCurrentOpLock")
- final SparseArray<Operation> mCurrentOperations = new SparseArray<Operation>();
- final Object mCurrentOpLock = new Object();
- final Random mTokenGenerator = new Random();
- final AtomicInteger mNextToken = new AtomicInteger();
-
- final SparseArray<AdbParams> mAdbBackupRestoreConfirmations = new SparseArray<AdbParams>();
-
- // Where we keep our journal files and other bookkeeping
- File mBaseStateDir;
- File mDataDir;
- File mJournalDir;
- File mJournal;
-
- // Backup password, if any, and the file where it's saved. What is stored is not the
- // password text itself; it's the result of a PBKDF2 hash with a randomly chosen (but
- // persisted) salt. Validation is performed by running the challenge text through the
- // same PBKDF2 cycle with the persisted salt; if the resulting derived key string matches
- // the saved hash string, then the challenge text matches the originally supplied
- // password text.
- private final SecureRandom mRng = new SecureRandom();
- private String mPasswordHash;
- private File mPasswordHashFile;
- private int mPasswordVersion;
- private File mPasswordVersionFile;
- private byte[] mPasswordSalt;
-
- // Configuration of PBKDF2 that we use for generating pw hashes and intermediate keys
- static final int PBKDF2_HASH_ROUNDS = 10000;
- static final int PBKDF2_KEY_SIZE = 256; // bits
- static final int PBKDF2_SALT_SIZE = 512; // bits
- static final String ENCRYPTION_ALGORITHM_NAME = "AES-256";
-
- // Keep a log of all the apps we've ever backed up, and what the
- // dataset tokens are for both the current backup dataset and
- // the ancestral dataset.
- private File mEverStored;
- HashSet<String> mEverStoredApps = new HashSet<String>();
-
- static final int CURRENT_ANCESTRAL_RECORD_VERSION = 1; // increment when the schema changes
- File mTokenFile;
- Set<String> mAncestralPackages = null;
- long mAncestralToken = 0;
- long mCurrentToken = 0;
-
- // Persistently track the need to do a full init
- static final String INIT_SENTINEL_FILE_NAME = "_need_init_";
- ArraySet<String> mPendingInits = new ArraySet<String>(); // transport names
-
- // Round-robin queue for scheduling full backup passes
- static final int SCHEDULE_FILE_VERSION = 1; // current version of the schedule file
- class FullBackupEntry implements Comparable<FullBackupEntry> {
- String packageName;
- long lastBackup;
-
- FullBackupEntry(String pkg, long when) {
- packageName = pkg;
- lastBackup = when;
- }
-
- @Override
- public int compareTo(FullBackupEntry other) {
- if (lastBackup < other.lastBackup) return -1;
- else if (lastBackup > other.lastBackup) return 1;
- else return 0;
- }
- }
-
- File mFullBackupScheduleFile;
- // If we're running a schedule-driven full backup, this is the task instance doing it
-
- @GuardedBy("mQueueLock")
- PerformFullTransportBackupTask mRunningFullBackupTask;
-
- @GuardedBy("mQueueLock")
- ArrayList<FullBackupEntry> mFullBackupQueue;
-
- // Utility: build a new random integer token. The low bits are the ordinal of the
- // operation for near-time uniqueness, and the upper bits are random for app-
- // side unpredictability.
- @Override
- public int generateRandomIntegerToken() {
- int token = mTokenGenerator.nextInt();
- if (token < 0) token = -token;
- token &= ~0xFF;
- token |= (mNextToken.incrementAndGet() & 0xFF);
- return token;
- }
-
- // High level policy: apps are generally ineligible for backup if certain conditions apply
- public static boolean appIsEligibleForBackup(ApplicationInfo app, PackageManager pm) {
- // 1. their manifest states android:allowBackup="false"
- if ((app.flags&ApplicationInfo.FLAG_ALLOW_BACKUP) == 0) {
- return false;
- }
-
- // 2. they run as a system-level uid but do not supply their own backup agent
- if ((app.uid < Process.FIRST_APPLICATION_UID) && (app.backupAgentName == null)) {
- return false;
- }
-
- // 3. it is the special shared-storage backup package used for 'adb backup'
- if (app.packageName.equals(BackupManagerService.SHARED_BACKUP_AGENT_PACKAGE)) {
- return false;
- }
-
- // 4. it is an "instant" app
- if (app.isInstantApp()) {
- return false;
- }
-
- // Everything else checks out; the only remaining roadblock would be if the
- // package were disabled
- return !appIsDisabled(app, pm);
- }
-
- // Checks if the app is in a stopped state. This is not part of the general "eligible for
- // backup?" check because we *do* still need to restore data to apps in this state (e.g.
- // newly-installing ones)
- private static boolean appIsStopped(ApplicationInfo app) {
- return ((app.flags & ApplicationInfo.FLAG_STOPPED) != 0);
- }
-
- private static boolean appIsDisabled(ApplicationInfo app, PackageManager pm) {
- switch (pm.getApplicationEnabledSetting(app.packageName)) {
- case PackageManager.COMPONENT_ENABLED_STATE_DISABLED:
- case PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER:
- case PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED:
- return true;
-
- default:
- return false;
- }
- }
-
- /* does *not* check overall backup eligibility policy! */
- private static boolean appGetsFullBackup(PackageInfo pkg) {
- if (pkg.applicationInfo.backupAgentName != null) {
- // If it has an agent, it gets full backups only if it says so
- return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_FULL_BACKUP_ONLY) != 0;
- }
-
- // No agent or fullBackupOnly="true" means we do indeed perform full-data backups for it
- return true;
- }
-
- /* adb backup: is this app only capable of doing key/value? We say otherwise if
- * the app has a backup agent and does not say fullBackupOnly,
- */
- private static boolean appIsKeyValueOnly(PackageInfo pkg) {
- return !appGetsFullBackup(pkg);
- }
-
- /*
- * Construct a backup agent instance for the metadata pseudopackage. This is a
- * process-local non-lifecycle agent instance, so we manually set up the context
- * topology for it.
- */
- PackageManagerBackupAgent makeMetadataAgent() {
- PackageManagerBackupAgent pmAgent = new PackageManagerBackupAgent(mPackageManager);
- pmAgent.attach(mContext);
- pmAgent.onCreate();
- return pmAgent;
- }
-
- /*
- * Same as above but with the explicit package-set configuration.
- */
- PackageManagerBackupAgent makeMetadataAgent(List<PackageInfo> packages) {
- PackageManagerBackupAgent pmAgent =
- new PackageManagerBackupAgent(mPackageManager, packages);
- pmAgent.attach(mContext);
- pmAgent.onCreate();
- return pmAgent;
- }
-
- // ----- Asynchronous backup/restore handler thread -----
-
- private class BackupHandler extends Handler {
- public BackupHandler(Looper looper) {
- super(looper);
- }
-
- public void handleMessage(Message msg) {
-
- switch (msg.what) {
- case MSG_RUN_BACKUP:
- {
- mLastBackupPass = System.currentTimeMillis();
-
- IBackupTransport transport = mTransportManager.getCurrentTransportBinder();
- if (transport == null) {
- Slog.v(TAG, "Backup requested but no transport available");
- synchronized (mQueueLock) {
- mBackupRunning = false;
- }
- mWakelock.release();
- break;
- }
-
- // snapshot the pending-backup set and work on that
- ArrayList<BackupRequest> queue = new ArrayList<BackupRequest>();
- File oldJournal = mJournal;
- synchronized (mQueueLock) {
- // Do we have any work to do? Construct the work queue
- // then release the synchronization lock to actually run
- // the backup.
- if (mPendingBackups.size() > 0) {
- for (BackupRequest b: mPendingBackups.values()) {
- queue.add(b);
- }
- if (DEBUG) Slog.v(TAG, "clearing pending backups");
- mPendingBackups.clear();
-
- // Start a new backup-queue journal file too
- mJournal = null;
-
- }
- }
-
- // At this point, we have started a new journal file, and the old
- // file identity is being passed to the backup processing task.
- // When it completes successfully, that old journal file will be
- // deleted. If we crash prior to that, the old journal is parsed
- // at next boot and the journaled requests fulfilled.
- boolean staged = true;
- if (queue.size() > 0) {
- // Spin up a backup state sequence and set it running
- try {
- String dirName = transport.transportDirName();
- PerformBackupTask pbt = new PerformBackupTask(transport, dirName, queue,
- oldJournal, null, null, Collections.<String>emptyList(), false,
- false /* nonIncremental */);
- Message pbtMessage = obtainMessage(MSG_BACKUP_RESTORE_STEP, pbt);
- sendMessage(pbtMessage);
- } catch (Exception e) {
- // unable to ask the transport its dir name -- transient failure, since
- // the above check succeeded. Try again next time.
- Slog.e(TAG, "Transport became unavailable attempting backup"
- + " or error initializing backup task", e);
- staged = false;
- }
- } else {
- Slog.v(TAG, "Backup requested but nothing pending");
- staged = false;
- }
-
- if (!staged) {
- // if we didn't actually hand off the wakelock, rewind until next time
- synchronized (mQueueLock) {
- mBackupRunning = false;
- }
- mWakelock.release();
- }
- break;
- }
-
- case MSG_BACKUP_RESTORE_STEP:
- {
- try {
- BackupRestoreTask task = (BackupRestoreTask) msg.obj;
- if (MORE_DEBUG) Slog.v(TAG, "Got next step for " + task + ", executing");
- task.execute();
- } catch (ClassCastException e) {
- Slog.e(TAG, "Invalid backup task in flight, obj=" + msg.obj);
- }
- break;
- }
-
- case MSG_OP_COMPLETE:
- {
- try {
- Pair<BackupRestoreTask, Long> taskWithResult =
- (Pair<BackupRestoreTask, Long>) msg.obj;
- taskWithResult.first.operationComplete(taskWithResult.second);
- } catch (ClassCastException e) {
- Slog.e(TAG, "Invalid completion in flight, obj=" + msg.obj);
- }
- break;
- }
-
- case MSG_RUN_ADB_BACKUP:
- {
- // TODO: refactor full backup to be a looper-based state machine
- // similar to normal backup/restore.
- AdbBackupParams params = (AdbBackupParams)msg.obj;
- PerformAdbBackupTask task = new PerformAdbBackupTask(params.fd,
- params.observer, params.includeApks, params.includeObbs,
- params.includeShared, params.doWidgets, params.curPassword,
- params.encryptPassword, params.allApps, params.includeSystem,
- params.doCompress, params.includeKeyValue, params.packages, params.latch);
- (new Thread(task, "adb-backup")).start();
- break;
- }
-
- case MSG_RUN_FULL_TRANSPORT_BACKUP:
- {
- PerformFullTransportBackupTask task = (PerformFullTransportBackupTask) msg.obj;
- (new Thread(task, "transport-backup")).start();
- break;
- }
-
- case MSG_RUN_RESTORE:
- {
- RestoreParams params = (RestoreParams)msg.obj;
- Slog.d(TAG, "MSG_RUN_RESTORE observer=" + params.observer);
-
- PerformUnifiedRestoreTask task = new PerformUnifiedRestoreTask(params.transport,
- params.observer, params.monitor, params.token, params.pkgInfo,
- params.pmToken, params.isSystemRestore, params.filterSet);
-
- synchronized (mPendingRestores) {
- if (mIsRestoreInProgress) {
- if (DEBUG) {
- Slog.d(TAG, "Restore in progress, queueing.");
- }
- mPendingRestores.add(task);
- // This task will be picked up and executed when the the currently running
- // restore task finishes.
- } else {
- if (DEBUG) {
- Slog.d(TAG, "Starting restore.");
- }
- mIsRestoreInProgress = true;
- Message restoreMsg = obtainMessage(MSG_BACKUP_RESTORE_STEP, task);
- sendMessage(restoreMsg);
- }
- }
- break;
- }
-
- case MSG_RUN_ADB_RESTORE:
- {
- // TODO: refactor full restore to be a looper-based state machine
- // similar to normal backup/restore.
- AdbRestoreParams params = (AdbRestoreParams)msg.obj;
- PerformAdbRestoreTask task = new PerformAdbRestoreTask(params.fd,
- params.curPassword, params.encryptPassword,
- params.observer, params.latch);
- (new Thread(task, "adb-restore")).start();
- break;
- }
-
- case MSG_RUN_CLEAR:
- {
- ClearParams params = (ClearParams)msg.obj;
- (new PerformClearTask(params.transport, params.packageInfo)).run();
- break;
- }
-
- case MSG_RETRY_CLEAR:
- {
- // reenqueues if the transport remains unavailable
- ClearRetryParams params = (ClearRetryParams)msg.obj;
- clearBackupData(params.transportName, params.packageName);
- break;
- }
-
- case MSG_RETRY_INIT:
- {
- synchronized (mQueueLock) {
- recordInitPendingLocked(msg.arg1 != 0, (String)msg.obj);
- mAlarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(),
- mRunInitIntent);
- }
- break;
- }
-
- case MSG_RUN_GET_RESTORE_SETS:
- {
- // Like other async operations, this is entered with the wakelock held
- RestoreSet[] sets = null;
- RestoreGetSetsParams params = (RestoreGetSetsParams)msg.obj;
- try {
- sets = params.transport.getAvailableRestoreSets();
- // cache the result in the active session
- synchronized (params.session) {
- params.session.mRestoreSets = sets;
- }
- if (sets == null) EventLog.writeEvent(EventLogTags.RESTORE_TRANSPORT_FAILURE);
- } catch (Exception e) {
- Slog.e(TAG, "Error from transport getting set list: " + e.getMessage());
- } finally {
- if (params.observer != null) {
- try {
- params.observer.restoreSetsAvailable(sets);
- } catch (RemoteException re) {
- Slog.e(TAG, "Unable to report listing to observer");
- } catch (Exception e) {
- Slog.e(TAG, "Restore observer threw: " + e.getMessage());
- }
- }
-
- // Done: reset the session timeout clock
- removeMessages(MSG_RESTORE_SESSION_TIMEOUT);
- sendEmptyMessageDelayed(MSG_RESTORE_SESSION_TIMEOUT, TIMEOUT_RESTORE_INTERVAL);
-
- mWakelock.release();
- }
- break;
- }
-
- case MSG_BACKUP_OPERATION_TIMEOUT:
- case MSG_RESTORE_OPERATION_TIMEOUT:
- {
- Slog.d(TAG, "Timeout message received for token=" + Integer.toHexString(msg.arg1));
- handleCancel(msg.arg1, false);
- break;
- }
-
- case MSG_RESTORE_SESSION_TIMEOUT:
- {
- synchronized (BackupManagerService.this) {
- if (mActiveRestoreSession != null) {
- // Client app left the restore session dangling. We know that it
- // can't be in the middle of an actual restore operation because
- // the timeout is suspended while a restore is in progress. Clean
- // up now.
- Slog.w(TAG, "Restore session timed out; aborting");
- mActiveRestoreSession.markTimedOut();
- post(mActiveRestoreSession.new EndRestoreRunnable(
- BackupManagerService.this, mActiveRestoreSession));
- }
- }
- break;
- }
-
- case MSG_FULL_CONFIRMATION_TIMEOUT:
- {
- synchronized (mAdbBackupRestoreConfirmations) {
- AdbParams params = mAdbBackupRestoreConfirmations.get(msg.arg1);
- if (params != null) {
- Slog.i(TAG, "Full backup/restore timed out waiting for user confirmation");
-
- // Release the waiter; timeout == completion
- signalAdbBackupRestoreCompletion(params);
-
- // Remove the token from the set
- mAdbBackupRestoreConfirmations.delete(msg.arg1);
-
- // Report a timeout to the observer, if any
- if (params.observer != null) {
- try {
- params.observer.onTimeout();
- } catch (RemoteException e) {
- /* don't care if the app has gone away */
- }
- }
- } else {
- Slog.d(TAG, "couldn't find params for token " + msg.arg1);
- }
- }
- break;
- }
-
- case MSG_WIDGET_BROADCAST:
- {
- final Intent intent = (Intent) msg.obj;
- mContext.sendBroadcastAsUser(intent, UserHandle.SYSTEM);
- break;
- }
-
- case MSG_REQUEST_BACKUP:
- {
- BackupParams params = (BackupParams)msg.obj;
- if (MORE_DEBUG) {
- Slog.d(TAG, "MSG_REQUEST_BACKUP observer=" + params.observer);
- }
- ArrayList<BackupRequest> kvQueue = new ArrayList<>();
- for (String packageName : params.kvPackages) {
- kvQueue.add(new BackupRequest(packageName));
- }
- mBackupRunning = true;
- mWakelock.acquire();
-
- PerformBackupTask pbt = new PerformBackupTask(params.transport, params.dirName,
- kvQueue, null, params.observer, params.monitor, params.fullPackages, true,
- params.nonIncrementalBackup);
- Message pbtMessage = obtainMessage(MSG_BACKUP_RESTORE_STEP, pbt);
- sendMessage(pbtMessage);
- break;
- }
-
- case MSG_SCHEDULE_BACKUP_PACKAGE:
- {
- String pkgName = (String)msg.obj;
- if (MORE_DEBUG) {
- Slog.d(TAG, "MSG_SCHEDULE_BACKUP_PACKAGE " + pkgName);
- }
- dataChangedImpl(pkgName);
- break;
- }
- }
- }
- }
-
- // ----- Debug-only backup operation trace -----
- void addBackupTrace(String s) {
- if (DEBUG_BACKUP_TRACE) {
- synchronized (mBackupTrace) {
- mBackupTrace.add(s);
- }
- }
- }
-
- void clearBackupTrace() {
- if (DEBUG_BACKUP_TRACE) {
- synchronized (mBackupTrace) {
- mBackupTrace.clear();
- }
- }
- }
-
- // ----- Main service implementation -----
-
- public BackupManagerService(Context context, Trampoline parent, HandlerThread backupThread) {
- mContext = context;
- mPackageManager = context.getPackageManager();
- mPackageManagerBinder = AppGlobals.getPackageManager();
- mActivityManager = ActivityManager.getService();
-
- mAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
- mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
- mStorageManager = IStorageManager.Stub.asInterface(ServiceManager.getService("mount"));
-
- mBackupManagerBinder = Trampoline.asInterface(parent.asBinder());
-
- // spin up the backup/restore handler thread
- mBackupHandler = new BackupHandler(backupThread.getLooper());
-
- // Set up our bookkeeping
- final ContentResolver resolver = context.getContentResolver();
- mProvisioned = Settings.Global.getInt(resolver,
- Settings.Global.DEVICE_PROVISIONED, 0) != 0;
- mAutoRestore = Settings.Secure.getInt(resolver,
- Settings.Secure.BACKUP_AUTO_RESTORE, 1) != 0;
-
- mProvisionedObserver = new ProvisionedObserver(mBackupHandler);
- resolver.registerContentObserver(
- Settings.Global.getUriFor(Settings.Global.DEVICE_PROVISIONED),
- false, mProvisionedObserver);
-
- // If Encrypted file systems is enabled or disabled, this call will return the
- // correct directory.
- mBaseStateDir = new File(Environment.getDataDirectory(), "backup");
- mBaseStateDir.mkdirs();
- if (!SELinux.restorecon(mBaseStateDir)) {
- Slog.e(TAG, "SELinux restorecon failed on " + mBaseStateDir);
- }
-
- // This dir on /cache is managed directly in init.rc
- mDataDir = new File(Environment.getDownloadCacheDirectory(), "backup_stage");
-
- mPasswordVersion = 1; // unless we hear otherwise
- mPasswordVersionFile = new File(mBaseStateDir, "pwversion");
- if (mPasswordVersionFile.exists()) {
- FileInputStream fin = null;
- DataInputStream in = null;
- try {
- fin = new FileInputStream(mPasswordVersionFile);
- in = new DataInputStream(fin);
- mPasswordVersion = in.readInt();
- } catch (IOException e) {
- Slog.e(TAG, "Unable to read backup pw version");
- } finally {
- try {
- if (in != null) in.close();
- if (fin != null) fin.close();
- } catch (IOException e) {
- Slog.w(TAG, "Error closing pw version files");
- }
- }
- }
-
- mPasswordHashFile = new File(mBaseStateDir, "pwhash");
- if (mPasswordHashFile.exists()) {
- FileInputStream fin = null;
- DataInputStream in = null;
- try {
- fin = new FileInputStream(mPasswordHashFile);
- in = new DataInputStream(new BufferedInputStream(fin));
- // integer length of the salt array, followed by the salt,
- // then the hex pw hash string
- int saltLen = in.readInt();
- byte[] salt = new byte[saltLen];
- in.readFully(salt);
- mPasswordHash = in.readUTF();
- mPasswordSalt = salt;
- } catch (IOException e) {
- Slog.e(TAG, "Unable to read saved backup pw hash");
- } finally {
- try {
- if (in != null) in.close();
- if (fin != null) fin.close();
- } catch (IOException e) {
- Slog.w(TAG, "Unable to close streams");
- }
- }
- }
-
- // Alarm receivers for scheduled backups & initialization operations
- mRunBackupReceiver = new RunBackupReceiver();
- IntentFilter filter = new IntentFilter();
- filter.addAction(RUN_BACKUP_ACTION);
- context.registerReceiver(mRunBackupReceiver, filter,
- android.Manifest.permission.BACKUP, null);
-
- mRunInitReceiver = new RunInitializeReceiver();
- filter = new IntentFilter();
- filter.addAction(RUN_INITIALIZE_ACTION);
- context.registerReceiver(mRunInitReceiver, filter,
- android.Manifest.permission.BACKUP, null);
-
- Intent backupIntent = new Intent(RUN_BACKUP_ACTION);
- backupIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
- mRunBackupIntent = PendingIntent.getBroadcast(context, MSG_RUN_BACKUP, backupIntent, 0);
-
- Intent initIntent = new Intent(RUN_INITIALIZE_ACTION);
- initIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
- mRunInitIntent = PendingIntent.getBroadcast(context, 0, initIntent, 0);
-
- // Set up the backup-request journaling
- mJournalDir = new File(mBaseStateDir, "pending");
- mJournalDir.mkdirs(); // creates mBaseStateDir along the way
- mJournal = null; // will be created on first use
-
- mConstants = new BackupManagerConstants(mBackupHandler, mContext.getContentResolver());
-
- // Set up the various sorts of package tracking we do
- mFullBackupScheduleFile = new File(mBaseStateDir, "fb-schedule");
- initPackageTracking();
-
- // Build our mapping of uid to backup client services. This implicitly
- // schedules a backup pass on the Package Manager metadata the first
- // time anything needs to be backed up.
- synchronized (mBackupParticipants) {
- addPackageParticipantsLocked(null);
- }
-
- // Set up our transport options and initialize the default transport
- // TODO: Don't create transports that we don't need to?
- SystemConfig systemConfig = SystemConfig.getInstance();
- Set<ComponentName> transportWhitelist = systemConfig.getBackupTransportWhitelist();
-
- String transport = Settings.Secure.getString(context.getContentResolver(),
- Settings.Secure.BACKUP_TRANSPORT);
- if (TextUtils.isEmpty(transport)) {
- transport = null;
- }
- String currentTransport = transport;
- if (DEBUG) Slog.v(TAG, "Starting with transport " + currentTransport);
-
- mTransportManager = new TransportManager(context, transportWhitelist, currentTransport,
- mTransportBoundListener, backupThread.getLooper());
- mTransportManager.registerAllTransports();
-
- // Now that we know about valid backup participants, parse any
- // leftover journal files into the pending backup set
- mBackupHandler.post(() -> parseLeftoverJournals());
-
- // Power management
- mWakelock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*backup*");
- }
-
- private class RunBackupReceiver extends BroadcastReceiver {
- public void onReceive(Context context, Intent intent) {
- if (RUN_BACKUP_ACTION.equals(intent.getAction())) {
- synchronized (mQueueLock) {
- if (mPendingInits.size() > 0) {
- // If there are pending init operations, we process those
- // and then settle into the usual periodic backup schedule.
- if (MORE_DEBUG) Slog.v(TAG, "Init pending at scheduled backup");
- try {
- mAlarmManager.cancel(mRunInitIntent);
- mRunInitIntent.send();
- } catch (PendingIntent.CanceledException ce) {
- Slog.e(TAG, "Run init intent cancelled");
- // can't really do more than bail here
- }
- } else {
- // Don't run backups now if we're disabled or not yet
- // fully set up.
- if (mEnabled && mProvisioned) {
- if (!mBackupRunning) {
- if (DEBUG) Slog.v(TAG, "Running a backup pass");
-
- // Acquire the wakelock and pass it to the backup thread. it will
- // be released once backup concludes.
- mBackupRunning = true;
- mWakelock.acquire();
-
- Message msg = mBackupHandler.obtainMessage(MSG_RUN_BACKUP);
- mBackupHandler.sendMessage(msg);
- } else {
- Slog.i(TAG, "Backup time but one already running");
- }
- } else {
- Slog.w(TAG, "Backup pass but e=" + mEnabled + " p=" + mProvisioned);
- }
- }
- }
- }
- }
- }
-
- private class RunInitializeReceiver extends BroadcastReceiver {
- public void onReceive(Context context, Intent intent) {
- if (RUN_INITIALIZE_ACTION.equals(intent.getAction())) {
- // Snapshot the pending-init queue and work on that
- synchronized (mQueueLock) {
- String[] queue = mPendingInits.toArray(new String[mPendingInits.size()]);
- mPendingInits.clear();
-
- // Acquire the wakelock and pass it to the init thread. it will
- // be released once init concludes.
- mWakelock.acquire();
- mBackupHandler.post(new PerformInitializeTask(queue, null));
- }
- }
- }
- }
-
- private void initPackageTracking() {
- if (MORE_DEBUG) Slog.v(TAG, "` tracking");
-
- // Remember our ancestral dataset
- mTokenFile = new File(mBaseStateDir, "ancestral");
- try (DataInputStream tokenStream = new DataInputStream(new BufferedInputStream(
- new FileInputStream(mTokenFile)))) {
- int version = tokenStream.readInt();
- if (version == CURRENT_ANCESTRAL_RECORD_VERSION) {
- mAncestralToken = tokenStream.readLong();
- mCurrentToken = tokenStream.readLong();
-
- int numPackages = tokenStream.readInt();
- if (numPackages >= 0) {
- mAncestralPackages = new HashSet<>();
- for (int i = 0; i < numPackages; i++) {
- String pkgName = tokenStream.readUTF();
- mAncestralPackages.add(pkgName);
- }
- }
- }
- } catch (FileNotFoundException fnf) {
- // Probably innocuous
- Slog.v(TAG, "No ancestral data");
- } catch (IOException e) {
- Slog.w(TAG, "Unable to read token file", e);
- }
-
- // Keep a log of what apps we've ever backed up. Because we might have
- // rebooted in the middle of an operation that was removing something from
- // this log, we sanity-check its contents here and reconstruct it.
- mEverStored = new File(mBaseStateDir, "processed");
-
- // If there are previous contents, parse them out then start a new
- // file to continue the recordkeeping.
- if (mEverStored.exists()) {
- try (DataInputStream in = new DataInputStream(
- new BufferedInputStream(new FileInputStream(mEverStored)))) {
-
- // Loop until we hit EOF
- while (true) {
- String pkg = in.readUTF();
- mEverStoredApps.add(pkg);
- if (MORE_DEBUG) Slog.v(TAG, " + " + pkg);
- }
- } catch (EOFException e) {
- // Done
- } catch (IOException e) {
- Slog.e(TAG, "Error in processed file", e);
- }
- }
-
- synchronized (mQueueLock) {
- // Resume the full-data backup queue
- mFullBackupQueue = readFullBackupSchedule();
- }
-
- // Register for broadcasts about package install, etc., so we can
- // update the provider list.
- IntentFilter filter = new IntentFilter();
- filter.addAction(Intent.ACTION_PACKAGE_ADDED);
- filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
- filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
- filter.addDataScheme("package");
- mContext.registerReceiver(mBroadcastReceiver, filter);
- // Register for events related to sdcard installation.
- IntentFilter sdFilter = new IntentFilter();
- sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);
- sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
- mContext.registerReceiver(mBroadcastReceiver, sdFilter);
- }
-
- private ArrayList<FullBackupEntry> readFullBackupSchedule() {
- boolean changed = false;
- ArrayList<FullBackupEntry> schedule = null;
- List<PackageInfo> apps =
- PackageManagerBackupAgent.getStorableApplications(mPackageManager);
-
- if (mFullBackupScheduleFile.exists()) {
- FileInputStream fstream = null;
- BufferedInputStream bufStream = null;
- DataInputStream in = null;
- try {
- fstream = new FileInputStream(mFullBackupScheduleFile);
- bufStream = new BufferedInputStream(fstream);
- in = new DataInputStream(bufStream);
-
- int version = in.readInt();
- if (version != SCHEDULE_FILE_VERSION) {
- Slog.e(TAG, "Unknown backup schedule version " + version);
- return null;
- }
-
- final int N = in.readInt();
- schedule = new ArrayList<FullBackupEntry>(N);
-
- // HashSet instead of ArraySet specifically because we want the eventual
- // lookups against O(hundreds) of entries to be as fast as possible, and
- // we discard the set immediately after the scan so the extra memory
- // overhead is transient.
- HashSet<String> foundApps = new HashSet<String>(N);
-
- for (int i = 0; i < N; i++) {
- String pkgName = in.readUTF();
- long lastBackup = in.readLong();
- foundApps.add(pkgName); // all apps that we've addressed already
- try {
- PackageInfo pkg = mPackageManager.getPackageInfo(pkgName, 0);
- if (appGetsFullBackup(pkg)
- && appIsEligibleForBackup(pkg.applicationInfo, mPackageManager)) {
- schedule.add(new FullBackupEntry(pkgName, lastBackup));
- } else {
- if (DEBUG) {
- Slog.i(TAG, "Package " + pkgName
- + " no longer eligible for full backup");
- }
- }
- } catch (NameNotFoundException e) {
- if (DEBUG) {
- Slog.i(TAG, "Package " + pkgName
- + " not installed; dropping from full backup");
- }
- }
- }
-
- // New apps can arrive "out of band" via OTA and similar, so we also need to
- // scan to make sure that we're tracking all full-backup candidates properly
- for (PackageInfo app : apps) {
- if (appGetsFullBackup(app)
- && appIsEligibleForBackup(app.applicationInfo, mPackageManager)) {
- if (!foundApps.contains(app.packageName)) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "New full backup app " + app.packageName + " found");
- }
- schedule.add(new FullBackupEntry(app.packageName, 0));
- changed = true;
- }
- }
- }
-
- Collections.sort(schedule);
- } catch (Exception e) {
- Slog.e(TAG, "Unable to read backup schedule", e);
- mFullBackupScheduleFile.delete();
- schedule = null;
- } finally {
- IoUtils.closeQuietly(in);
- IoUtils.closeQuietly(bufStream);
- IoUtils.closeQuietly(fstream);
- }
- }
-
- if (schedule == null) {
- // no prior queue record, or unable to read it. Set up the queue
- // from scratch.
- changed = true;
- schedule = new ArrayList<FullBackupEntry>(apps.size());
- for (PackageInfo info : apps) {
- if (appGetsFullBackup(info)
- && appIsEligibleForBackup(info.applicationInfo, mPackageManager)) {
- schedule.add(new FullBackupEntry(info.packageName, 0));
- }
- }
- }
-
- if (changed) {
- writeFullBackupScheduleAsync();
- }
- return schedule;
- }
-
- Runnable mFullBackupScheduleWriter = new Runnable() {
- @Override public void run() {
- synchronized (mQueueLock) {
- try {
- ByteArrayOutputStream bufStream = new ByteArrayOutputStream(4096);
- DataOutputStream bufOut = new DataOutputStream(bufStream);
- bufOut.writeInt(SCHEDULE_FILE_VERSION);
-
- // version 1:
- //
- // [int] # of packages in the queue = N
- // N * {
- // [utf8] package name
- // [long] last backup time for this package
- // }
- int N = mFullBackupQueue.size();
- bufOut.writeInt(N);
-
- for (int i = 0; i < N; i++) {
- FullBackupEntry entry = mFullBackupQueue.get(i);
- bufOut.writeUTF(entry.packageName);
- bufOut.writeLong(entry.lastBackup);
- }
- bufOut.flush();
-
- AtomicFile af = new AtomicFile(mFullBackupScheduleFile);
- FileOutputStream out = af.startWrite();
- out.write(bufStream.toByteArray());
- af.finishWrite(out);
- } catch (Exception e) {
- Slog.e(TAG, "Unable to write backup schedule!", e);
- }
- }
- }
- };
-
- private void writeFullBackupScheduleAsync() {
- mBackupHandler.removeCallbacks(mFullBackupScheduleWriter);
- mBackupHandler.post(mFullBackupScheduleWriter);
- }
-
- private void parseLeftoverJournals() {
- for (File f : mJournalDir.listFiles()) {
- if (mJournal == null || f.compareTo(mJournal) != 0) {
- // This isn't the current journal, so it must be a leftover. Read
- // out the package names mentioned there and schedule them for
- // backup.
- DataInputStream in = null;
- try {
- Slog.i(TAG, "Found stale backup journal, scheduling");
- // Journals will tend to be on the order of a few kilobytes(around 4k), hence,
- // setting the buffer size to 8192.
- InputStream bufferedInputStream = new BufferedInputStream(
- new FileInputStream(f), 8192);
- in = new DataInputStream(bufferedInputStream);
- while (true) {
- String packageName = in.readUTF();
- if (MORE_DEBUG) Slog.i(TAG, " " + packageName);
- dataChangedImpl(packageName);
- }
- } catch (EOFException e) {
- // no more data; we're done
- } catch (Exception e) {
- Slog.e(TAG, "Can't read " + f, e);
- } finally {
- // close/delete the file
- try { if (in != null) in.close(); } catch (IOException e) {}
- f.delete();
- }
- }
- }
- }
-
- private SecretKey buildPasswordKey(String algorithm, String pw, byte[] salt, int rounds) {
- return buildCharArrayKey(algorithm, pw.toCharArray(), salt, rounds);
- }
-
- private SecretKey buildCharArrayKey(String algorithm, char[] pwArray, byte[] salt, int rounds) {
- try {
- SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);
- KeySpec ks = new PBEKeySpec(pwArray, salt, rounds, PBKDF2_KEY_SIZE);
- return keyFactory.generateSecret(ks);
- } catch (InvalidKeySpecException e) {
- Slog.e(TAG, "Invalid key spec for PBKDF2!");
- } catch (NoSuchAlgorithmException e) {
- Slog.e(TAG, "PBKDF2 unavailable!");
- }
- return null;
- }
-
- private String buildPasswordHash(String algorithm, String pw, byte[] salt, int rounds) {
- SecretKey key = buildPasswordKey(algorithm, pw, salt, rounds);
- if (key != null) {
- return byteArrayToHex(key.getEncoded());
- }
- return null;
- }
-
- private String byteArrayToHex(byte[] data) {
- StringBuilder buf = new StringBuilder(data.length * 2);
- for (int i = 0; i < data.length; i++) {
- buf.append(Byte.toHexString(data[i], true));
- }
- return buf.toString();
- }
-
- private byte[] hexToByteArray(String digits) {
- final int bytes = digits.length() / 2;
- if (2*bytes != digits.length()) {
- throw new IllegalArgumentException("Hex string must have an even number of digits");
- }
-
- byte[] result = new byte[bytes];
- for (int i = 0; i < digits.length(); i += 2) {
- result[i/2] = (byte) Integer.parseInt(digits.substring(i, i+2), 16);
- }
- return result;
- }
-
- private byte[] makeKeyChecksum(String algorithm, byte[] pwBytes, byte[] salt, int rounds) {
- char[] mkAsChar = new char[pwBytes.length];
- for (int i = 0; i < pwBytes.length; i++) {
- mkAsChar[i] = (char) pwBytes[i];
- }
-
- Key checksum = buildCharArrayKey(algorithm, mkAsChar, salt, rounds);
- return checksum.getEncoded();
- }
-
- // Used for generating random salts or passwords
- private byte[] randomBytes(int bits) {
- byte[] array = new byte[bits / 8];
- mRng.nextBytes(array);
- return array;
- }
-
- boolean passwordMatchesSaved(String algorithm, String candidatePw, int rounds) {
- if (mPasswordHash == null) {
- // no current password case -- require that 'currentPw' be null or empty
- if (candidatePw == null || "".equals(candidatePw)) {
- return true;
- } // else the non-empty candidate does not match the empty stored pw
- } else {
- // hash the stated current pw and compare to the stored one
- if (candidatePw != null && candidatePw.length() > 0) {
- String currentPwHash = buildPasswordHash(algorithm, candidatePw, mPasswordSalt, rounds);
- if (mPasswordHash.equalsIgnoreCase(currentPwHash)) {
- // candidate hash matches the stored hash -- the password matches
- return true;
- }
- } // else the stored pw is nonempty but the candidate is empty; no match
- }
- return false;
- }
-
- @Override
- public boolean setBackupPassword(String currentPw, String newPw) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "setBackupPassword");
-
- // When processing v1 passwords we may need to try two different PBKDF2 checksum regimes
- final boolean pbkdf2Fallback = (mPasswordVersion < BACKUP_PW_FILE_VERSION);
-
- // If the supplied pw doesn't hash to the the saved one, fail. The password
- // might be caught in the legacy crypto mismatch; verify that too.
- if (!passwordMatchesSaved(PBKDF_CURRENT, currentPw, PBKDF2_HASH_ROUNDS)
- && !(pbkdf2Fallback && passwordMatchesSaved(PBKDF_FALLBACK,
- currentPw, PBKDF2_HASH_ROUNDS))) {
- return false;
- }
-
- // Snap up to current on the pw file version
- mPasswordVersion = BACKUP_PW_FILE_VERSION;
- FileOutputStream pwFout = null;
- DataOutputStream pwOut = null;
- try {
- pwFout = new FileOutputStream(mPasswordVersionFile);
- pwOut = new DataOutputStream(pwFout);
- pwOut.writeInt(mPasswordVersion);
- } catch (IOException e) {
- Slog.e(TAG, "Unable to write backup pw version; password not changed");
- return false;
- } finally {
- try {
- if (pwOut != null) pwOut.close();
- if (pwFout != null) pwFout.close();
- } catch (IOException e) {
- Slog.w(TAG, "Unable to close pw version record");
- }
- }
-
- // Clearing the password is okay
- if (newPw == null || newPw.isEmpty()) {
- if (mPasswordHashFile.exists()) {
- if (!mPasswordHashFile.delete()) {
- // Unable to delete the old pw file, so fail
- Slog.e(TAG, "Unable to clear backup password");
- return false;
- }
- }
- mPasswordHash = null;
- mPasswordSalt = null;
- return true;
- }
-
- try {
- // Okay, build the hash of the new backup password
- byte[] salt = randomBytes(PBKDF2_SALT_SIZE);
- String newPwHash = buildPasswordHash(PBKDF_CURRENT, newPw, salt, PBKDF2_HASH_ROUNDS);
-
- OutputStream pwf = null, buffer = null;
- DataOutputStream out = null;
- try {
- pwf = new FileOutputStream(mPasswordHashFile);
- buffer = new BufferedOutputStream(pwf);
- out = new DataOutputStream(buffer);
- // integer length of the salt array, followed by the salt,
- // then the hex pw hash string
- out.writeInt(salt.length);
- out.write(salt);
- out.writeUTF(newPwHash);
- out.flush();
- mPasswordHash = newPwHash;
- mPasswordSalt = salt;
- return true;
- } finally {
- if (out != null) out.close();
- if (buffer != null) buffer.close();
- if (pwf != null) pwf.close();
- }
- } catch (IOException e) {
- Slog.e(TAG, "Unable to set backup password");
- }
- return false;
- }
-
- @Override
- public boolean hasBackupPassword() {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "hasBackupPassword");
-
- return mPasswordHash != null && mPasswordHash.length() > 0;
- }
-
- private boolean backupPasswordMatches(String currentPw) {
- if (hasBackupPassword()) {
- final boolean pbkdf2Fallback = (mPasswordVersion < BACKUP_PW_FILE_VERSION);
- if (!passwordMatchesSaved(PBKDF_CURRENT, currentPw, PBKDF2_HASH_ROUNDS)
- && !(pbkdf2Fallback && passwordMatchesSaved(PBKDF_FALLBACK,
- currentPw, PBKDF2_HASH_ROUNDS))) {
- if (DEBUG) Slog.w(TAG, "Backup password mismatch; aborting");
- return false;
- }
- }
- return true;
- }
-
- // Maintain persistent state around whether need to do an initialize operation.
- // Must be called with the queue lock held.
- void recordInitPendingLocked(boolean isPending, String transportName) {
- if (MORE_DEBUG) Slog.i(TAG, "recordInitPendingLocked: " + isPending
- + " on transport " + transportName);
- mBackupHandler.removeMessages(MSG_RETRY_INIT);
-
- try {
- IBackupTransport transport = mTransportManager.getTransportBinder(transportName);
- if (transport != null) {
- String transportDirName = transport.transportDirName();
- File stateDir = new File(mBaseStateDir, transportDirName);
- File initPendingFile = new File(stateDir, INIT_SENTINEL_FILE_NAME);
-
- if (isPending) {
- // We need an init before we can proceed with sending backup data.
- // Record that with an entry in our set of pending inits, as well as
- // journaling it via creation of a sentinel file.
- mPendingInits.add(transportName);
- try {
- (new FileOutputStream(initPendingFile)).close();
- } catch (IOException ioe) {
- // Something is badly wrong with our permissions; just try to move on
- }
- } else {
- // No more initialization needed; wipe the journal and reset our state.
- initPendingFile.delete();
- mPendingInits.remove(transportName);
- }
- return; // done; don't fall through to the error case
- }
- } catch (Exception e) {
- // transport threw when asked its name; fall through to the lookup-failed case
- Slog.e(TAG, "Transport " + transportName + " failed to report name: "
- + e.getMessage());
- }
-
- // The named transport doesn't exist or threw. This operation is
- // important, so we record the need for a an init and post a message
- // to retry the init later.
- if (isPending) {
- mPendingInits.add(transportName);
- mBackupHandler.sendMessageDelayed(
- mBackupHandler.obtainMessage(MSG_RETRY_INIT,
- (isPending ? 1 : 0),
- 0,
- transportName),
- TRANSPORT_RETRY_INTERVAL);
- }
- }
-
- // Reset all of our bookkeeping, in response to having been told that
- // the backend data has been wiped [due to idle expiry, for example],
- // so we must re-upload all saved settings.
- void resetBackupState(File stateFileDir) {
- synchronized (mQueueLock) {
- // Wipe the "what we've ever backed up" tracking
- mEverStoredApps.clear();
- mEverStored.delete();
-
- mCurrentToken = 0;
- writeRestoreTokens();
-
- // Remove all the state files
- for (File sf : stateFileDir.listFiles()) {
- // ... but don't touch the needs-init sentinel
- if (!sf.getName().equals(INIT_SENTINEL_FILE_NAME)) {
- sf.delete();
- }
- }
- }
-
- // Enqueue a new backup of every participant
- synchronized (mBackupParticipants) {
- final int N = mBackupParticipants.size();
- for (int i=0; i<N; i++) {
- HashSet<String> participants = mBackupParticipants.valueAt(i);
- if (participants != null) {
- for (String packageName : participants) {
- dataChangedImpl(packageName);
- }
- }
- }
- }
- }
-
- private TransportManager.TransportBoundListener mTransportBoundListener =
- new TransportManager.TransportBoundListener() {
- @Override
- public boolean onTransportBound(IBackupTransport transport) {
- // If the init sentinel file exists, we need to be sure to perform the init
- // as soon as practical. We also create the state directory at registration
- // time to ensure it's present from the outset.
- String name = null;
- try {
- name = transport.name();
- String transportDirName = transport.transportDirName();
- File stateDir = new File(mBaseStateDir, transportDirName);
- stateDir.mkdirs();
-
- File initSentinel = new File(stateDir, INIT_SENTINEL_FILE_NAME);
- if (initSentinel.exists()) {
- synchronized (mQueueLock) {
- mPendingInits.add(name);
-
- // TODO: pick a better starting time than now + 1 minute
- long delay = 1000 * 60; // one minute, in milliseconds
- mAlarmManager.set(AlarmManager.RTC_WAKEUP,
- System.currentTimeMillis() + delay, mRunInitIntent);
- }
- }
- return true;
- } catch (Exception e) {
- // the transport threw when asked its file naming prefs; declare it invalid
- Slog.w(TAG, "Failed to regiser transport: " + name);
- return false;
- }
- }
- };
-
- // ----- Track installation/removal of packages -----
- BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
- public void onReceive(Context context, Intent intent) {
- if (MORE_DEBUG) Slog.d(TAG, "Received broadcast " + intent);
-
- String action = intent.getAction();
- boolean replacing = false;
- boolean added = false;
- boolean changed = false;
- Bundle extras = intent.getExtras();
- String pkgList[] = null;
- if (Intent.ACTION_PACKAGE_ADDED.equals(action) ||
- Intent.ACTION_PACKAGE_REMOVED.equals(action) ||
- Intent.ACTION_PACKAGE_CHANGED.equals(action)) {
- Uri uri = intent.getData();
- if (uri == null) {
- return;
- }
- final String pkgName = uri.getSchemeSpecificPart();
- if (pkgName != null) {
- pkgList = new String[] { pkgName };
- }
- changed = Intent.ACTION_PACKAGE_CHANGED.equals(action);
-
- // At package-changed we only care about looking at new transport states
- if (changed) {
- final String[] components =
- intent.getStringArrayExtra(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST);
-
- if (MORE_DEBUG) {
- Slog.i(TAG, "Package " + pkgName + " changed; rechecking");
- for (int i = 0; i < components.length; i++) {
- Slog.i(TAG, " * " + components[i]);
- }
- }
-
- mBackupHandler.post(
- () -> mTransportManager.onPackageChanged(pkgName, components));
- return; // nothing more to do in the PACKAGE_CHANGED case
- }
-
- added = Intent.ACTION_PACKAGE_ADDED.equals(action);
- replacing = extras.getBoolean(Intent.EXTRA_REPLACING, false);
- } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) {
- added = true;
- pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
- } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) {
- added = false;
- pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
- }
-
- if (pkgList == null || pkgList.length == 0) {
- return;
- }
-
- final int uid = extras.getInt(Intent.EXTRA_UID);
- if (added) {
- synchronized (mBackupParticipants) {
- if (replacing) {
- // This is the package-replaced case; we just remove the entry
- // under the old uid and fall through to re-add. If an app
- // just added key/value backup participation, this picks it up
- // as a known participant.
- removePackageParticipantsLocked(pkgList, uid);
- }
- addPackageParticipantsLocked(pkgList);
- }
- // If they're full-backup candidates, add them there instead
- final long now = System.currentTimeMillis();
- for (final String packageName : pkgList) {
- try {
- PackageInfo app = mPackageManager.getPackageInfo(packageName, 0);
- if (appGetsFullBackup(app)
- && appIsEligibleForBackup(app.applicationInfo, mPackageManager)) {
- enqueueFullBackup(packageName, now);
- scheduleNextFullBackupJob(0);
- } else {
- // The app might have just transitioned out of full-data into
- // doing key/value backups, or might have just disabled backups
- // entirely. Make sure it is no longer in the full-data queue.
- synchronized (mQueueLock) {
- dequeueFullBackupLocked(packageName);
- }
- writeFullBackupScheduleAsync();
- }
-
- mBackupHandler.post(
- () -> mTransportManager.onPackageAdded(packageName));
-
- } catch (NameNotFoundException e) {
- // doesn't really exist; ignore it
- if (DEBUG) {
- Slog.w(TAG, "Can't resolve new app " + packageName);
- }
- }
- }
-
- // Whenever a package is added or updated we need to update
- // the package metadata bookkeeping.
- dataChangedImpl(PACKAGE_MANAGER_SENTINEL);
- } else {
- if (replacing) {
- // The package is being updated. We'll receive a PACKAGE_ADDED shortly.
- } else {
- // Outright removal. In the full-data case, the app will be dropped
- // from the queue when its (now obsolete) name comes up again for
- // backup.
- synchronized (mBackupParticipants) {
- removePackageParticipantsLocked(pkgList, uid);
- }
- }
- for (final String pkgName : pkgList) {
- mBackupHandler.post(
- () -> mTransportManager.onPackageRemoved(pkgName));
- }
- }
- }
- };
-
- // Add the backup agents in the given packages to our set of known backup participants.
- // If 'packageNames' is null, adds all backup agents in the whole system.
- void addPackageParticipantsLocked(String[] packageNames) {
- // Look for apps that define the android:backupAgent attribute
- List<PackageInfo> targetApps = allAgentPackages();
- if (packageNames != null) {
- if (MORE_DEBUG) Slog.v(TAG, "addPackageParticipantsLocked: #" + packageNames.length);
- for (String packageName : packageNames) {
- addPackageParticipantsLockedInner(packageName, targetApps);
- }
- } else {
- if (MORE_DEBUG) Slog.v(TAG, "addPackageParticipantsLocked: all");
- addPackageParticipantsLockedInner(null, targetApps);
- }
- }
-
- private void addPackageParticipantsLockedInner(String packageName,
- List<PackageInfo> targetPkgs) {
- if (MORE_DEBUG) {
- Slog.v(TAG, "Examining " + packageName + " for backup agent");
- }
-
- for (PackageInfo pkg : targetPkgs) {
- if (packageName == null || pkg.packageName.equals(packageName)) {
- int uid = pkg.applicationInfo.uid;
- HashSet<String> set = mBackupParticipants.get(uid);
- if (set == null) {
- set = new HashSet<>();
- mBackupParticipants.put(uid, set);
- }
- set.add(pkg.packageName);
- if (MORE_DEBUG) Slog.v(TAG, "Agent found; added");
-
- // Schedule a backup for it on general principles
- if (MORE_DEBUG) Slog.i(TAG, "Scheduling backup for new app " + pkg.packageName);
- Message msg = mBackupHandler
- .obtainMessage(MSG_SCHEDULE_BACKUP_PACKAGE, pkg.packageName);
- mBackupHandler.sendMessage(msg);
- }
- }
- }
-
- // Remove the given packages' entries from our known active set.
- void removePackageParticipantsLocked(String[] packageNames, int oldUid) {
- if (packageNames == null) {
- Slog.w(TAG, "removePackageParticipants with null list");
- return;
- }
-
- if (MORE_DEBUG) Slog.v(TAG, "removePackageParticipantsLocked: uid=" + oldUid
- + " #" + packageNames.length);
- for (String pkg : packageNames) {
- // Known previous UID, so we know which package set to check
- HashSet<String> set = mBackupParticipants.get(oldUid);
- if (set != null && set.contains(pkg)) {
- removePackageFromSetLocked(set, pkg);
- if (set.isEmpty()) {
- if (MORE_DEBUG) Slog.v(TAG, " last one of this uid; purging set");
- mBackupParticipants.remove(oldUid);
- }
- }
- }
- }
-
- private void removePackageFromSetLocked(final HashSet<String> set,
- final String packageName) {
- if (set.contains(packageName)) {
- // Found it. Remove this one package from the bookkeeping, and
- // if it's the last participating app under this uid we drop the
- // (now-empty) set as well.
- // Note that we deliberately leave it 'known' in the "ever backed up"
- // bookkeeping so that its current-dataset data will be retrieved
- // if the app is subsequently reinstalled
- if (MORE_DEBUG) Slog.v(TAG, " removing participant " + packageName);
- set.remove(packageName);
- mPendingBackups.remove(packageName);
- }
- }
-
- // Returns the set of all applications that define an android:backupAgent attribute
- List<PackageInfo> allAgentPackages() {
- // !!! TODO: cache this and regenerate only when necessary
- int flags = PackageManager.GET_SIGNATURES;
- List<PackageInfo> packages = mPackageManager.getInstalledPackages(flags);
- int N = packages.size();
- for (int a = N-1; a >= 0; a--) {
- PackageInfo pkg = packages.get(a);
- try {
- ApplicationInfo app = pkg.applicationInfo;
- if (((app.flags&ApplicationInfo.FLAG_ALLOW_BACKUP) == 0)
- || app.backupAgentName == null
- || (app.flags&ApplicationInfo.FLAG_FULL_BACKUP_ONLY) != 0) {
- packages.remove(a);
- }
- else {
- // we will need the shared library path, so look that up and store it here.
- // This is used implicitly when we pass the PackageInfo object off to
- // the Activity Manager to launch the app for backup/restore purposes.
- app = mPackageManager.getApplicationInfo(pkg.packageName,
- PackageManager.GET_SHARED_LIBRARY_FILES);
- pkg.applicationInfo.sharedLibraryFiles = app.sharedLibraryFiles;
- }
- } catch (NameNotFoundException e) {
- packages.remove(a);
- }
- }
- return packages;
- }
-
- // Called from the backup tasks: record that the given app has been successfully
- // backed up at least once. This includes both key/value and full-data backups
- // through the transport.
- void logBackupComplete(String packageName) {
- if (packageName.equals(PACKAGE_MANAGER_SENTINEL)) return;
-
- synchronized (mEverStoredApps) {
- if (!mEverStoredApps.add(packageName)) return;
-
- RandomAccessFile out = null;
- try {
- out = new RandomAccessFile(mEverStored, "rws");
- out.seek(out.length());
- out.writeUTF(packageName);
- } catch (IOException e) {
- Slog.e(TAG, "Can't log backup of " + packageName + " to " + mEverStored);
- } finally {
- try { if (out != null) out.close(); } catch (IOException e) {}
- }
- }
- }
-
- // Persistently record the current and ancestral backup tokens as well
- // as the set of packages with data [supposedly] available in the
- // ancestral dataset.
- void writeRestoreTokens() {
- try {
- RandomAccessFile af = new RandomAccessFile(mTokenFile, "rwd");
-
- // First, the version number of this record, for futureproofing
- af.writeInt(CURRENT_ANCESTRAL_RECORD_VERSION);
-
- // Write the ancestral and current tokens
- af.writeLong(mAncestralToken);
- af.writeLong(mCurrentToken);
-
- // Now write the set of ancestral packages
- if (mAncestralPackages == null) {
- af.writeInt(-1);
- } else {
- af.writeInt(mAncestralPackages.size());
- if (DEBUG) Slog.v(TAG, "Ancestral packages: " + mAncestralPackages.size());
- for (String pkgName : mAncestralPackages) {
- af.writeUTF(pkgName);
- if (MORE_DEBUG) Slog.v(TAG, " " + pkgName);
- }
- }
- af.close();
- } catch (IOException e) {
- Slog.w(TAG, "Unable to write token file:", e);
- }
- }
-
- // What name is this transport registered under...?
- private String getTransportName(IBackupTransport transport) {
- if (MORE_DEBUG) {
- Slog.v(TAG, "Searching for transport name of " + transport);
- }
- return mTransportManager.getTransportName(transport);
- }
-
- // fire off a backup agent, blocking until it attaches or times out
- @Override
- public IBackupAgent bindToAgentSynchronous(ApplicationInfo app, int mode) {
- IBackupAgent agent = null;
- synchronized(mAgentConnectLock) {
- mConnecting = true;
- mConnectedAgent = null;
- try {
- if (mActivityManager.bindBackupAgent(app.packageName, mode,
- UserHandle.USER_OWNER)) {
- Slog.d(TAG, "awaiting agent for " + app);
-
- // success; wait for the agent to arrive
- // only wait 10 seconds for the bind to happen
- long timeoutMark = System.currentTimeMillis() + TIMEOUT_INTERVAL;
- while (mConnecting && mConnectedAgent == null
- && (System.currentTimeMillis() < timeoutMark)) {
- try {
- mAgentConnectLock.wait(5000);
- } catch (InterruptedException e) {
- // just bail
- Slog.w(TAG, "Interrupted: " + e);
- mConnecting = false;
- mConnectedAgent = null;
- }
- }
-
- // if we timed out with no connect, abort and move on
- if (mConnecting == true) {
- Slog.w(TAG, "Timeout waiting for agent " + app);
- mConnectedAgent = null;
- }
- if (DEBUG) Slog.i(TAG, "got agent " + mConnectedAgent);
- agent = mConnectedAgent;
- }
- } catch (RemoteException e) {
- // can't happen - ActivityManager is local
- }
- }
- if (agent == null) {
- try {
- mActivityManager.clearPendingBackup();
- } catch (RemoteException e) {
- // can't happen - ActivityManager is local
- }
- }
- return agent;
- }
-
- // clear an application's data, blocking until the operation completes or times out
- void clearApplicationDataSynchronous(String packageName) {
- // Don't wipe packages marked allowClearUserData=false
- try {
- PackageInfo info = mPackageManager.getPackageInfo(packageName, 0);
- if ((info.applicationInfo.flags & ApplicationInfo.FLAG_ALLOW_CLEAR_USER_DATA) == 0) {
- if (MORE_DEBUG) Slog.i(TAG, "allowClearUserData=false so not wiping "
- + packageName);
- return;
- }
- } catch (NameNotFoundException e) {
- Slog.w(TAG, "Tried to clear data for " + packageName + " but not found");
- return;
- }
-
- ClearDataObserver observer = new ClearDataObserver();
-
- synchronized(mClearDataLock) {
- mClearingData = true;
- try {
- mActivityManager.clearApplicationUserData(packageName, observer, 0);
- } catch (RemoteException e) {
- // can't happen because the activity manager is in this process
- }
-
- // only wait 10 seconds for the clear data to happen
- long timeoutMark = System.currentTimeMillis() + TIMEOUT_INTERVAL;
- while (mClearingData && (System.currentTimeMillis() < timeoutMark)) {
- try {
- mClearDataLock.wait(5000);
- } catch (InterruptedException e) {
- // won't happen, but still.
- mClearingData = false;
- }
- }
- }
- }
-
- class ClearDataObserver extends IPackageDataObserver.Stub {
- public void onRemoveCompleted(String packageName, boolean succeeded) {
- synchronized(mClearDataLock) {
- mClearingData = false;
- mClearDataLock.notifyAll();
- }
- }
- }
-
- // Get the restore-set token for the best-available restore set for this package:
- // the active set if possible, else the ancestral one. Returns zero if none available.
- @Override
- public long getAvailableRestoreToken(String packageName) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "getAvailableRestoreToken");
-
- long token = mAncestralToken;
- synchronized (mQueueLock) {
- if (mCurrentToken != 0 && mEverStoredApps.contains(packageName)) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "App in ever-stored, so using current token");
- }
- token = mCurrentToken;
- }
- }
- if (MORE_DEBUG) Slog.i(TAG, "getAvailableRestoreToken() == " + token);
- return token;
- }
-
- @Override
- public int requestBackup(String[] packages, IBackupObserver observer, int flags) {
- return requestBackup(packages, observer, null, flags);
- }
-
- @Override
- public int requestBackup(String[] packages, IBackupObserver observer,
- IBackupManagerMonitor monitor, int flags) {
- mContext.enforceCallingPermission(android.Manifest.permission.BACKUP, "requestBackup");
-
- if (packages == null || packages.length < 1) {
- Slog.e(TAG, "No packages named for backup request");
- sendBackupFinished(observer, BackupManager.ERROR_TRANSPORT_ABORTED);
- monitor = monitorEvent(monitor, BackupManagerMonitor.LOG_EVENT_ID_NO_PACKAGES,
- null, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, null);
- throw new IllegalArgumentException("No packages are provided for backup");
- }
-
- if (!mEnabled || !mProvisioned) {
- Slog.i(TAG, "Backup requested but e=" + mEnabled + " p=" +mProvisioned);
- sendBackupFinished(observer, BackupManager.ERROR_BACKUP_NOT_ALLOWED);
- final int logTag = mProvisioned
- ? BackupManagerMonitor.LOG_EVENT_ID_BACKUP_DISABLED
- : BackupManagerMonitor.LOG_EVENT_ID_DEVICE_NOT_PROVISIONED;
- monitor = monitorEvent(monitor, logTag, null,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null);
- return BackupManager.ERROR_BACKUP_NOT_ALLOWED;
- }
-
- IBackupTransport transport = mTransportManager.getCurrentTransportBinder();
- if (transport == null) {
- sendBackupFinished(observer, BackupManager.ERROR_TRANSPORT_ABORTED);
- monitor = monitorEvent(monitor, BackupManagerMonitor.LOG_EVENT_ID_TRANSPORT_IS_NULL,
- null, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, null);
- return BackupManager.ERROR_TRANSPORT_ABORTED;
- }
-
- ArrayList<String> fullBackupList = new ArrayList<>();
- ArrayList<String> kvBackupList = new ArrayList<>();
- for (String packageName : packages) {
- if (PACKAGE_MANAGER_SENTINEL.equals(packageName)) {
- kvBackupList.add(packageName);
- continue;
- }
- try {
- PackageInfo packageInfo = mPackageManager.getPackageInfo(packageName,
- PackageManager.GET_SIGNATURES);
- if (!appIsEligibleForBackup(packageInfo.applicationInfo, mPackageManager)) {
- sendBackupOnPackageResult(observer, packageName,
- BackupManager.ERROR_BACKUP_NOT_ALLOWED);
- continue;
- }
- if (appGetsFullBackup(packageInfo)) {
- fullBackupList.add(packageInfo.packageName);
- } else {
- kvBackupList.add(packageInfo.packageName);
- }
- } catch (NameNotFoundException e) {
- sendBackupOnPackageResult(observer, packageName,
- BackupManager.ERROR_PACKAGE_NOT_FOUND);
- }
- }
- EventLog.writeEvent(EventLogTags.BACKUP_REQUESTED, packages.length, kvBackupList.size(),
- fullBackupList.size());
- if (MORE_DEBUG) {
- Slog.i(TAG, "Backup requested for " + packages.length + " packages, of them: " +
- fullBackupList.size() + " full backups, " + kvBackupList.size() + " k/v backups");
- }
-
- String dirName;
- try {
- dirName = transport.transportDirName();
- } catch (Exception e) {
- Slog.e(TAG, "Transport unavailable while attempting backup: " + e.getMessage());
- sendBackupFinished(observer, BackupManager.ERROR_TRANSPORT_ABORTED);
- return BackupManager.ERROR_TRANSPORT_ABORTED;
- }
-
- boolean nonIncrementalBackup = (flags & BackupManager.FLAG_NON_INCREMENTAL_BACKUP) != 0;
-
- Message msg = mBackupHandler.obtainMessage(MSG_REQUEST_BACKUP);
- msg.obj = new BackupParams(transport, dirName, kvBackupList, fullBackupList, observer,
- monitor, true, nonIncrementalBackup);
- mBackupHandler.sendMessage(msg);
- return BackupManager.SUCCESS;
- }
-
- // Cancel all running backups.
- @Override
- public void cancelBackups(){
- mContext.enforceCallingPermission(android.Manifest.permission.BACKUP, "cancelBackups");
- if (MORE_DEBUG) {
- Slog.i(TAG, "cancelBackups() called.");
- }
- final long oldToken = Binder.clearCallingIdentity();
- try {
- List<Integer> operationsToCancel = new ArrayList<>();
- synchronized (mCurrentOpLock) {
- for (int i = 0; i < mCurrentOperations.size(); i++) {
- Operation op = mCurrentOperations.valueAt(i);
- int token = mCurrentOperations.keyAt(i);
- if (op.type == OP_TYPE_BACKUP) {
- operationsToCancel.add(token);
- }
- }
- }
- for (Integer token : operationsToCancel) {
- handleCancel(token, true /* cancelAll */);
- }
- // We don't want the backup jobs to kick in any time soon.
- // Reschedules them to run in the distant future.
- KeyValueBackupJob.schedule(mContext, BUSY_BACKOFF_MIN_MILLIS, mConstants);
- FullBackupJob.schedule(mContext, 2 * BUSY_BACKOFF_MIN_MILLIS, mConstants);
- } finally {
- Binder.restoreCallingIdentity(oldToken);
- }
- }
-
- @Override
- public void prepareOperationTimeout(int token, long interval, BackupRestoreTask callback,
- int operationType) {
- if (operationType != OP_TYPE_BACKUP_WAIT && operationType != OP_TYPE_RESTORE_WAIT) {
- Slog.wtf(TAG, "prepareOperationTimeout() doesn't support operation " +
- Integer.toHexString(token) + " of type " + operationType);
- return;
- }
- if (MORE_DEBUG) Slog.v(TAG, "starting timeout: token=" + Integer.toHexString(token)
- + " interval=" + interval + " callback=" + callback);
-
- synchronized (mCurrentOpLock) {
- mCurrentOperations.put(token, new Operation(OP_PENDING, callback, operationType));
- Message msg = mBackupHandler.obtainMessage(getMessageIdForOperationType(operationType),
- token, 0, callback);
- mBackupHandler.sendMessageDelayed(msg, interval);
- }
- }
-
- private int getMessageIdForOperationType(int operationType) {
- switch (operationType) {
- case OP_TYPE_BACKUP_WAIT:
- return MSG_BACKUP_OPERATION_TIMEOUT;
- case OP_TYPE_RESTORE_WAIT:
- return MSG_RESTORE_OPERATION_TIMEOUT;
- default:
- Slog.wtf(TAG, "getMessageIdForOperationType called on invalid operation type: " +
- operationType);
- return -1;
- }
- }
-
- private void removeOperation(int token) {
- if (MORE_DEBUG) {
- Slog.d(TAG, "Removing operation token=" + Integer.toHexString(token));
- }
- synchronized (mCurrentOpLock) {
- if (mCurrentOperations.get(token) == null) {
- Slog.w(TAG, "Duplicate remove for operation. token=" +
- Integer.toHexString(token));
- }
- mCurrentOperations.remove(token);
- }
- }
-
- // synchronous waiter case
- @Override
- public boolean waitUntilOperationComplete(int token) {
- if (MORE_DEBUG) Slog.i(TAG, "Blocking until operation complete for "
- + Integer.toHexString(token));
- int finalState = OP_PENDING;
- Operation op = null;
- synchronized (mCurrentOpLock) {
- while (true) {
- op = mCurrentOperations.get(token);
- if (op == null) {
- // mysterious disappearance: treat as success with no callback
- break;
- } else {
- if (op.state == OP_PENDING) {
- try {
- mCurrentOpLock.wait();
- } catch (InterruptedException e) {
- }
- // When the wait is notified we loop around and recheck the current state
- } else {
- if (MORE_DEBUG) {
- Slog.d(TAG, "Unblocked waiting for operation token=" +
- Integer.toHexString(token));
- }
- // No longer pending; we're done
- finalState = op.state;
- break;
- }
- }
- }
- }
-
- removeOperation(token);
- if (op != null) {
- mBackupHandler.removeMessages(getMessageIdForOperationType(op.type));
- }
- if (MORE_DEBUG) Slog.v(TAG, "operation " + Integer.toHexString(token)
- + " complete: finalState=" + finalState);
- return finalState == OP_ACKNOWLEDGED;
- }
-
- void handleCancel(int token, boolean cancelAll) {
- // Notify any synchronous waiters
- Operation op = null;
- synchronized (mCurrentOpLock) {
- op = mCurrentOperations.get(token);
- if (MORE_DEBUG) {
- if (op == null) Slog.w(TAG, "Cancel of token " + Integer.toHexString(token)
- + " but no op found");
- }
- int state = (op != null) ? op.state : OP_TIMEOUT;
- if (state == OP_ACKNOWLEDGED) {
- // The operation finished cleanly, so we have nothing more to do.
- if (DEBUG) {
- Slog.w(TAG, "Operation already got an ack." +
- "Should have been removed from mCurrentOperations.");
- }
- op = null;
- mCurrentOperations.delete(token);
- } else if (state == OP_PENDING) {
- if (DEBUG) Slog.v(TAG, "Cancel: token=" + Integer.toHexString(token));
- op.state = OP_TIMEOUT;
- // Can't delete op from mCurrentOperations here. waitUntilOperationComplete may be
- // called after we receive cancel here. We need this op's state there.
-
- // Remove all pending timeout messages of types OP_TYPE_BACKUP_WAIT and
- // OP_TYPE_RESTORE_WAIT. On the other hand, OP_TYPE_BACKUP cannot time out and
- // doesn't require cancellation.
- if (op.type == OP_TYPE_BACKUP_WAIT || op.type == OP_TYPE_RESTORE_WAIT) {
- mBackupHandler.removeMessages(getMessageIdForOperationType(op.type));
- }
- }
- mCurrentOpLock.notifyAll();
- }
-
- // If there's a TimeoutHandler for this event, call it
- if (op != null && op.callback != null) {
- if (MORE_DEBUG) {
- Slog.v(TAG, " Invoking cancel on " + op.callback);
- }
- op.callback.handleCancel(cancelAll);
- }
- }
-
- // ----- Back up a set of applications via a worker thread -----
-
- enum BackupState {
- INITIAL,
- RUNNING_QUEUE,
- FINAL
- }
-
- /**
- * This class handles the process of backing up a given list of key/value backup packages.
- * Also takes in a list of pending dolly backups and kicks them off when key/value backups
- * are done.
- *
- * Flow:
- * If required, backup @pm@.
- * For each pending key/value backup package:
- * - Bind to agent.
- * - Call agent.doBackup()
- * - Wait either for cancel/timeout or operationComplete() callback from the agent.
- * Start task to perform dolly backups.
- *
- * There are three entry points into this class:
- * - execute() [Called from the handler thread]
- * - operationComplete(long result) [Called from the handler thread]
- * - handleCancel(boolean cancelAll) [Can be called from any thread]
- * These methods synchronize on mCancelLock.
- *
- * Interaction with mCurrentOperations:
- * - An entry for this task is put into mCurrentOperations for the entire lifetime of the
- * task. This is useful to cancel the task if required.
- * - An ephemeral entry is put into mCurrentOperations each time we are waiting on for
- * response from a backup agent. This is used to plumb timeouts and completion callbacks.
- */
- class PerformBackupTask implements BackupRestoreTask {
- private static final String TAG = "PerformBackupTask";
-
- private final Object mCancelLock = new Object();
-
- IBackupTransport mTransport;
- ArrayList<BackupRequest> mQueue;
- ArrayList<BackupRequest> mOriginalQueue;
- File mStateDir;
- File mJournal;
- BackupState mCurrentState;
- List<String> mPendingFullBackups;
- IBackupObserver mObserver;
- IBackupManagerMonitor mMonitor;
-
- private final PerformFullTransportBackupTask mFullBackupTask;
- private final int mCurrentOpToken;
- private volatile int mEphemeralOpToken;
-
- // carried information about the current in-flight operation
- IBackupAgent mAgentBinder;
- PackageInfo mCurrentPackage;
- File mSavedStateName;
- File mBackupDataName;
- File mNewStateName;
- ParcelFileDescriptor mSavedState;
- ParcelFileDescriptor mBackupData;
- ParcelFileDescriptor mNewState;
- int mStatus;
- boolean mFinished;
- final boolean mUserInitiated;
- final boolean mNonIncremental;
-
- private volatile boolean mCancelAll;
-
- public PerformBackupTask(IBackupTransport transport, String dirName,
- ArrayList<BackupRequest> queue, File journal, IBackupObserver observer,
- IBackupManagerMonitor monitor, List<String> pendingFullBackups,
- boolean userInitiated, boolean nonIncremental) {
- mTransport = transport;
- mOriginalQueue = queue;
- mQueue = new ArrayList<>();
- mJournal = journal;
- mObserver = observer;
- mMonitor = monitor;
- mPendingFullBackups = pendingFullBackups;
- mUserInitiated = userInitiated;
- mNonIncremental = nonIncremental;
-
- mStateDir = new File(mBaseStateDir, dirName);
- mCurrentOpToken = generateRandomIntegerToken();
-
- mFinished = false;
-
- synchronized (mCurrentOpLock) {
- if (isBackupOperationInProgress()) {
- if (DEBUG) {
- Slog.d(TAG, "Skipping backup since one is already in progress.");
- }
- mCancelAll = true;
- mFullBackupTask = null;
- mCurrentState = BackupState.FINAL;
- addBackupTrace("Skipped. Backup already in progress.");
- } else {
- mCurrentState = BackupState.INITIAL;
- CountDownLatch latch = new CountDownLatch(1);
- String[] fullBackups =
- mPendingFullBackups.toArray(new String[mPendingFullBackups.size()]);
- mFullBackupTask =
- new PerformFullTransportBackupTask(/*fullBackupRestoreObserver*/ null,
- fullBackups, /*updateSchedule*/ false, /*runningJob*/ null,
- latch,
- mObserver, mMonitor, mUserInitiated);
-
- registerTask();
- addBackupTrace("STATE => INITIAL");
- }
- }
- }
-
- /**
- * Put this task in the repository of running tasks.
- */
- private void registerTask() {
- synchronized (mCurrentOpLock) {
- mCurrentOperations.put(mCurrentOpToken, new Operation(OP_PENDING, this,
- OP_TYPE_BACKUP));
- }
- }
-
- /**
- * Remove this task from repository of running tasks.
- */
- private void unregisterTask() {
- removeOperation(mCurrentOpToken);
- }
-
- // Main entry point: perform one chunk of work, updating the state as appropriate
- // and reposting the next chunk to the primary backup handler thread.
- @Override
- @GuardedBy("mCancelLock")
- public void execute() {
- synchronized (mCancelLock) {
- switch (mCurrentState) {
- case INITIAL:
- beginBackup();
- break;
-
- case RUNNING_QUEUE:
- invokeNextAgent();
- break;
-
- case FINAL:
- if (!mFinished) {
- finalizeBackup();
- } else {
- Slog.e(TAG, "Duplicate finish of K/V pass");
- }
- break;
- }
- }
- }
-
- // We're starting a backup pass. Initialize the transport and send
- // the PM metadata blob if we haven't already.
- void beginBackup() {
- if (DEBUG_BACKUP_TRACE) {
- clearBackupTrace();
- StringBuilder b = new StringBuilder(256);
- b.append("beginBackup: [");
- for (BackupRequest req : mOriginalQueue) {
- b.append(' ');
- b.append(req.packageName);
- }
- b.append(" ]");
- addBackupTrace(b.toString());
- }
-
- mAgentBinder = null;
- mStatus = BackupTransport.TRANSPORT_OK;
-
- // Sanity check: if the queue is empty we have no work to do.
- if (mOriginalQueue.isEmpty() && mPendingFullBackups.isEmpty()) {
- Slog.w(TAG, "Backup begun with an empty queue - nothing to do.");
- addBackupTrace("queue empty at begin");
- sendBackupFinished(mObserver, BackupManager.SUCCESS);
- executeNextState(BackupState.FINAL);
- return;
- }
-
- // We need to retain the original queue contents in case of transport
- // failure, but we want a working copy that we can manipulate along
- // the way.
- mQueue = (ArrayList<BackupRequest>) mOriginalQueue.clone();
-
- // When the transport is forcing non-incremental key/value payloads, we send the
- // metadata only if it explicitly asks for it.
- boolean skipPm = mNonIncremental;
-
- // The app metadata pseudopackage might also be represented in the
- // backup queue if apps have been added/removed since the last time
- // we performed a backup. Drop it from the working queue now that
- // we're committed to evaluating it for backup regardless.
- for (int i = 0; i < mQueue.size(); i++) {
- if (PACKAGE_MANAGER_SENTINEL.equals(mQueue.get(i).packageName)) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Metadata in queue; eliding");
- }
- mQueue.remove(i);
- skipPm = false;
- break;
- }
- }
-
- if (DEBUG) Slog.v(TAG, "Beginning backup of " + mQueue.size() + " targets");
-
- File pmState = new File(mStateDir, PACKAGE_MANAGER_SENTINEL);
- try {
- final String transportName = mTransport.transportDirName();
- EventLog.writeEvent(EventLogTags.BACKUP_START, transportName);
-
- // If we haven't stored package manager metadata yet, we must init the transport.
- if (mStatus == BackupTransport.TRANSPORT_OK && pmState.length() <= 0) {
- Slog.i(TAG, "Initializing (wiping) backup state and transport storage");
- addBackupTrace("initializing transport " + transportName);
- resetBackupState(mStateDir); // Just to make sure.
- mStatus = mTransport.initializeDevice();
-
- addBackupTrace("transport.initializeDevice() == " + mStatus);
- if (mStatus == BackupTransport.TRANSPORT_OK) {
- EventLog.writeEvent(EventLogTags.BACKUP_INITIALIZE);
- } else {
- EventLog.writeEvent(EventLogTags.BACKUP_TRANSPORT_FAILURE, "(initialize)");
- Slog.e(TAG, "Transport error in initializeDevice()");
- }
- }
-
- if (skipPm) {
- Slog.d(TAG, "Skipping backup of package metadata.");
- executeNextState(BackupState.RUNNING_QUEUE);
- } else {
- // The package manager doesn't have a proper <application> etc, but since
- // it's running here in the system process we can just set up its agent
- // directly and use a synthetic BackupRequest. We always run this pass
- // because it's cheap and this way we guarantee that we don't get out of
- // step even if we're selecting among various transports at run time.
- if (mStatus == BackupTransport.TRANSPORT_OK) {
- PackageManagerBackupAgent pmAgent = makeMetadataAgent();
- mStatus = invokeAgentForBackup(PACKAGE_MANAGER_SENTINEL,
- IBackupAgent.Stub.asInterface(pmAgent.onBind()), mTransport);
- addBackupTrace("PMBA invoke: " + mStatus);
-
- // Because the PMBA is a local instance, it has already executed its
- // backup callback and returned. Blow away the lingering (spurious)
- // pending timeout message for it.
- mBackupHandler.removeMessages(MSG_BACKUP_OPERATION_TIMEOUT);
- }
- }
-
- if (mStatus == BackupTransport.TRANSPORT_NOT_INITIALIZED) {
- // The backend reports that our dataset has been wiped. Note this in
- // the event log; the no-success code below will reset the backup
- // state as well.
- EventLog.writeEvent(EventLogTags.BACKUP_RESET, transportName);
- }
- } catch (Exception e) {
- Slog.e(TAG, "Error in backup thread", e);
- addBackupTrace("Exception in backup thread: " + e);
- mStatus = BackupTransport.TRANSPORT_ERROR;
- } finally {
- // If we've succeeded so far, invokeAgentForBackup() will have run the PM
- // metadata and its completion/timeout callback will continue the state
- // machine chain. If it failed that won't happen; we handle that now.
- addBackupTrace("exiting prelim: " + mStatus);
- if (mStatus != BackupTransport.TRANSPORT_OK) {
- // if things went wrong at this point, we need to
- // restage everything and try again later.
- resetBackupState(mStateDir); // Just to make sure.
- // In case of any other error, it's backup transport error.
- sendBackupFinished(mObserver, BackupManager.ERROR_TRANSPORT_ABORTED);
- executeNextState(BackupState.FINAL);
- }
- }
- }
-
- // Transport has been initialized and the PM metadata submitted successfully
- // if that was warranted. Now we process the single next thing in the queue.
- void invokeNextAgent() {
- mStatus = BackupTransport.TRANSPORT_OK;
- addBackupTrace("invoke q=" + mQueue.size());
-
- // Sanity check that we have work to do. If not, skip to the end where
- // we reestablish the wakelock invariants etc.
- if (mQueue.isEmpty()) {
- if (MORE_DEBUG) Slog.i(TAG, "queue now empty");
- executeNextState(BackupState.FINAL);
- return;
- }
-
- // pop the entry we're going to process on this step
- BackupRequest request = mQueue.get(0);
- mQueue.remove(0);
-
- Slog.d(TAG, "starting key/value backup of " + request);
- addBackupTrace("launch agent for " + request.packageName);
-
- // Verify that the requested app exists; it might be something that
- // requested a backup but was then uninstalled. The request was
- // journalled and rather than tamper with the journal it's safer
- // to sanity-check here. This also gives us the classname of the
- // package's backup agent.
- try {
- mCurrentPackage = mPackageManager.getPackageInfo(request.packageName,
- PackageManager.GET_SIGNATURES);
- if (!appIsEligibleForBackup(mCurrentPackage.applicationInfo, mPackageManager)) {
- // The manifest has changed but we had a stale backup request pending.
- // This won't happen again because the app won't be requesting further
- // backups.
- Slog.i(TAG, "Package " + request.packageName
- + " no longer supports backup; skipping");
- addBackupTrace("skipping - not eligible, completion is noop");
- // Shouldn't happen in case of requested backup, as pre-check was done in
- // #requestBackup(), except to app update done concurrently
- sendBackupOnPackageResult(mObserver, mCurrentPackage.packageName,
- BackupManager.ERROR_BACKUP_NOT_ALLOWED);
- executeNextState(BackupState.RUNNING_QUEUE);
- return;
- }
-
- if (appGetsFullBackup(mCurrentPackage)) {
- // It's possible that this app *formerly* was enqueued for key/value backup,
- // but has since been updated and now only supports the full-data path.
- // Don't proceed with a key/value backup for it in this case.
- Slog.i(TAG, "Package " + request.packageName
- + " requests full-data rather than key/value; skipping");
- addBackupTrace("skipping - fullBackupOnly, completion is noop");
- // Shouldn't happen in case of requested backup, as pre-check was done in
- // #requestBackup()
- sendBackupOnPackageResult(mObserver, mCurrentPackage.packageName,
- BackupManager.ERROR_BACKUP_NOT_ALLOWED);
- executeNextState(BackupState.RUNNING_QUEUE);
- return;
- }
-
- if (appIsStopped(mCurrentPackage.applicationInfo)) {
- // The app has been force-stopped or cleared or just installed,
- // and not yet launched out of that state, so just as it won't
- // receive broadcasts, we won't run it for backup.
- addBackupTrace("skipping - stopped");
- sendBackupOnPackageResult(mObserver, mCurrentPackage.packageName,
- BackupManager.ERROR_BACKUP_NOT_ALLOWED);
- executeNextState(BackupState.RUNNING_QUEUE);
- return;
- }
-
- IBackupAgent agent = null;
- try {
- mWakelock.setWorkSource(new WorkSource(mCurrentPackage.applicationInfo.uid));
- agent = bindToAgentSynchronous(mCurrentPackage.applicationInfo,
- ApplicationThreadConstants.BACKUP_MODE_INCREMENTAL);
- addBackupTrace("agent bound; a? = " + (agent != null));
- if (agent != null) {
- mAgentBinder = agent;
- mStatus = invokeAgentForBackup(request.packageName, agent, mTransport);
- // at this point we'll either get a completion callback from the
- // agent, or a timeout message on the main handler. either way, we're
- // done here as long as we're successful so far.
- } else {
- // Timeout waiting for the agent
- mStatus = BackupTransport.AGENT_ERROR;
- }
- } catch (SecurityException ex) {
- // Try for the next one.
- Slog.d(TAG, "error in bind/backup", ex);
- mStatus = BackupTransport.AGENT_ERROR;
- addBackupTrace("agent SE");
- }
- } catch (NameNotFoundException e) {
- Slog.d(TAG, "Package does not exist; skipping");
- addBackupTrace("no such package");
- mStatus = BackupTransport.AGENT_UNKNOWN;
- } finally {
- mWakelock.setWorkSource(null);
-
- // If there was an agent error, no timeout/completion handling will occur.
- // That means we need to direct to the next state ourselves.
- if (mStatus != BackupTransport.TRANSPORT_OK) {
- BackupState nextState = BackupState.RUNNING_QUEUE;
- mAgentBinder = null;
-
- // An agent-level failure means we reenqueue this one agent for
- // a later retry, but otherwise proceed normally.
- if (mStatus == BackupTransport.AGENT_ERROR) {
- if (MORE_DEBUG) Slog.i(TAG, "Agent failure for " + request.packageName
- + " - restaging");
- dataChangedImpl(request.packageName);
- mStatus = BackupTransport.TRANSPORT_OK;
- if (mQueue.isEmpty()) nextState = BackupState.FINAL;
- sendBackupOnPackageResult(mObserver, mCurrentPackage.packageName,
- BackupManager.ERROR_AGENT_FAILURE);
- } else if (mStatus == BackupTransport.AGENT_UNKNOWN) {
- // Failed lookup of the app, so we couldn't bring up an agent, but
- // we're otherwise fine. Just drop it and go on to the next as usual.
- mStatus = BackupTransport.TRANSPORT_OK;
- sendBackupOnPackageResult(mObserver, mCurrentPackage.packageName,
- BackupManager.ERROR_PACKAGE_NOT_FOUND);
- } else {
- // Transport-level failure means we reenqueue everything
- revertAndEndBackup();
- nextState = BackupState.FINAL;
- }
-
- executeNextState(nextState);
- } else {
- // success case
- addBackupTrace("expecting completion/timeout callback");
- }
- }
- }
-
- void finalizeBackup() {
- addBackupTrace("finishing");
-
- // Mark packages that we didn't backup (because backup was cancelled, etc.) as needing
- // backup.
- for (BackupRequest req : mQueue) {
- dataChangedImpl(req.packageName);
- }
-
- // Either backup was successful, in which case we of course do not need
- // this pass's journal any more; or it failed, in which case we just
- // re-enqueued all of these packages in the current active journal.
- // Either way, we no longer need this pass's journal.
- if (mJournal != null && !mJournal.delete()) {
- Slog.e(TAG, "Unable to remove backup journal file " + mJournal);
- }
-
- // If everything actually went through and this is the first time we've
- // done a backup, we can now record what the current backup dataset token
- // is.
- if ((mCurrentToken == 0) && (mStatus == BackupTransport.TRANSPORT_OK)) {
- addBackupTrace("success; recording token");
- try {
- mCurrentToken = mTransport.getCurrentRestoreSet();
- writeRestoreTokens();
- } catch (Exception e) {
- // nothing for it at this point, unfortunately, but this will be
- // recorded the next time we fully succeed.
- Slog.e(TAG, "Transport threw reporting restore set: " + e.getMessage());
- addBackupTrace("transport threw returning token");
- }
- }
-
- // Set up the next backup pass - at this point we can set mBackupRunning
- // to false to allow another pass to fire, because we're done with the
- // state machine sequence and the wakelock is refcounted.
- synchronized (mQueueLock) {
- mBackupRunning = false;
- if (mStatus == BackupTransport.TRANSPORT_NOT_INITIALIZED) {
- // Make sure we back up everything and perform the one-time init
- if (MORE_DEBUG) Slog.d(TAG, "Server requires init; rerunning");
- addBackupTrace("init required; rerunning");
- try {
- final String name = mTransportManager.getTransportName(mTransport);
- if (name != null) {
- mPendingInits.add(name);
- } else {
- if (DEBUG) {
- Slog.w(TAG, "Couldn't find name of transport " + mTransport
- + " for init");
- }
- }
- } catch (Exception e) {
- Slog.w(TAG, "Failed to query transport name for init: " + e.getMessage());
- // swallow it and proceed; we don't rely on this
- }
- clearMetadata();
- backupNow();
- }
- }
-
- clearBackupTrace();
-
- unregisterTask();
-
- if (!mCancelAll && mStatus == BackupTransport.TRANSPORT_OK &&
- mPendingFullBackups != null && !mPendingFullBackups.isEmpty()) {
- Slog.d(TAG, "Starting full backups for: " + mPendingFullBackups);
- // Acquiring wakelock for PerformFullTransportBackupTask before its start.
- mWakelock.acquire();
- (new Thread(mFullBackupTask, "full-transport-requested")).start();
- } else if (mCancelAll) {
- if (mFullBackupTask != null) {
- mFullBackupTask.unregisterTask();
- }
- sendBackupFinished(mObserver, BackupManager.ERROR_BACKUP_CANCELLED);
- } else {
- mFullBackupTask.unregisterTask();
- switch (mStatus) {
- case BackupTransport.TRANSPORT_OK:
- sendBackupFinished(mObserver, BackupManager.SUCCESS);
- break;
- case BackupTransport.TRANSPORT_NOT_INITIALIZED:
- sendBackupFinished(mObserver, BackupManager.ERROR_TRANSPORT_ABORTED);
- break;
- case BackupTransport.TRANSPORT_ERROR:
- default:
- sendBackupFinished(mObserver, BackupManager.ERROR_TRANSPORT_ABORTED);
- break;
- }
- }
- mFinished = true;
- Slog.i(BackupManagerService.TAG, "K/V backup pass finished.");
- // Only once we're entirely finished do we release the wakelock for k/v backup.
- mWakelock.release();
- }
-
- // Remove the PM metadata state. This will generate an init on the next pass.
- void clearMetadata() {
- final File pmState = new File(mStateDir, PACKAGE_MANAGER_SENTINEL);
- if (pmState.exists()) pmState.delete();
- }
-
- // Invoke an agent's doBackup() and start a timeout message spinning on the main
- // handler in case it doesn't get back to us.
- int invokeAgentForBackup(String packageName, IBackupAgent agent,
- IBackupTransport transport) {
- if (DEBUG) Slog.d(TAG, "invokeAgentForBackup on " + packageName);
- addBackupTrace("invoking " + packageName);
-
- File blankStateName = new File(mStateDir, "blank_state");
- mSavedStateName = new File(mStateDir, packageName);
- mBackupDataName = new File(mDataDir, packageName + ".data");
- mNewStateName = new File(mStateDir, packageName + ".new");
- if (MORE_DEBUG) Slog.d(TAG, "data file: " + mBackupDataName);
-
- mSavedState = null;
- mBackupData = null;
- mNewState = null;
-
- boolean callingAgent = false;
- mEphemeralOpToken = generateRandomIntegerToken();
- try {
- // Look up the package info & signatures. This is first so that if it
- // throws an exception, there's no file setup yet that would need to
- // be unraveled.
- if (packageName.equals(PACKAGE_MANAGER_SENTINEL)) {
- // The metadata 'package' is synthetic; construct one and make
- // sure our global state is pointed at it
- mCurrentPackage = new PackageInfo();
- mCurrentPackage.packageName = packageName;
- }
-
- // In a full backup, we pass a null ParcelFileDescriptor as
- // the saved-state "file". For key/value backups we pass the old state if
- // an incremental backup is required, and a blank state otherwise.
- mSavedState = ParcelFileDescriptor.open(
- mNonIncremental ? blankStateName : mSavedStateName,
- ParcelFileDescriptor.MODE_READ_ONLY |
- ParcelFileDescriptor.MODE_CREATE); // Make an empty file if necessary
-
- mBackupData = ParcelFileDescriptor.open(mBackupDataName,
- ParcelFileDescriptor.MODE_READ_WRITE |
- ParcelFileDescriptor.MODE_CREATE |
- ParcelFileDescriptor.MODE_TRUNCATE);
-
- if (!SELinux.restorecon(mBackupDataName)) {
- Slog.e(TAG, "SELinux restorecon failed on " + mBackupDataName);
- }
-
- mNewState = ParcelFileDescriptor.open(mNewStateName,
- ParcelFileDescriptor.MODE_READ_WRITE |
- ParcelFileDescriptor.MODE_CREATE |
- ParcelFileDescriptor.MODE_TRUNCATE);
-
- final long quota = mTransport.getBackupQuota(packageName, false /* isFullBackup */);
- callingAgent = true;
-
- // Initiate the target's backup pass
- addBackupTrace("setting timeout");
- prepareOperationTimeout(mEphemeralOpToken, TIMEOUT_BACKUP_INTERVAL, this,
- OP_TYPE_BACKUP_WAIT);
- addBackupTrace("calling agent doBackup()");
-
- agent.doBackup(mSavedState, mBackupData, mNewState, quota, mEphemeralOpToken,
- mBackupManagerBinder);
- } catch (Exception e) {
- Slog.e(TAG, "Error invoking for backup on " + packageName + ". " + e);
- addBackupTrace("exception: " + e);
- EventLog.writeEvent(EventLogTags.BACKUP_AGENT_FAILURE, packageName,
- e.toString());
- errorCleanup();
- return callingAgent ? BackupTransport.AGENT_ERROR
- : BackupTransport.TRANSPORT_ERROR;
- } finally {
- if (mNonIncremental) {
- blankStateName.delete();
- }
- }
-
- // At this point the agent is off and running. The next thing to happen will
- // either be a callback from the agent, at which point we'll process its data
- // for transport, or a timeout. Either way the next phase will happen in
- // response to the TimeoutHandler interface callbacks.
- addBackupTrace("invoke success");
- return BackupTransport.TRANSPORT_OK;
- }
-
- public void failAgent(IBackupAgent agent, String message) {
- try {
- agent.fail(message);
- } catch (Exception e) {
- Slog.w(TAG, "Error conveying failure to " + mCurrentPackage.packageName);
- }
- }
-
- // SHA-1 a byte array and return the result in hex
- private String SHA1Checksum(byte[] input) {
- final byte[] checksum;
- try {
- MessageDigest md = MessageDigest.getInstance("SHA-1");
- checksum = md.digest(input);
- } catch (NoSuchAlgorithmException e) {
- Slog.e(TAG, "Unable to use SHA-1!");
- return "00";
- }
-
- StringBuffer sb = new StringBuffer(checksum.length * 2);
- for (int i = 0; i < checksum.length; i++) {
- sb.append(Integer.toHexString(checksum[i]));
- }
- return sb.toString();
- }
-
- private void writeWidgetPayloadIfAppropriate(FileDescriptor fd, String pkgName)
- throws IOException {
- // TODO: http://b/22388012
- byte[] widgetState = AppWidgetBackupBridge.getWidgetState(pkgName,
- UserHandle.USER_SYSTEM);
- // has the widget state changed since last time?
- final File widgetFile = new File(mStateDir, pkgName + "_widget");
- final boolean priorStateExists = widgetFile.exists();
-
- if (MORE_DEBUG) {
- if (priorStateExists || widgetState != null) {
- Slog.i(TAG, "Checking widget update: state=" + (widgetState != null)
- + " prior=" + priorStateExists);
- }
- }
-
- if (!priorStateExists && widgetState == null) {
- // no prior state, no new state => nothing to do
- return;
- }
-
- // if the new state is not null, we might need to compare checksums to
- // determine whether to update the widget blob in the archive. If the
- // widget state *is* null, we know a priori at this point that we simply
- // need to commit a deletion for it.
- String newChecksum = null;
- if (widgetState != null) {
- newChecksum = SHA1Checksum(widgetState);
- if (priorStateExists) {
- final String priorChecksum;
- try (
- FileInputStream fin = new FileInputStream(widgetFile);
- DataInputStream in = new DataInputStream(fin)
- ) {
- priorChecksum = in.readUTF();
- }
- if (Objects.equals(newChecksum, priorChecksum)) {
- // Same checksum => no state change => don't rewrite the widget data
- return;
- }
- }
- } // else widget state *became* empty, so we need to commit a deletion
-
- BackupDataOutput out = new BackupDataOutput(fd);
- if (widgetState != null) {
- try (
- FileOutputStream fout = new FileOutputStream(widgetFile);
- DataOutputStream stateOut = new DataOutputStream(fout)
- ) {
- stateOut.writeUTF(newChecksum);
- }
-
- out.writeEntityHeader(KEY_WIDGET_STATE, widgetState.length);
- out.writeEntityData(widgetState, widgetState.length);
- } else {
- // Widget state for this app has been removed; commit a deletion
- out.writeEntityHeader(KEY_WIDGET_STATE, -1);
- widgetFile.delete();
- }
- }
-
- @Override
- @GuardedBy("mCancelLock")
- public void operationComplete(long unusedResult) {
- removeOperation(mEphemeralOpToken);
- synchronized (mCancelLock) {
- // The agent reported back to us!
- if (mFinished) {
- Slog.d(TAG, "operationComplete received after task finished.");
- return;
- }
-
- if (mBackupData == null) {
- // This callback was racing with our timeout, so we've cleaned up the
- // agent state already and are on to the next thing. We have nothing
- // further to do here: agent state having been cleared means that we've
- // initiated the appropriate next operation.
- final String pkg = (mCurrentPackage != null)
- ? mCurrentPackage.packageName : "[none]";
- if (MORE_DEBUG) {
- Slog.i(TAG, "Callback after agent teardown: " + pkg);
- }
- addBackupTrace("late opComplete; curPkg = " + pkg);
- return;
- }
-
- final String pkgName = mCurrentPackage.packageName;
- final long filepos = mBackupDataName.length();
- FileDescriptor fd = mBackupData.getFileDescriptor();
- try {
- // If it's a 3rd party app, see whether they wrote any protected keys
- // and complain mightily if they are attempting shenanigans.
- if (mCurrentPackage.applicationInfo != null &&
- (mCurrentPackage.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
- == 0) {
- ParcelFileDescriptor readFd = ParcelFileDescriptor.open(mBackupDataName,
- ParcelFileDescriptor.MODE_READ_ONLY);
- BackupDataInput in = new BackupDataInput(readFd.getFileDescriptor());
- try {
- while (in.readNextHeader()) {
- final String key = in.getKey();
- if (key != null && key.charAt(0) >= 0xff00) {
- // Not okay: crash them and bail.
- failAgent(mAgentBinder, "Illegal backup key: " + key);
- addBackupTrace("illegal key " + key + " from " + pkgName);
- EventLog.writeEvent(EventLogTags.BACKUP_AGENT_FAILURE, pkgName,
- "bad key");
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_ILLEGAL_KEY,
- mCurrentPackage,
- BackupManagerMonitor
- .LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- putMonitoringExtra(null,
- BackupManagerMonitor.EXTRA_LOG_ILLEGAL_KEY,
- key));
- mBackupHandler.removeMessages(MSG_BACKUP_OPERATION_TIMEOUT);
- sendBackupOnPackageResult(mObserver, pkgName,
- BackupManager.ERROR_AGENT_FAILURE);
- errorCleanup();
- // agentErrorCleanup() implicitly executes next state properly
- return;
- }
- in.skipEntityData();
- }
- } finally {
- if (readFd != null) {
- readFd.close();
- }
- }
- }
-
- // Piggyback the widget state payload, if any
- writeWidgetPayloadIfAppropriate(fd, pkgName);
- } catch (IOException e) {
- // Hard disk error; recovery/failure policy TBD. For now roll back,
- // but we may want to consider this a transport-level failure (i.e.
- // we're in such a bad state that we can't contemplate doing backup
- // operations any more during this pass).
- Slog.w(TAG, "Unable to save widget state for " + pkgName);
- try {
- Os.ftruncate(fd, filepos);
- } catch (ErrnoException ee) {
- Slog.w(TAG, "Unable to roll back!");
- }
- }
-
- // Spin the data off to the transport and proceed with the next stage.
- if (MORE_DEBUG) Slog.v(TAG, "operationComplete(): sending data to transport for "
- + pkgName);
- mBackupHandler.removeMessages(MSG_BACKUP_OPERATION_TIMEOUT);
- clearAgentState();
- addBackupTrace("operation complete");
-
- ParcelFileDescriptor backupData = null;
- mStatus = BackupTransport.TRANSPORT_OK;
- long size = 0;
- try {
- size = mBackupDataName.length();
- if (size > 0) {
- if (mStatus == BackupTransport.TRANSPORT_OK) {
- backupData = ParcelFileDescriptor.open(mBackupDataName,
- ParcelFileDescriptor.MODE_READ_ONLY);
- addBackupTrace("sending data to transport");
- int flags = mUserInitiated ? BackupTransport.FLAG_USER_INITIATED : 0;
- mStatus = mTransport.performBackup(mCurrentPackage, backupData, flags);
- }
-
- // TODO - We call finishBackup() for each application backed up, because
- // we need to know now whether it succeeded or failed. Instead, we should
- // hold off on finishBackup() until the end, which implies holding off on
- // renaming *all* the output state files (see below) until that happens.
-
- addBackupTrace("data delivered: " + mStatus);
- if (mStatus == BackupTransport.TRANSPORT_OK) {
- addBackupTrace("finishing op on transport");
- mStatus = mTransport.finishBackup();
- addBackupTrace("finished: " + mStatus);
- } else if (mStatus == BackupTransport.TRANSPORT_PACKAGE_REJECTED) {
- addBackupTrace("transport rejected package");
- }
- } else {
- if (MORE_DEBUG) Slog.i(TAG,
- "no backup data written; not calling transport");
- addBackupTrace("no data to send");
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_NO_DATA_TO_SEND,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- }
-
- if (mStatus == BackupTransport.TRANSPORT_OK) {
- // After successful transport, delete the now-stale data
- // and juggle the files so that next time we supply the agent
- // with the new state file it just created.
- mBackupDataName.delete();
- mNewStateName.renameTo(mSavedStateName);
- sendBackupOnPackageResult(mObserver, pkgName, BackupManager.SUCCESS);
- EventLog.writeEvent(EventLogTags.BACKUP_PACKAGE, pkgName, size);
- logBackupComplete(pkgName);
- } else if (mStatus == BackupTransport.TRANSPORT_PACKAGE_REJECTED) {
- // The transport has rejected backup of this specific package. Roll it
- // back but proceed with running the rest of the queue.
- mBackupDataName.delete();
- mNewStateName.delete();
- sendBackupOnPackageResult(mObserver, pkgName,
- BackupManager.ERROR_TRANSPORT_PACKAGE_REJECTED);
- EventLogTags.writeBackupAgentFailure(pkgName, "Transport rejected");
- } else if (mStatus == BackupTransport.TRANSPORT_QUOTA_EXCEEDED) {
- sendBackupOnPackageResult(mObserver, pkgName,
- BackupManager.ERROR_TRANSPORT_QUOTA_EXCEEDED);
- EventLog.writeEvent(EventLogTags.BACKUP_QUOTA_EXCEEDED, pkgName);
- } else {
- // Actual transport-level failure to communicate the data to the backend
- sendBackupOnPackageResult(mObserver, pkgName,
- BackupManager.ERROR_TRANSPORT_ABORTED);
- EventLog.writeEvent(EventLogTags.BACKUP_TRANSPORT_FAILURE, pkgName);
- }
- } catch (Exception e) {
- sendBackupOnPackageResult(mObserver, pkgName,
- BackupManager.ERROR_TRANSPORT_ABORTED);
- Slog.e(TAG, "Transport error backing up " + pkgName, e);
- EventLog.writeEvent(EventLogTags.BACKUP_TRANSPORT_FAILURE, pkgName);
- mStatus = BackupTransport.TRANSPORT_ERROR;
- } finally {
- try {
- if (backupData != null) backupData.close();
- } catch (IOException e) {
- }
- }
-
- final BackupState nextState;
- if (mStatus == BackupTransport.TRANSPORT_OK
- || mStatus == BackupTransport.TRANSPORT_PACKAGE_REJECTED) {
- // Success or single-package rejection. Proceed with the next app if any,
- // otherwise we're done.
- nextState = (mQueue.isEmpty()) ? BackupState.FINAL : BackupState.RUNNING_QUEUE;
- } else if (mStatus == BackupTransport.TRANSPORT_QUOTA_EXCEEDED) {
- if (MORE_DEBUG) {
- Slog.d(TAG, "Package " + mCurrentPackage.packageName +
- " hit quota limit on k/v backup");
- }
- if (mAgentBinder != null) {
- try {
- long quota = mTransport.getBackupQuota(mCurrentPackage.packageName,
- false);
- mAgentBinder.doQuotaExceeded(size, quota);
- } catch (Exception e) {
- Slog.e(TAG, "Unable to notify about quota exceeded: " + e.getMessage());
- }
- }
- nextState = (mQueue.isEmpty()) ? BackupState.FINAL : BackupState.RUNNING_QUEUE;
- } else {
- // Any other error here indicates a transport-level failure. That means
- // we need to halt everything and reschedule everything for next time.
- revertAndEndBackup();
- nextState = BackupState.FINAL;
- }
-
- executeNextState(nextState);
- }
- }
-
-
- @Override
- @GuardedBy("mCancelLock")
- public void handleCancel(boolean cancelAll) {
- removeOperation(mEphemeralOpToken);
- synchronized (mCancelLock) {
- if (mFinished) {
- // We have already cancelled this operation.
- if (MORE_DEBUG) {
- Slog.d(TAG, "Ignoring stale cancel. cancelAll=" + cancelAll);
- }
- return;
- }
- mCancelAll = cancelAll;
- final String logPackageName = (mCurrentPackage != null)
- ? mCurrentPackage.packageName
- : "no_package_yet";
- Slog.i(TAG, "Cancel backing up " + logPackageName);
- EventLog.writeEvent(EventLogTags.BACKUP_AGENT_FAILURE, logPackageName);
- addBackupTrace("cancel of " + logPackageName + ", cancelAll=" + cancelAll);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_BACKUP_CANCEL,
- mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT,
- putMonitoringExtra(null, BackupManagerMonitor.EXTRA_LOG_CANCEL_ALL,
- mCancelAll));
- errorCleanup();
- if (!cancelAll) {
- // The current agent either timed out or was cancelled running doBackup().
- // Restage it for the next time we run a backup pass.
- // !!! TODO: keep track of failure counts per agent, and blacklist those which
- // fail repeatedly (i.e. have proved themselves to be buggy).
- executeNextState(
- mQueue.isEmpty() ? BackupState.FINAL : BackupState.RUNNING_QUEUE);
- dataChangedImpl(mCurrentPackage.packageName);
- } else {
- finalizeBackup();
- }
- }
- }
-
- void revertAndEndBackup() {
- if (MORE_DEBUG) Slog.i(TAG, "Reverting backup queue - restaging everything");
- addBackupTrace("transport error; reverting");
-
- // We want to reset the backup schedule based on whatever the transport suggests
- // by way of retry/backoff time.
- long delay;
- try {
- delay = mTransport.requestBackupTime();
- } catch (Exception e) {
- Slog.w(TAG, "Unable to contact transport for recommended backoff: " + e.getMessage());
- delay = 0; // use the scheduler's default
- }
- KeyValueBackupJob.schedule(mContext, delay, mConstants);
-
- for (BackupRequest request : mOriginalQueue) {
- dataChangedImpl(request.packageName);
- }
-
- }
-
- void errorCleanup() {
- mBackupDataName.delete();
- mNewStateName.delete();
- clearAgentState();
- }
-
- // Cleanup common to both success and failure cases
- void clearAgentState() {
- try { if (mSavedState != null) mSavedState.close(); } catch (IOException e) {}
- try { if (mBackupData != null) mBackupData.close(); } catch (IOException e) {}
- try { if (mNewState != null) mNewState.close(); } catch (IOException e) {}
- synchronized (mCurrentOpLock) {
- // Current-operation callback handling requires the validity of these various
- // bits of internal state as an invariant of the operation still being live.
- // This means we make sure to clear all of the state in unison inside the lock.
- mCurrentOperations.remove(mEphemeralOpToken);
- mSavedState = mBackupData = mNewState = null;
- }
-
- // If this was a pseudopackage there's no associated Activity Manager state
- if (mCurrentPackage.applicationInfo != null) {
- addBackupTrace("unbinding " + mCurrentPackage.packageName);
- try { // unbind even on timeout, just in case
- mActivityManager.unbindBackupAgent(mCurrentPackage.applicationInfo);
- } catch (RemoteException e) { /* can't happen; activity manager is local */ }
- }
- }
-
- void executeNextState(BackupState nextState) {
- if (MORE_DEBUG) Slog.i(TAG, " => executing next step on "
- + this + " nextState=" + nextState);
- addBackupTrace("executeNextState => " + nextState);
- mCurrentState = nextState;
- Message msg = mBackupHandler.obtainMessage(MSG_BACKUP_RESTORE_STEP, this);
- mBackupHandler.sendMessage(msg);
- }
- }
-
- private boolean isBackupOperationInProgress() {
- synchronized (mCurrentOpLock) {
- for (int i = 0; i < mCurrentOperations.size(); i++) {
- Operation op = mCurrentOperations.valueAt(i);
- if (op.type == OP_TYPE_BACKUP && op.state == OP_PENDING) {
- return true;
- }
- }
- }
- return false;
- }
-
-
- // ----- Full backup/restore to a file/socket -----
-
- class FullBackupObbConnection implements ServiceConnection {
- volatile IObbBackupService mService;
-
- FullBackupObbConnection() {
- mService = null;
- }
-
- public void establish() {
- if (MORE_DEBUG) Slog.i(TAG, "Initiating bind of OBB service on " + this);
- Intent obbIntent = new Intent().setComponent(new ComponentName(
- "com.android.sharedstoragebackup",
- "com.android.sharedstoragebackup.ObbBackupService"));
- BackupManagerService.this.mContext.bindServiceAsUser(
- obbIntent, this, Context.BIND_AUTO_CREATE, UserHandle.SYSTEM);
- }
-
- public void tearDown() {
- BackupManagerService.this.mContext.unbindService(this);
- }
-
- public boolean backupObbs(PackageInfo pkg, OutputStream out) {
- boolean success = false;
- waitForConnection();
-
- ParcelFileDescriptor[] pipes = null;
- try {
- pipes = ParcelFileDescriptor.createPipe();
- int token = generateRandomIntegerToken();
- prepareOperationTimeout(token, TIMEOUT_FULL_BACKUP_INTERVAL,
- null, OP_TYPE_BACKUP_WAIT);
- mService.backupObbs(pkg.packageName, pipes[1], token, mBackupManagerBinder);
- routeSocketDataToOutput(pipes[0], out);
- success = waitUntilOperationComplete(token);
- } catch (Exception e) {
- Slog.w(TAG, "Unable to back up OBBs for " + pkg, e);
- } finally {
- try {
- out.flush();
- if (pipes != null) {
- if (pipes[0] != null) pipes[0].close();
- if (pipes[1] != null) pipes[1].close();
- }
- } catch (IOException e) {
- Slog.w(TAG, "I/O error closing down OBB backup", e);
- }
- }
- return success;
- }
-
- public void restoreObbFile(String pkgName, ParcelFileDescriptor data,
- long fileSize, int type, String path, long mode, long mtime,
- int token, IBackupManager callbackBinder) {
- waitForConnection();
-
- try {
- mService.restoreObbFile(pkgName, data, fileSize, type, path, mode, mtime,
- token, callbackBinder);
- } catch (Exception e) {
- Slog.w(TAG, "Unable to restore OBBs for " + pkgName, e);
- }
- }
-
- private void waitForConnection() {
- synchronized (this) {
- while (mService == null) {
- if (MORE_DEBUG) Slog.i(TAG, "...waiting for OBB service binding...");
- try {
- this.wait();
- } catch (InterruptedException e) { /* never interrupted */ }
- }
- if (MORE_DEBUG) Slog.i(TAG, "Connected to OBB service; continuing");
- }
- }
-
- @Override
- public void onServiceConnected(ComponentName name, IBinder service) {
- synchronized (this) {
- mService = IObbBackupService.Stub.asInterface(service);
- if (MORE_DEBUG) Slog.i(TAG, "OBB service connection " + mService
- + " connected on " + this);
- this.notifyAll();
- }
- }
-
- @Override
- public void onServiceDisconnected(ComponentName name) {
- synchronized (this) {
- mService = null;
- if (MORE_DEBUG) Slog.i(TAG, "OBB service connection disconnected on " + this);
- this.notifyAll();
- }
- }
-
- }
-
- static void routeSocketDataToOutput(ParcelFileDescriptor inPipe, OutputStream out)
- throws IOException {
- // We do not take close() responsibility for the pipe FD
- FileInputStream raw = new FileInputStream(inPipe.getFileDescriptor());
- DataInputStream in = new DataInputStream(raw);
-
- byte[] buffer = new byte[32 * 1024];
- int chunkTotal;
- while ((chunkTotal = in.readInt()) > 0) {
- while (chunkTotal > 0) {
- int toRead = (chunkTotal > buffer.length) ? buffer.length : chunkTotal;
- int nRead = in.read(buffer, 0, toRead);
- out.write(buffer, 0, nRead);
- chunkTotal -= nRead;
- }
- }
- }
-
- @Override
- public void tearDownAgentAndKill(ApplicationInfo app) {
- if (app == null) {
- // Null means the system package, so just quietly move on. :)
- return;
- }
-
- try {
- // unbind and tidy up even on timeout or failure, just in case
- mActivityManager.unbindBackupAgent(app);
-
- // The agent was running with a stub Application object, so shut it down.
- // !!! We hardcode the confirmation UI's package name here rather than use a
- // manifest flag! TODO something less direct.
- if (app.uid >= Process.FIRST_APPLICATION_UID
- && !app.packageName.equals("com.android.backupconfirm")) {
- if (MORE_DEBUG) Slog.d(TAG, "Killing agent host process");
- mActivityManager.killApplicationProcess(app.processName, app.uid);
- } else {
- if (MORE_DEBUG) Slog.d(TAG, "Not killing after operation: " + app.processName);
- }
- } catch (RemoteException e) {
- Slog.d(TAG, "Lost app trying to shut down");
- }
- }
-
- // Core logic for performing one package's full backup, gathering the tarball from the
- // application and emitting it to the designated OutputStream.
-
- // Callout from the engine to an interested participant that might need to communicate
- // with the agent prior to asking it to move data
- interface FullBackupPreflight {
- /**
- * Perform the preflight operation necessary for the given package.
- * @param pkg The name of the package being proposed for full-data backup
- * @param agent Live BackupAgent binding to the target app's agent
- * @return BackupTransport.TRANSPORT_OK to proceed with the backup operation,
- * or one of the other BackupTransport.* error codes as appropriate
- */
- int preflightFullBackup(PackageInfo pkg, IBackupAgent agent);
-
- long getExpectedSizeOrErrorCode();
- };
-
- class FullBackupEngine {
- OutputStream mOutput;
- FullBackupPreflight mPreflightHook;
- BackupRestoreTask mTimeoutMonitor;
- IBackupAgent mAgent;
- File mFilesDir;
- File mManifestFile;
- File mMetadataFile;
- boolean mIncludeApks;
- PackageInfo mPkg;
- private final long mQuota;
- private final int mOpToken;
-
- class FullBackupRunner implements Runnable {
- PackageInfo mPackage;
- byte[] mWidgetData;
- IBackupAgent mAgent;
- ParcelFileDescriptor mPipe;
- int mToken;
- boolean mSendApk;
- boolean mWriteManifest;
-
- FullBackupRunner(PackageInfo pack, IBackupAgent agent, ParcelFileDescriptor pipe,
- int token, boolean sendApk, boolean writeManifest, byte[] widgetData)
- throws IOException {
- mPackage = pack;
- mWidgetData = widgetData;
- mAgent = agent;
- mPipe = ParcelFileDescriptor.dup(pipe.getFileDescriptor());
- mToken = token;
- mSendApk = sendApk;
- mWriteManifest = writeManifest;
- }
-
- @Override
- public void run() {
- try {
- FullBackupDataOutput output = new FullBackupDataOutput(mPipe);
-
- if (mWriteManifest) {
- final boolean writeWidgetData = mWidgetData != null;
- if (MORE_DEBUG) Slog.d(TAG, "Writing manifest for " + mPackage.packageName);
- writeAppManifest(mPackage, mPackageManager, mManifestFile, mSendApk, writeWidgetData);
- FullBackup.backupToTar(mPackage.packageName, null, null,
- mFilesDir.getAbsolutePath(),
- mManifestFile.getAbsolutePath(),
- output);
- mManifestFile.delete();
-
- // We only need to write a metadata file if we have widget data to stash
- if (writeWidgetData) {
- writeMetadata(mPackage, mMetadataFile, mWidgetData);
- FullBackup.backupToTar(mPackage.packageName, null, null,
- mFilesDir.getAbsolutePath(),
- mMetadataFile.getAbsolutePath(),
- output);
- mMetadataFile.delete();
- }
- }
-
- if (mSendApk) {
- writeApkToBackup(mPackage, output);
- }
-
- final boolean isSharedStorage =
- mPackage.packageName.equals(SHARED_BACKUP_AGENT_PACKAGE);
- final long timeout = isSharedStorage ?
- TIMEOUT_SHARED_BACKUP_INTERVAL : TIMEOUT_FULL_BACKUP_INTERVAL;
-
- if (DEBUG) Slog.d(TAG, "Calling doFullBackup() on " + mPackage.packageName);
- prepareOperationTimeout(mToken, timeout, mTimeoutMonitor /* in parent class */,
- OP_TYPE_BACKUP_WAIT);
- mAgent.doFullBackup(mPipe, mQuota, mToken, mBackupManagerBinder);
- } catch (IOException e) {
- Slog.e(TAG, "Error running full backup for " + mPackage.packageName);
- } catch (RemoteException e) {
- Slog.e(TAG, "Remote agent vanished during full backup of "
- + mPackage.packageName);
- } finally {
- try {
- mPipe.close();
- } catch (IOException e) {}
- }
- }
- }
-
- FullBackupEngine(OutputStream output, FullBackupPreflight preflightHook, PackageInfo pkg,
- boolean alsoApks, BackupRestoreTask timeoutMonitor, long quota, int opToken) {
- mOutput = output;
- mPreflightHook = preflightHook;
- mPkg = pkg;
- mIncludeApks = alsoApks;
- mTimeoutMonitor = timeoutMonitor;
- mFilesDir = new File("/data/system");
- mManifestFile = new File(mFilesDir, BACKUP_MANIFEST_FILENAME);
- mMetadataFile = new File(mFilesDir, BACKUP_METADATA_FILENAME);
- mQuota = quota;
- mOpToken = opToken;
- }
-
- public int preflightCheck() throws RemoteException {
- if (mPreflightHook == null) {
- if (MORE_DEBUG) {
- Slog.v(TAG, "No preflight check");
- }
- return BackupTransport.TRANSPORT_OK;
- }
- if (initializeAgent()) {
- int result = mPreflightHook.preflightFullBackup(mPkg, mAgent);
- if (MORE_DEBUG) {
- Slog.v(TAG, "preflight returned " + result);
- }
- return result;
- } else {
- Slog.w(TAG, "Unable to bind to full agent for " + mPkg.packageName);
- return BackupTransport.AGENT_ERROR;
- }
- }
-
- public int backupOnePackage() throws RemoteException {
- int result = BackupTransport.AGENT_ERROR;
-
- if (initializeAgent()) {
- ParcelFileDescriptor[] pipes = null;
- try {
- pipes = ParcelFileDescriptor.createPipe();
-
- ApplicationInfo app = mPkg.applicationInfo;
- final boolean isSharedStorage =
- mPkg.packageName.equals(SHARED_BACKUP_AGENT_PACKAGE);
- final boolean sendApk = mIncludeApks
- && !isSharedStorage
- && ((app.privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) == 0)
- && ((app.flags & ApplicationInfo.FLAG_SYSTEM) == 0 ||
- (app.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0);
-
- // TODO: http://b/22388012
- byte[] widgetBlob = AppWidgetBackupBridge.getWidgetState(mPkg.packageName,
- UserHandle.USER_SYSTEM);
-
- FullBackupRunner runner = new FullBackupRunner(mPkg, mAgent, pipes[1],
- mOpToken, sendApk, !isSharedStorage, widgetBlob);
- pipes[1].close(); // the runner has dup'd it
- pipes[1] = null;
- Thread t = new Thread(runner, "app-data-runner");
- t.start();
-
- // Now pull data from the app and stuff it into the output
- routeSocketDataToOutput(pipes[0], mOutput);
-
- if (!waitUntilOperationComplete(mOpToken)) {
- Slog.e(TAG, "Full backup failed on package " + mPkg.packageName);
- } else {
- if (MORE_DEBUG) {
- Slog.d(TAG, "Full package backup success: " + mPkg.packageName);
- }
- result = BackupTransport.TRANSPORT_OK;
- }
- } catch (IOException e) {
- Slog.e(TAG, "Error backing up " + mPkg.packageName + ": " + e.getMessage());
- result = BackupTransport.AGENT_ERROR;
- } finally {
- try {
- // flush after every package
- mOutput.flush();
- if (pipes != null) {
- if (pipes[0] != null) pipes[0].close();
- if (pipes[1] != null) pipes[1].close();
- }
- } catch (IOException e) {
- Slog.w(TAG, "Error bringing down backup stack");
- result = BackupTransport.TRANSPORT_ERROR;
- }
- }
- } else {
- Slog.w(TAG, "Unable to bind to full agent for " + mPkg.packageName);
- }
- tearDown();
- return result;
- }
-
- public void sendQuotaExceeded(final long backupDataBytes, final long quotaBytes) {
- if (initializeAgent()) {
- try {
- mAgent.doQuotaExceeded(backupDataBytes, quotaBytes);
- } catch (RemoteException e) {
- Slog.e(TAG, "Remote exception while telling agent about quota exceeded");
- }
- }
- }
-
- private boolean initializeAgent() {
- if (mAgent == null) {
- if (MORE_DEBUG) {
- Slog.d(TAG, "Binding to full backup agent : " + mPkg.packageName);
- }
- mAgent = bindToAgentSynchronous(mPkg.applicationInfo,
- ApplicationThreadConstants.BACKUP_MODE_FULL);
- }
- return mAgent != null;
- }
-
- private void writeApkToBackup(PackageInfo pkg, FullBackupDataOutput output) {
- // Forward-locked apps, system-bundled .apks, etc are filtered out before we get here
- // TODO: handle backing up split APKs
- final String appSourceDir = pkg.applicationInfo.getBaseCodePath();
- final String apkDir = new File(appSourceDir).getParent();
- FullBackup.backupToTar(pkg.packageName, FullBackup.APK_TREE_TOKEN, null,
- apkDir, appSourceDir, output);
-
- // TODO: migrate this to SharedStorageBackup, since AID_SYSTEM
- // doesn't have access to external storage.
-
- // Save associated .obb content if it exists and we did save the apk
- // check for .obb and save those too
- // TODO: http://b/22388012
- final UserEnvironment userEnv = new UserEnvironment(UserHandle.USER_SYSTEM);
- final File obbDir = userEnv.buildExternalStorageAppObbDirs(pkg.packageName)[0];
- if (obbDir != null) {
- if (MORE_DEBUG) Log.i(TAG, "obb dir: " + obbDir.getAbsolutePath());
- File[] obbFiles = obbDir.listFiles();
- if (obbFiles != null) {
- final String obbDirName = obbDir.getAbsolutePath();
- for (File obb : obbFiles) {
- FullBackup.backupToTar(pkg.packageName, FullBackup.OBB_TREE_TOKEN, null,
- obbDirName, obb.getAbsolutePath(), output);
- }
- }
- }
- }
-
- // Widget metadata format. All header entries are strings ending in LF:
- //
- // Version 1 header:
- // BACKUP_METADATA_VERSION, currently "1"
- // package name
- //
- // File data (all integers are binary in network byte order)
- // *N: 4 : integer token identifying which metadata blob
- // 4 : integer size of this blob = N
- // N : raw bytes of this metadata blob
- //
- // Currently understood blobs (always in network byte order):
- //
- // widgets : metadata token = 0x01FFED01 (BACKUP_WIDGET_METADATA_TOKEN)
- //
- // Unrecognized blobs are *ignored*, not errors.
- private void writeMetadata(PackageInfo pkg, File destination, byte[] widgetData)
- throws IOException {
- StringBuilder b = new StringBuilder(512);
- StringBuilderPrinter printer = new StringBuilderPrinter(b);
- printer.println(Integer.toString(BACKUP_METADATA_VERSION));
- printer.println(pkg.packageName);
-
- FileOutputStream fout = new FileOutputStream(destination);
- BufferedOutputStream bout = new BufferedOutputStream(fout);
- DataOutputStream out = new DataOutputStream(bout);
- bout.write(b.toString().getBytes()); // bypassing DataOutputStream
-
- if (widgetData != null && widgetData.length > 0) {
- out.writeInt(BACKUP_WIDGET_METADATA_TOKEN);
- out.writeInt(widgetData.length);
- out.write(widgetData);
- }
- bout.flush();
- out.close();
-
- // As with the manifest file, guarantee idempotence of the archive metadata
- // for the widget block by using a fixed mtime on the transient file.
- destination.setLastModified(0);
- }
-
- private void tearDown() {
- if (mPkg != null) {
- tearDownAgentAndKill(mPkg.applicationInfo);
- }
- }
- }
-
- static void writeAppManifest(PackageInfo pkg, PackageManager packageManager, File manifestFile,
- boolean withApk, boolean withWidgets) throws IOException {
- // Manifest format. All data are strings ending in LF:
- // BACKUP_MANIFEST_VERSION, currently 1
- //
- // Version 1:
- // package name
- // package's versionCode
- // platform versionCode
- // getInstallerPackageName() for this package (maybe empty)
- // boolean: "1" if archive includes .apk; any other string means not
- // number of signatures == N
- // N*: signature byte array in ascii format per Signature.toCharsString()
- StringBuilder builder = new StringBuilder(4096);
- StringBuilderPrinter printer = new StringBuilderPrinter(builder);
-
- printer.println(Integer.toString(BACKUP_MANIFEST_VERSION));
- printer.println(pkg.packageName);
- printer.println(Integer.toString(pkg.versionCode));
- printer.println(Integer.toString(Build.VERSION.SDK_INT));
-
- String installerName = packageManager.getInstallerPackageName(pkg.packageName);
- printer.println((installerName != null) ? installerName : "");
-
- printer.println(withApk ? "1" : "0");
- if (pkg.signatures == null) {
- printer.println("0");
- } else {
- printer.println(Integer.toString(pkg.signatures.length));
- for (Signature sig : pkg.signatures) {
- printer.println(sig.toCharsString());
- }
- }
-
- FileOutputStream outstream = new FileOutputStream(manifestFile);
- outstream.write(builder.toString().getBytes());
- outstream.close();
-
- // We want the manifest block in the archive stream to be idempotent:
- // each time we generate a backup stream for the app, we want the manifest
- // block to be identical. The underlying tar mechanism sees it as a file,
- // though, and will propagate its mtime, causing the tar header to vary.
- // Avoid this problem by pinning the mtime to zero.
- manifestFile.setLastModified(0);
- }
-
- // Generic driver skeleton for full backup operations
- abstract class FullBackupTask implements Runnable {
- IFullBackupRestoreObserver mObserver;
-
- FullBackupTask(IFullBackupRestoreObserver observer) {
- mObserver = observer;
- }
-
- // wrappers for observer use
- final void sendStartBackup() {
- if (mObserver != null) {
- try {
- mObserver.onStartBackup();
- } catch (RemoteException e) {
- Slog.w(TAG, "full backup observer went away: startBackup");
- mObserver = null;
- }
- }
- }
-
- final void sendOnBackupPackage(String name) {
- if (mObserver != null) {
- try {
- // TODO: use a more user-friendly name string
- mObserver.onBackupPackage(name);
- } catch (RemoteException e) {
- Slog.w(TAG, "full backup observer went away: backupPackage");
- mObserver = null;
- }
- }
- }
-
- final void sendEndBackup() {
- if (mObserver != null) {
- try {
- mObserver.onEndBackup();
- } catch (RemoteException e) {
- Slog.w(TAG, "full backup observer went away: endBackup");
- mObserver = null;
- }
- }
- }
- }
-
- boolean deviceIsEncrypted() {
- try {
- return mStorageManager.getEncryptionState()
- != StorageManager.ENCRYPTION_STATE_NONE
- && mStorageManager.getPasswordType()
- != StorageManager.CRYPT_TYPE_DEFAULT;
- } catch (Exception e) {
- // If we can't talk to the storagemanager service we have a serious problem; fail
- // "secure" i.e. assuming that the device is encrypted.
- Slog.e(TAG, "Unable to communicate with storagemanager service: " + e.getMessage());
- return true;
- }
- }
-
- // Full backup task variant used for adb backup
- class PerformAdbBackupTask extends FullBackupTask implements BackupRestoreTask {
- FullBackupEngine mBackupEngine;
- final AtomicBoolean mLatch;
-
- ParcelFileDescriptor mOutputFile;
- DeflaterOutputStream mDeflater;
- boolean mIncludeApks;
- boolean mIncludeObbs;
- boolean mIncludeShared;
- boolean mDoWidgets;
- boolean mAllApps;
- boolean mIncludeSystem;
- boolean mCompress;
- boolean mKeyValue;
- ArrayList<String> mPackages;
- PackageInfo mCurrentTarget;
- String mCurrentPassword;
- String mEncryptPassword;
- private final int mCurrentOpToken;
-
- PerformAdbBackupTask(ParcelFileDescriptor fd, IFullBackupRestoreObserver observer,
- boolean includeApks, boolean includeObbs, boolean includeShared, boolean doWidgets,
- String curPassword, String encryptPassword, boolean doAllApps, boolean doSystem,
- boolean doCompress, boolean doKeyValue, String[] packages, AtomicBoolean latch) {
- super(observer);
- mCurrentOpToken = generateRandomIntegerToken();
- mLatch = latch;
-
- mOutputFile = fd;
- mIncludeApks = includeApks;
- mIncludeObbs = includeObbs;
- mIncludeShared = includeShared;
- mDoWidgets = doWidgets;
- mAllApps = doAllApps;
- mIncludeSystem = doSystem;
- mPackages = (packages == null)
- ? new ArrayList<String>()
- : new ArrayList<String>(Arrays.asList(packages));
- mCurrentPassword = curPassword;
- // when backing up, if there is a current backup password, we require that
- // the user use a nonempty encryption password as well. if one is supplied
- // in the UI we use that, but if the UI was left empty we fall back to the
- // current backup password (which was supplied by the user as well).
- if (encryptPassword == null || "".equals(encryptPassword)) {
- mEncryptPassword = curPassword;
- } else {
- mEncryptPassword = encryptPassword;
- }
- if (MORE_DEBUG) {
- Slog.w(TAG, "Encrypting backup with passphrase=" + mEncryptPassword);
- }
- mCompress = doCompress;
- mKeyValue = doKeyValue;
- }
-
- void addPackagesToSet(TreeMap<String, PackageInfo> set, List<String> pkgNames) {
- for (String pkgName : pkgNames) {
- if (!set.containsKey(pkgName)) {
- try {
- PackageInfo info = mPackageManager.getPackageInfo(pkgName,
- PackageManager.GET_SIGNATURES);
- set.put(pkgName, info);
- } catch (NameNotFoundException e) {
- Slog.w(TAG, "Unknown package " + pkgName + ", skipping");
- }
- }
- }
- }
-
- private OutputStream emitAesBackupHeader(StringBuilder headerbuf,
- OutputStream ofstream) throws Exception {
- // User key will be used to encrypt the master key.
- byte[] newUserSalt = randomBytes(PBKDF2_SALT_SIZE);
- SecretKey userKey = buildPasswordKey(PBKDF_CURRENT, mEncryptPassword, newUserSalt,
- PBKDF2_HASH_ROUNDS);
-
- // the master key is random for each backup
- byte[] masterPw = new byte[256 / 8];
- mRng.nextBytes(masterPw);
- byte[] checksumSalt = randomBytes(PBKDF2_SALT_SIZE);
-
- // primary encryption of the datastream with the random key
- Cipher c = Cipher.getInstance("AES/CBC/PKCS5Padding");
- SecretKeySpec masterKeySpec = new SecretKeySpec(masterPw, "AES");
- c.init(Cipher.ENCRYPT_MODE, masterKeySpec);
- OutputStream finalOutput = new CipherOutputStream(ofstream, c);
-
- // line 4: name of encryption algorithm
- headerbuf.append(ENCRYPTION_ALGORITHM_NAME);
- headerbuf.append('\n');
- // line 5: user password salt [hex]
- headerbuf.append(byteArrayToHex(newUserSalt));
- headerbuf.append('\n');
- // line 6: master key checksum salt [hex]
- headerbuf.append(byteArrayToHex(checksumSalt));
- headerbuf.append('\n');
- // line 7: number of PBKDF2 rounds used [decimal]
- headerbuf.append(PBKDF2_HASH_ROUNDS);
- headerbuf.append('\n');
-
- // line 8: IV of the user key [hex]
- Cipher mkC = Cipher.getInstance("AES/CBC/PKCS5Padding");
- mkC.init(Cipher.ENCRYPT_MODE, userKey);
-
- byte[] IV = mkC.getIV();
- headerbuf.append(byteArrayToHex(IV));
- headerbuf.append('\n');
-
- // line 9: master IV + key blob, encrypted by the user key [hex]. Blob format:
- // [byte] IV length = Niv
- // [array of Niv bytes] IV itself
- // [byte] master key length = Nmk
- // [array of Nmk bytes] master key itself
- // [byte] MK checksum hash length = Nck
- // [array of Nck bytes] master key checksum hash
- //
- // The checksum is the (master key + checksum salt), run through the
- // stated number of PBKDF2 rounds
- IV = c.getIV();
- byte[] mk = masterKeySpec.getEncoded();
- byte[] checksum = makeKeyChecksum(PBKDF_CURRENT, masterKeySpec.getEncoded(),
- checksumSalt, PBKDF2_HASH_ROUNDS);
-
- ByteArrayOutputStream blob = new ByteArrayOutputStream(IV.length + mk.length
- + checksum.length + 3);
- DataOutputStream mkOut = new DataOutputStream(blob);
- mkOut.writeByte(IV.length);
- mkOut.write(IV);
- mkOut.writeByte(mk.length);
- mkOut.write(mk);
- mkOut.writeByte(checksum.length);
- mkOut.write(checksum);
- mkOut.flush();
- byte[] encryptedMk = mkC.doFinal(blob.toByteArray());
- headerbuf.append(byteArrayToHex(encryptedMk));
- headerbuf.append('\n');
-
- return finalOutput;
- }
-
- private void finalizeBackup(OutputStream out) {
- try {
- // A standard 'tar' EOF sequence: two 512-byte blocks of all zeroes.
- byte[] eof = new byte[512 * 2]; // newly allocated == zero filled
- out.write(eof);
- } catch (IOException e) {
- Slog.w(TAG, "Error attempting to finalize backup stream");
- }
- }
-
- @Override
- public void run() {
- String includeKeyValue = mKeyValue ? ", including key-value backups" : "";
- Slog.i(TAG, "--- Performing adb backup" + includeKeyValue + " ---");
-
- TreeMap<String, PackageInfo> packagesToBackup = new TreeMap<String, PackageInfo>();
- FullBackupObbConnection obbConnection = new FullBackupObbConnection();
- obbConnection.establish(); // we'll want this later
-
- sendStartBackup();
-
- // doAllApps supersedes the package set if any
- if (mAllApps) {
- List<PackageInfo> allPackages = mPackageManager.getInstalledPackages(
- PackageManager.GET_SIGNATURES);
- for (int i = 0; i < allPackages.size(); i++) {
- PackageInfo pkg = allPackages.get(i);
- // Exclude system apps if we've been asked to do so
- if (mIncludeSystem == true
- || ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0)) {
- packagesToBackup.put(pkg.packageName, pkg);
- }
- }
- }
-
- // If we're doing widget state as well, ensure that we have all the involved
- // host & provider packages in the set
- if (mDoWidgets) {
- // TODO: http://b/22388012
- List<String> pkgs =
- AppWidgetBackupBridge.getWidgetParticipants(UserHandle.USER_SYSTEM);
- if (pkgs != null) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Adding widget participants to backup set:");
- StringBuilder sb = new StringBuilder(128);
- sb.append(" ");
- for (String s : pkgs) {
- sb.append(' ');
- sb.append(s);
- }
- Slog.i(TAG, sb.toString());
- }
- addPackagesToSet(packagesToBackup, pkgs);
- }
- }
-
- // Now process the command line argument packages, if any. Note that explicitly-
- // named system-partition packages will be included even if includeSystem was
- // set to false.
- if (mPackages != null) {
- addPackagesToSet(packagesToBackup, mPackages);
- }
-
- // Now we cull any inapplicable / inappropriate packages from the set. This
- // includes the special shared-storage agent package; we handle that one
- // explicitly at the end of the backup pass. Packages supporting key-value backup are
- // added to their own queue, and handled after packages supporting fullbackup.
- ArrayList<PackageInfo> keyValueBackupQueue = new ArrayList<>();
- Iterator<Entry<String, PackageInfo>> iter = packagesToBackup.entrySet().iterator();
- while (iter.hasNext()) {
- PackageInfo pkg = iter.next().getValue();
- if (!appIsEligibleForBackup(pkg.applicationInfo, mPackageManager)
- || appIsStopped(pkg.applicationInfo)) {
- iter.remove();
- if (DEBUG) {
- Slog.i(TAG, "Package " + pkg.packageName
- + " is not eligible for backup, removing.");
- }
- } else if (appIsKeyValueOnly(pkg)) {
- iter.remove();
- if (DEBUG) {
- Slog.i(TAG, "Package " + pkg.packageName
- + " is key-value.");
- }
- keyValueBackupQueue.add(pkg);
- }
- }
-
- // flatten the set of packages now so we can explicitly control the ordering
- ArrayList<PackageInfo> backupQueue =
- new ArrayList<PackageInfo>(packagesToBackup.values());
- FileOutputStream ofstream = new FileOutputStream(mOutputFile.getFileDescriptor());
- OutputStream out = null;
-
- PackageInfo pkg = null;
- try {
- boolean encrypting = (mEncryptPassword != null && mEncryptPassword.length() > 0);
-
- // Only allow encrypted backups of encrypted devices
- if (deviceIsEncrypted() && !encrypting) {
- Slog.e(TAG, "Unencrypted backup of encrypted device; aborting");
- return;
- }
-
- OutputStream finalOutput = ofstream;
-
- // Verify that the given password matches the currently-active
- // backup password, if any
- if (!backupPasswordMatches(mCurrentPassword)) {
- if (DEBUG) Slog.w(TAG, "Backup password mismatch; aborting");
- return;
- }
-
- // Write the global file header. All strings are UTF-8 encoded; lines end
- // with a '\n' byte. Actual backup data begins immediately following the
- // final '\n'.
- //
- // line 1: "ANDROID BACKUP"
- // line 2: backup file format version, currently "5"
- // line 3: compressed? "0" if not compressed, "1" if compressed.
- // line 4: name of encryption algorithm [currently only "none" or "AES-256"]
- //
- // When line 4 is not "none", then additional header data follows:
- //
- // line 5: user password salt [hex]
- // line 6: master key checksum salt [hex]
- // line 7: number of PBKDF2 rounds to use (same for user & master) [decimal]
- // line 8: IV of the user key [hex]
- // line 9: master key blob [hex]
- // IV of the master key, master key itself, master key checksum hash
- //
- // The master key checksum is the master key plus its checksum salt, run through
- // 10k rounds of PBKDF2. This is used to verify that the user has supplied the
- // correct password for decrypting the archive: the master key decrypted from
- // the archive using the user-supplied password is also run through PBKDF2 in
- // this way, and if the result does not match the checksum as stored in the
- // archive, then we know that the user-supplied password does not match the
- // archive's.
- StringBuilder headerbuf = new StringBuilder(1024);
-
- headerbuf.append(BACKUP_FILE_HEADER_MAGIC);
- headerbuf.append(BACKUP_FILE_VERSION); // integer, no trailing \n
- headerbuf.append(mCompress ? "\n1\n" : "\n0\n");
-
- try {
- // Set up the encryption stage if appropriate, and emit the correct header
- if (encrypting) {
- finalOutput = emitAesBackupHeader(headerbuf, finalOutput);
- } else {
- headerbuf.append("none\n");
- }
-
- byte[] header = headerbuf.toString().getBytes("UTF-8");
- ofstream.write(header);
-
- // Set up the compression stage feeding into the encryption stage (if any)
- if (mCompress) {
- Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION);
- finalOutput = new DeflaterOutputStream(finalOutput, deflater, true);
- }
-
- out = finalOutput;
- } catch (Exception e) {
- // Should never happen!
- Slog.e(TAG, "Unable to emit archive header", e);
- return;
- }
-
- // Shared storage if requested
- if (mIncludeShared) {
- try {
- pkg = mPackageManager.getPackageInfo(SHARED_BACKUP_AGENT_PACKAGE, 0);
- backupQueue.add(pkg);
- } catch (NameNotFoundException e) {
- Slog.e(TAG, "Unable to find shared-storage backup handler");
- }
- }
-
- // Now actually run the constructed backup sequence for full backup
- int N = backupQueue.size();
- for (int i = 0; i < N; i++) {
- pkg = backupQueue.get(i);
- if (DEBUG) {
- Slog.i(TAG,"--- Performing full backup for package " + pkg.packageName
- + " ---");
- }
- final boolean isSharedStorage =
- pkg.packageName.equals(SHARED_BACKUP_AGENT_PACKAGE);
-
- mBackupEngine = new FullBackupEngine(out, null, pkg, mIncludeApks, this, Long.MAX_VALUE, mCurrentOpToken);
- sendOnBackupPackage(isSharedStorage ? "Shared storage" : pkg.packageName);
-
- // Don't need to check preflight result as there is no preflight hook.
- mCurrentTarget = pkg;
- mBackupEngine.backupOnePackage();
-
- // after the app's agent runs to handle its private filesystem
- // contents, back up any OBB content it has on its behalf.
- if (mIncludeObbs) {
- boolean obbOkay = obbConnection.backupObbs(pkg, out);
- if (!obbOkay) {
- throw new RuntimeException("Failure writing OBB stack for " + pkg);
- }
- }
- }
- // And for key-value backup if enabled
- if (mKeyValue) {
- for (PackageInfo keyValuePackage : keyValueBackupQueue) {
- if (DEBUG) {
- Slog.i(TAG, "--- Performing key-value backup for package "
- + keyValuePackage.packageName + " ---");
- }
- KeyValueAdbBackupEngine kvBackupEngine =
- new KeyValueAdbBackupEngine(out, keyValuePackage,
- BackupManagerService.this,
- mPackageManager, mBaseStateDir, mDataDir);
- sendOnBackupPackage(keyValuePackage.packageName);
- kvBackupEngine.backupOnePackage();
- }
- }
-
- // Done!
- finalizeBackup(out);
- } catch (RemoteException e) {
- Slog.e(TAG, "App died during full backup");
- } catch (Exception e) {
- Slog.e(TAG, "Internal exception during full backup", e);
- } finally {
- try {
- if (out != null) {
- out.flush();
- out.close();
- }
- mOutputFile.close();
- } catch (IOException e) {
- Slog.e(TAG, "IO error closing adb backup file: " + e.getMessage());
- }
- synchronized (mLatch) {
- mLatch.set(true);
- mLatch.notifyAll();
- }
- sendEndBackup();
- obbConnection.tearDown();
- if (DEBUG) Slog.d(TAG, "Full backup pass complete.");
- mWakelock.release();
- }
- }
-
- // BackupRestoreTask methods, used for timeout handling
- @Override
- public void execute() {
- // Unused
- }
-
- @Override
- public void operationComplete(long result) {
- // Unused
- }
-
- @Override
- public void handleCancel(boolean cancelAll) {
- final PackageInfo target = mCurrentTarget;
- if (DEBUG) {
- Slog.w(TAG, "adb backup cancel of " + target);
- }
- if (target != null) {
- tearDownAgentAndKill(mCurrentTarget.applicationInfo);
- }
- removeOperation(mCurrentOpToken);
- }
- }
-
- /**
- * Full backup task extension used for transport-oriented operation.
- *
- * Flow:
- * For each requested package:
- * - Spin off a new SinglePackageBackupRunner (mBackupRunner) for the current package.
- * - Wait until preflight is complete. (mBackupRunner.getPreflightResultBlocking())
- * - If preflight data size is within limit, start reading data from agent pipe and writing
- * to transport pipe. While there is data to send, call transport.sendBackupData(int) to
- * tell the transport how many bytes to expect on its pipe.
- * - After sending all data, call transport.finishBackup() if things went well. And
- * transport.cancelFullBackup() otherwise.
- *
- * Interactions with mCurrentOperations:
- * - An entry for this object is added to mCurrentOperations for the entire lifetime of this
- * object. Used to cancel the operation.
- * - SinglePackageBackupRunner and SinglePackageBackupPreflight will put ephemeral entries
- * to get timeouts or operation complete callbacks.
- *
- * Handling cancels:
- * - The contract we provide is that the task won't interact with the transport after
- * handleCancel() is done executing.
- * - This task blocks at 3 points: 1. Preflight result check 2. Reading on agent side pipe
- * and 3. Get backup result from mBackupRunner.
- * - Bubbling up handleCancel to mBackupRunner handles all 3: 1. Calls handleCancel on the
- * preflight operation which counts down on the preflight latch. 2. Tears down the agent,
- * so read() returns -1. 3. Notifies mCurrentOpLock which unblocks
- * mBackupRunner.getBackupResultBlocking().
- */
- class PerformFullTransportBackupTask extends FullBackupTask implements BackupRestoreTask {
- static final String TAG = "PFTBT";
-
- private final Object mCancelLock = new Object();
-
- ArrayList<PackageInfo> mPackages;
- PackageInfo mCurrentPackage;
- boolean mUpdateSchedule;
- CountDownLatch mLatch;
- FullBackupJob mJob; // if a scheduled job needs to be finished afterwards
- IBackupObserver mBackupObserver;
- IBackupManagerMonitor mMonitor;
- boolean mUserInitiated;
- private volatile IBackupTransport mTransport;
- SinglePackageBackupRunner mBackupRunner;
- private final int mBackupRunnerOpToken;
-
- // This is true when a backup operation for some package is in progress.
- private volatile boolean mIsDoingBackup;
- private volatile boolean mCancelAll;
- private final int mCurrentOpToken;
-
- PerformFullTransportBackupTask(IFullBackupRestoreObserver observer,
- String[] whichPackages, boolean updateSchedule,
- FullBackupJob runningJob, CountDownLatch latch, IBackupObserver backupObserver,
- IBackupManagerMonitor monitor, boolean userInitiated) {
- super(observer);
- mUpdateSchedule = updateSchedule;
- mLatch = latch;
- mJob = runningJob;
- mPackages = new ArrayList<PackageInfo>(whichPackages.length);
- mBackupObserver = backupObserver;
- mMonitor = monitor;
- mUserInitiated = userInitiated;
- mCurrentOpToken = generateRandomIntegerToken();
- mBackupRunnerOpToken = generateRandomIntegerToken();
-
- if (isBackupOperationInProgress()) {
- if (DEBUG) {
- Slog.d(TAG, "Skipping full backup. A backup is already in progress.");
- }
- mCancelAll = true;
- return;
- }
-
- registerTask();
-
- for (String pkg : whichPackages) {
- try {
- PackageInfo info = mPackageManager.getPackageInfo(pkg,
- PackageManager.GET_SIGNATURES);
- mCurrentPackage = info;
- if (!appIsEligibleForBackup(info.applicationInfo, mPackageManager)) {
- // Cull any packages that have indicated that backups are not permitted,
- // that run as system-domain uids but do not define their own backup agents,
- // as well as any explicit mention of the 'special' shared-storage agent
- // package (we handle that one at the end).
- if (MORE_DEBUG) {
- Slog.d(TAG, "Ignoring ineligible package " + pkg);
- }
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_INELIGIBLE,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- sendBackupOnPackageResult(mBackupObserver, pkg,
- BackupManager.ERROR_BACKUP_NOT_ALLOWED);
- continue;
- } else if (!appGetsFullBackup(info)) {
- // Cull any packages that are found in the queue but now aren't supposed
- // to get full-data backup operations.
- if (MORE_DEBUG) {
- Slog.d(TAG, "Ignoring full-data backup of key/value participant "
- + pkg);
- }
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_KEY_VALUE_PARTICIPANT,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- sendBackupOnPackageResult(mBackupObserver, pkg,
- BackupManager.ERROR_BACKUP_NOT_ALLOWED);
- continue;
- } else if (appIsStopped(info.applicationInfo)) {
- // Cull any packages in the 'stopped' state: they've either just been
- // installed or have explicitly been force-stopped by the user. In both
- // cases we do not want to launch them for backup.
- if (MORE_DEBUG) {
- Slog.d(TAG, "Ignoring stopped package " + pkg);
- }
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_STOPPED,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- sendBackupOnPackageResult(mBackupObserver, pkg,
- BackupManager.ERROR_BACKUP_NOT_ALLOWED);
- continue;
- }
- mPackages.add(info);
- } catch (NameNotFoundException e) {
- Slog.i(TAG, "Requested package " + pkg + " not found; ignoring");
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_NOT_FOUND,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- }
- }
- }
-
- private void registerTask() {
- synchronized (mCurrentOpLock) {
- Slog.d(TAG, "backupmanager pftbt token=" + Integer.toHexString(mCurrentOpToken));
- mCurrentOperations.put(mCurrentOpToken, new Operation(OP_PENDING, this,
- OP_TYPE_BACKUP));
- }
- }
-
- private void unregisterTask() {
- removeOperation(mCurrentOpToken);
- }
-
- @Override
- public void execute() {
- // Nothing to do.
- }
-
- @Override
- public void handleCancel(boolean cancelAll) {
- synchronized (mCancelLock) {
- // We only support 'cancelAll = true' case for this task. Cancelling of a single package
-
- // due to timeout is handled by SinglePackageBackupRunner and SinglePackageBackupPreflight.
-
- if (!cancelAll) {
- Slog.wtf(TAG, "Expected cancelAll to be true.");
- }
-
- if (mCancelAll) {
- Slog.d(TAG, "Ignoring duplicate cancel call.");
- return;
- }
-
- mCancelAll = true;
- if (mIsDoingBackup) {
- BackupManagerService.this.handleCancel(mBackupRunnerOpToken, cancelAll);
- try {
- mTransport.cancelFullBackup();
- } catch (RemoteException e) {
- Slog.w(TAG, "Error calling cancelFullBackup() on transport: " + e);
- // Can't do much.
- }
- }
- }
- }
-
- @Override
- public void operationComplete(long result) {
- // Nothing to do.
- }
-
- @Override
- public void run() {
-
- // data from the app, passed to us for bridging to the transport
- ParcelFileDescriptor[] enginePipes = null;
-
- // Pipe through which we write data to the transport
- ParcelFileDescriptor[] transportPipes = null;
-
- long backoff = 0;
- int backupRunStatus = BackupManager.SUCCESS;
-
- try {
- if (!mEnabled || !mProvisioned) {
- // Backups are globally disabled, so don't proceed.
- if (DEBUG) {
- Slog.i(TAG, "full backup requested but enabled=" + mEnabled
- + " provisioned=" + mProvisioned + "; ignoring");
- }
- int monitoringEvent;
- if (mProvisioned) {
- monitoringEvent = BackupManagerMonitor.LOG_EVENT_ID_BACKUP_DISABLED;
- } else {
- monitoringEvent = BackupManagerMonitor.LOG_EVENT_ID_DEVICE_NOT_PROVISIONED;
- }
- mMonitor = monitorEvent(mMonitor, monitoringEvent, null,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null);
- mUpdateSchedule = false;
- backupRunStatus = BackupManager.ERROR_BACKUP_NOT_ALLOWED;
- return;
- }
-
- mTransport = mTransportManager.getCurrentTransportBinder();
- if (mTransport == null) {
- Slog.w(TAG, "Transport not present; full data backup not performed");
- backupRunStatus = BackupManager.ERROR_TRANSPORT_ABORTED;
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_TRANSPORT_NOT_PRESENT,
- mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT,
- null);
- return;
- }
-
- // Set up to send data to the transport
- final int N = mPackages.size();
- final byte[] buffer = new byte[8192];
- for (int i = 0; i < N; i++) {
- mBackupRunner = null;
- PackageInfo currentPackage = mPackages.get(i);
- String packageName = currentPackage.packageName;
- if (DEBUG) {
- Slog.i(TAG, "Initiating full-data transport backup of " + packageName
- + " token: " + mCurrentOpToken);
- }
- EventLog.writeEvent(EventLogTags.FULL_BACKUP_PACKAGE, packageName);
-
- transportPipes = ParcelFileDescriptor.createPipe();
-
- // Tell the transport the data's coming
- int flags = mUserInitiated ? BackupTransport.FLAG_USER_INITIATED : 0;
- int backupPackageStatus;
- long quota = Long.MAX_VALUE;
- synchronized (mCancelLock) {
- if (mCancelAll) {
- break;
- }
- backupPackageStatus = mTransport.performFullBackup(currentPackage,
- transportPipes[0], flags);
-
- if (backupPackageStatus == BackupTransport.TRANSPORT_OK) {
- quota = mTransport.getBackupQuota(currentPackage.packageName,
- true /* isFullBackup */);
- // Now set up the backup engine / data source end of things
- enginePipes = ParcelFileDescriptor.createPipe();
- mBackupRunner =
- new SinglePackageBackupRunner(enginePipes[1], currentPackage,
- mTransport, quota, mBackupRunnerOpToken);
- // The runner dup'd the pipe half, so we close it here
- enginePipes[1].close();
- enginePipes[1] = null;
-
- mIsDoingBackup = true;
- }
- }
- if (backupPackageStatus == BackupTransport.TRANSPORT_OK) {
-
- // The transport has its own copy of the read end of the pipe,
- // so close ours now
- transportPipes[0].close();
- transportPipes[0] = null;
-
- // Spin off the runner to fetch the app's data and pipe it
- // into the engine pipes
- (new Thread(mBackupRunner, "package-backup-bridge")).start();
-
- // Read data off the engine pipe and pass it to the transport
- // pipe until we hit EOD on the input stream. We do not take
- // close() responsibility for these FDs into these stream wrappers.
- FileInputStream in = new FileInputStream(
- enginePipes[0].getFileDescriptor());
- FileOutputStream out = new FileOutputStream(
- transportPipes[1].getFileDescriptor());
- long totalRead = 0;
- final long preflightResult = mBackupRunner.getPreflightResultBlocking();
- // Preflight result is negative if some error happened on preflight.
- if (preflightResult < 0) {
- if (MORE_DEBUG) {
- Slog.d(TAG, "Backup error after preflight of package "
- + packageName + ": " + preflightResult
- + ", not running backup.");
- }
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_ERROR_PREFLIGHT,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- putMonitoringExtra(null,
- BackupManagerMonitor.EXTRA_LOG_PREFLIGHT_ERROR,
- preflightResult));
- backupPackageStatus = (int) preflightResult;
- } else {
- int nRead = 0;
- do {
- nRead = in.read(buffer);
- if (MORE_DEBUG) {
- Slog.v(TAG, "in.read(buffer) from app: " + nRead);
- }
- if (nRead > 0) {
- out.write(buffer, 0, nRead);
- synchronized (mCancelLock) {
- if (!mCancelAll) {
- backupPackageStatus = mTransport.sendBackupData(nRead);
- }
- }
- totalRead += nRead;
- if (mBackupObserver != null && preflightResult > 0) {
- sendBackupOnUpdate(mBackupObserver, packageName,
- new BackupProgress(preflightResult, totalRead));
- }
- }
- } while (nRead > 0
- && backupPackageStatus == BackupTransport.TRANSPORT_OK);
- // Despite preflight succeeded, package still can hit quota on flight.
- if (backupPackageStatus == BackupTransport.TRANSPORT_QUOTA_EXCEEDED) {
- Slog.w(TAG, "Package hit quota limit in-flight " + packageName
- + ": " + totalRead + " of " + quota);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_QUOTA_HIT_PREFLIGHT,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT,
- null);
- mBackupRunner.sendQuotaExceeded(totalRead, quota);
- }
- }
-
- final int backupRunnerResult = mBackupRunner.getBackupResultBlocking();
-
- synchronized (mCancelLock) {
- mIsDoingBackup = false;
- // If mCancelCurrent is true, we have already called cancelFullBackup().
- if (!mCancelAll) {
- if (backupRunnerResult == BackupTransport.TRANSPORT_OK) {
- // If we were otherwise in a good state, now interpret the final
- // result based on what finishBackup() returns. If we're in a
- // failure case already, preserve that result and ignore whatever
- // finishBackup() reports.
- final int finishResult = mTransport.finishBackup();
- if (backupPackageStatus == BackupTransport.TRANSPORT_OK) {
- backupPackageStatus = finishResult;
- }
- } else {
- mTransport.cancelFullBackup();
- }
- }
- }
-
- // A transport-originated error here means that we've hit an error that the
- // runner doesn't know about, so it's still moving data but we're pulling the
- // rug out from under it. Don't ask for its result: we already know better
- // and we'll hang if we block waiting for it, since it relies on us to
- // read back the data it's writing into the engine. Just proceed with
- // a graceful failure. The runner/engine mechanism will tear itself
- // down cleanly when we close the pipes from this end. Transport-level
- // errors take precedence over agent/app-specific errors for purposes of
- // determining our course of action.
- if (backupPackageStatus == BackupTransport.TRANSPORT_OK) {
- // We still could fail in backup runner thread.
- if (backupRunnerResult != BackupTransport.TRANSPORT_OK) {
- // If there was an error in runner thread and
- // not TRANSPORT_ERROR here, overwrite it.
- backupPackageStatus = backupRunnerResult;
- }
- } else {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Transport-level failure; cancelling agent work");
- }
- }
-
- if (MORE_DEBUG) {
- Slog.i(TAG, "Done delivering backup data: result="
- + backupPackageStatus);
- }
-
- if (backupPackageStatus != BackupTransport.TRANSPORT_OK) {
- Slog.e(TAG, "Error " + backupPackageStatus + " backing up "
- + packageName);
- }
-
- // Also ask the transport how long it wants us to wait before
- // moving on to the next package, if any.
- backoff = mTransport.requestFullBackupTime();
- if (DEBUG_SCHEDULING) {
- Slog.i(TAG, "Transport suggested backoff=" + backoff);
- }
-
- }
-
- // Roll this package to the end of the backup queue if we're
- // in a queue-driven mode (regardless of success/failure)
- if (mUpdateSchedule) {
- enqueueFullBackup(packageName, System.currentTimeMillis());
- }
-
- if (backupPackageStatus == BackupTransport.TRANSPORT_PACKAGE_REJECTED) {
- sendBackupOnPackageResult(mBackupObserver, packageName,
- BackupManager.ERROR_TRANSPORT_PACKAGE_REJECTED);
- if (DEBUG) {
- Slog.i(TAG, "Transport rejected backup of " + packageName
- + ", skipping");
- }
- EventLog.writeEvent(EventLogTags.FULL_BACKUP_AGENT_FAILURE, packageName,
- "transport rejected");
- // This failure state can come either a-priori from the transport, or
- // from the preflight pass. If we got as far as preflight, we now need
- // to tear down the target process.
- if (mBackupRunner != null) {
- tearDownAgentAndKill(currentPackage.applicationInfo);
- }
- // ... and continue looping.
- } else if (backupPackageStatus == BackupTransport.TRANSPORT_QUOTA_EXCEEDED) {
- sendBackupOnPackageResult(mBackupObserver, packageName,
- BackupManager.ERROR_TRANSPORT_QUOTA_EXCEEDED);
- if (DEBUG) {
- Slog.i(TAG, "Transport quota exceeded for package: " + packageName);
- EventLog.writeEvent(EventLogTags.FULL_BACKUP_QUOTA_EXCEEDED,
- packageName);
- }
- tearDownAgentAndKill(currentPackage.applicationInfo);
- // Do nothing, clean up, and continue looping.
- } else if (backupPackageStatus == BackupTransport.AGENT_ERROR) {
- sendBackupOnPackageResult(mBackupObserver, packageName,
- BackupManager.ERROR_AGENT_FAILURE);
- Slog.w(TAG, "Application failure for package: " + packageName);
- EventLog.writeEvent(EventLogTags.BACKUP_AGENT_FAILURE, packageName);
- tearDownAgentAndKill(currentPackage.applicationInfo);
- // Do nothing, clean up, and continue looping.
- } else if (backupPackageStatus == BackupManager.ERROR_BACKUP_CANCELLED) {
- sendBackupOnPackageResult(mBackupObserver, packageName,
- BackupManager.ERROR_BACKUP_CANCELLED);
- Slog.w(TAG, "Backup cancelled. package=" + packageName +
- ", cancelAll=" + mCancelAll);
- EventLog.writeEvent(EventLogTags.FULL_BACKUP_CANCELLED, packageName);
- tearDownAgentAndKill(currentPackage.applicationInfo);
- // Do nothing, clean up, and continue looping.
- } else if (backupPackageStatus != BackupTransport.TRANSPORT_OK) {
- sendBackupOnPackageResult(mBackupObserver, packageName,
- BackupManager.ERROR_TRANSPORT_ABORTED);
- Slog.w(TAG, "Transport failed; aborting backup: " + backupPackageStatus);
- EventLog.writeEvent(EventLogTags.FULL_BACKUP_TRANSPORT_FAILURE);
- // Abort entire backup pass.
- backupRunStatus = BackupManager.ERROR_TRANSPORT_ABORTED;
- tearDownAgentAndKill(currentPackage.applicationInfo);
- return;
- } else {
- // Success!
- sendBackupOnPackageResult(mBackupObserver, packageName,
- BackupManager.SUCCESS);
- EventLog.writeEvent(EventLogTags.FULL_BACKUP_SUCCESS, packageName);
- logBackupComplete(packageName);
- }
- cleanUpPipes(transportPipes);
- cleanUpPipes(enginePipes);
- if (currentPackage.applicationInfo != null) {
- Slog.i(TAG, "Unbinding agent in " + packageName);
- addBackupTrace("unbinding " + packageName);
- try {
- mActivityManager.unbindBackupAgent(currentPackage.applicationInfo);
- } catch (RemoteException e) { /* can't happen; activity manager is local */ }
- }
- }
- } catch (Exception e) {
- backupRunStatus = BackupManager.ERROR_TRANSPORT_ABORTED;
- Slog.w(TAG, "Exception trying full transport backup", e);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_EXCEPTION_FULL_BACKUP,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- putMonitoringExtra(null,
- BackupManagerMonitor.EXTRA_LOG_EXCEPTION_FULL_BACKUP,
- Log.getStackTraceString(e)));
-
- } finally {
-
- if (mCancelAll) {
- backupRunStatus = BackupManager.ERROR_BACKUP_CANCELLED;
- }
-
- if (DEBUG) {
- Slog.i(TAG, "Full backup completed with status: " + backupRunStatus);
- }
- sendBackupFinished(mBackupObserver, backupRunStatus);
-
- cleanUpPipes(transportPipes);
- cleanUpPipes(enginePipes);
-
- unregisterTask();
-
- if (mJob != null) {
- mJob.finishBackupPass();
- }
-
- synchronized (mQueueLock) {
- mRunningFullBackupTask = null;
- }
-
- mLatch.countDown();
-
- // Now that we're actually done with schedule-driven work, reschedule
- // the next pass based on the new queue state.
- if (mUpdateSchedule) {
- scheduleNextFullBackupJob(backoff);
- }
-
- Slog.i(BackupManagerService.TAG, "Full data backup pass finished.");
- mWakelock.release();
- }
- }
-
- void cleanUpPipes(ParcelFileDescriptor[] pipes) {
- if (pipes != null) {
- if (pipes[0] != null) {
- ParcelFileDescriptor fd = pipes[0];
- pipes[0] = null;
- try {
- fd.close();
- } catch (IOException e) {
- Slog.w(TAG, "Unable to close pipe!");
- }
- }
- if (pipes[1] != null) {
- ParcelFileDescriptor fd = pipes[1];
- pipes[1] = null;
- try {
- fd.close();
- } catch (IOException e) {
- Slog.w(TAG, "Unable to close pipe!");
- }
- }
- }
- }
-
- // Run the backup and pipe it back to the given socket -- expects to run on
- // a standalone thread. The runner owns this half of the pipe, and closes
- // it to indicate EOD to the other end.
- class SinglePackageBackupPreflight implements BackupRestoreTask, FullBackupPreflight {
- final AtomicLong mResult = new AtomicLong(BackupTransport.AGENT_ERROR);
- final CountDownLatch mLatch = new CountDownLatch(1);
- final IBackupTransport mTransport;
- final long mQuota;
- private final int mCurrentOpToken;
-
- SinglePackageBackupPreflight(IBackupTransport transport, long quota, int currentOpToken) {
- mTransport = transport;
- mQuota = quota;
- mCurrentOpToken = currentOpToken;
- }
-
- @Override
- public int preflightFullBackup(PackageInfo pkg, IBackupAgent agent) {
- int result;
- try {
- prepareOperationTimeout(mCurrentOpToken, TIMEOUT_FULL_BACKUP_INTERVAL,
- this, OP_TYPE_BACKUP_WAIT);
- addBackupTrace("preflighting");
- if (MORE_DEBUG) {
- Slog.d(TAG, "Preflighting full payload of " + pkg.packageName);
- }
- agent.doMeasureFullBackup(mQuota, mCurrentOpToken, mBackupManagerBinder);
-
- // Now wait to get our result back. If this backstop timeout is reached without
- // the latch being thrown, flow will continue as though a result or "normal"
- // timeout had been produced. In case of a real backstop timeout, mResult
- // will still contain the value it was constructed with, AGENT_ERROR, which
- // intentionaly falls into the "just report failure" code.
- mLatch.await(TIMEOUT_FULL_BACKUP_INTERVAL, TimeUnit.MILLISECONDS);
-
- long totalSize = mResult.get();
- // If preflight timed out, mResult will contain error code as int.
- if (totalSize < 0) {
- return (int) totalSize;
- }
- if (MORE_DEBUG) {
- Slog.v(TAG, "Got preflight response; size=" + totalSize);
- }
-
- result = mTransport.checkFullBackupSize(totalSize);
- if (result == BackupTransport.TRANSPORT_QUOTA_EXCEEDED) {
- if (MORE_DEBUG) {
- Slog.d(TAG, "Package hit quota limit on preflight " +
- pkg.packageName + ": " + totalSize + " of " + mQuota);
- }
- agent.doQuotaExceeded(totalSize, mQuota);
- }
- } catch (Exception e) {
- Slog.w(TAG, "Exception preflighting " + pkg.packageName + ": " + e.getMessage());
- result = BackupTransport.AGENT_ERROR;
- }
- return result;
- }
-
- @Override
- public void execute() {
- // Unused.
- }
-
- @Override
- public void operationComplete(long result) {
- // got the callback, and our preflightFullBackup() method is waiting for the result
- if (MORE_DEBUG) {
- Slog.i(TAG, "Preflight op complete, result=" + result);
- }
- mResult.set(result);
- mLatch.countDown();
- removeOperation(mCurrentOpToken);
- }
-
- @Override
- public void handleCancel(boolean cancelAll) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Preflight cancelled; failing");
- }
- mResult.set(BackupTransport.AGENT_ERROR);
- mLatch.countDown();
- removeOperation(mCurrentOpToken);
- }
-
- @Override
- public long getExpectedSizeOrErrorCode() {
- try {
- mLatch.await(TIMEOUT_FULL_BACKUP_INTERVAL, TimeUnit.MILLISECONDS);
- return mResult.get();
- } catch (InterruptedException e) {
- return BackupTransport.NO_MORE_DATA;
- }
- }
- }
-
- class SinglePackageBackupRunner implements Runnable, BackupRestoreTask {
- final ParcelFileDescriptor mOutput;
- final PackageInfo mTarget;
- final SinglePackageBackupPreflight mPreflight;
- final CountDownLatch mPreflightLatch;
- final CountDownLatch mBackupLatch;
- private final int mCurrentOpToken;
- private final int mEphemeralToken;
- private FullBackupEngine mEngine;
- private volatile int mPreflightResult;
- private volatile int mBackupResult;
- private final long mQuota;
- private volatile boolean mIsCancelled;
-
- SinglePackageBackupRunner(ParcelFileDescriptor output, PackageInfo target,
- IBackupTransport transport, long quota, int currentOpToken) throws IOException {
- mOutput = ParcelFileDescriptor.dup(output.getFileDescriptor());
- mTarget = target;
- mCurrentOpToken = currentOpToken;
- mEphemeralToken = generateRandomIntegerToken();
- mPreflight = new SinglePackageBackupPreflight(transport, quota, mEphemeralToken);
- mPreflightLatch = new CountDownLatch(1);
- mBackupLatch = new CountDownLatch(1);
- mPreflightResult = BackupTransport.AGENT_ERROR;
- mBackupResult = BackupTransport.AGENT_ERROR;
- mQuota = quota;
- registerTask();
- }
-
- void registerTask() {
- synchronized (mCurrentOpLock) {
- mCurrentOperations.put(mCurrentOpToken, new Operation(OP_PENDING, this,
- OP_TYPE_BACKUP_WAIT));
- }
- }
-
- void unregisterTask() {
- synchronized (mCurrentOpLock) {
- mCurrentOperations.remove(mCurrentOpToken);
- }
- }
-
- @Override
- public void run() {
- FileOutputStream out = new FileOutputStream(mOutput.getFileDescriptor());
- mEngine = new FullBackupEngine(out, mPreflight, mTarget, false, this, mQuota, mCurrentOpToken);
- try {
- try {
- if (!mIsCancelled) {
- mPreflightResult = mEngine.preflightCheck();
- }
- } finally {
- mPreflightLatch.countDown();
- }
- // If there is no error on preflight, continue backup.
- if (mPreflightResult == BackupTransport.TRANSPORT_OK) {
- if (!mIsCancelled) {
- mBackupResult = mEngine.backupOnePackage();
- }
- }
- } catch (Exception e) {
- Slog.e(TAG, "Exception during full package backup of " + mTarget.packageName);
- } finally {
- unregisterTask();
- mBackupLatch.countDown();
- try {
- mOutput.close();
- } catch (IOException e) {
- Slog.w(TAG, "Error closing transport pipe in runner");
- }
- }
- }
-
- public void sendQuotaExceeded(final long backupDataBytes, final long quotaBytes) {
- mEngine.sendQuotaExceeded(backupDataBytes, quotaBytes);
- }
-
- // If preflight succeeded, returns positive number - preflight size,
- // otherwise return negative error code.
- long getPreflightResultBlocking() {
- try {
- mPreflightLatch.await(TIMEOUT_FULL_BACKUP_INTERVAL, TimeUnit.MILLISECONDS);
- if (mIsCancelled) {
- return BackupManager.ERROR_BACKUP_CANCELLED;
- }
- if (mPreflightResult == BackupTransport.TRANSPORT_OK) {
- return mPreflight.getExpectedSizeOrErrorCode();
- } else {
- return mPreflightResult;
- }
- } catch (InterruptedException e) {
- return BackupTransport.AGENT_ERROR;
- }
- }
-
- int getBackupResultBlocking() {
- try {
- mBackupLatch.await(TIMEOUT_FULL_BACKUP_INTERVAL, TimeUnit.MILLISECONDS);
- if (mIsCancelled) {
- return BackupManager.ERROR_BACKUP_CANCELLED;
- }
- return mBackupResult;
- } catch (InterruptedException e) {
- return BackupTransport.AGENT_ERROR;
- }
- }
-
-
- // BackupRestoreTask interface: specifically, timeout detection
-
- @Override
- public void execute() { /* intentionally empty */ }
-
- @Override
- public void operationComplete(long result) { /* intentionally empty */ }
-
- @Override
- public void handleCancel(boolean cancelAll) {
- if (DEBUG) {
- Slog.w(TAG, "Full backup cancel of " + mTarget.packageName);
- }
-
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_FULL_BACKUP_CANCEL,
- mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, null);
- mIsCancelled = true;
- // Cancel tasks spun off by this task.
- BackupManagerService.this.handleCancel(mEphemeralToken, cancelAll);
- tearDownAgentAndKill(mTarget.applicationInfo);
- // Free up everyone waiting on this task and its children.
- mPreflightLatch.countDown();
- mBackupLatch.countDown();
- // We are done with this operation.
- removeOperation(mCurrentOpToken);
- }
- }
- }
-
- // ----- Full-data backup scheduling -----
-
- /**
- * Schedule a job to tell us when it's a good time to run a full backup
- */
- void scheduleNextFullBackupJob(long transportMinLatency) {
- synchronized (mQueueLock) {
- if (mFullBackupQueue.size() > 0) {
- // schedule the next job at the point in the future when the least-recently
- // backed up app comes due for backup again; or immediately if it's already
- // due.
- final long upcomingLastBackup = mFullBackupQueue.get(0).lastBackup;
- final long timeSinceLast = System.currentTimeMillis() - upcomingLastBackup;
- final long interval = mConstants.getFullBackupIntervalMilliseconds();
- final long appLatency = (timeSinceLast < interval) ? (interval - timeSinceLast) : 0;
- final long latency = Math.max(transportMinLatency, appLatency);
- Runnable r = new Runnable() {
- @Override public void run() {
- FullBackupJob.schedule(mContext, latency, mConstants);
- }
- };
- mBackupHandler.postDelayed(r, 2500);
- } else {
- if (DEBUG_SCHEDULING) {
- Slog.i(TAG, "Full backup queue empty; not scheduling");
- }
- }
- }
- }
-
- /**
- * Remove a package from the full-data queue.
- */
- void dequeueFullBackupLocked(String packageName) {
- final int N = mFullBackupQueue.size();
- for (int i = N-1; i >= 0; i--) {
- final FullBackupEntry e = mFullBackupQueue.get(i);
- if (packageName.equals(e.packageName)) {
- mFullBackupQueue.remove(i);
- }
- }
- }
-
- /**
- * Enqueue full backup for the given app, with a note about when it last ran.
- */
- void enqueueFullBackup(String packageName, long lastBackedUp) {
- FullBackupEntry newEntry = new FullBackupEntry(packageName, lastBackedUp);
- synchronized (mQueueLock) {
- // First, sanity check that we aren't adding a duplicate. Slow but
- // straightforward; we'll have at most on the order of a few hundred
- // items in this list.
- dequeueFullBackupLocked(packageName);
-
- // This is also slow but easy for modest numbers of apps: work backwards
- // from the end of the queue until we find an item whose last backup
- // time was before this one, then insert this new entry after it. If we're
- // adding something new we don't bother scanning, and just prepend.
- int which = -1;
- if (lastBackedUp > 0) {
- for (which = mFullBackupQueue.size() - 1; which >= 0; which--) {
- final FullBackupEntry entry = mFullBackupQueue.get(which);
- if (entry.lastBackup <= lastBackedUp) {
- mFullBackupQueue.add(which + 1, newEntry);
- break;
- }
- }
- }
- if (which < 0) {
- // this one is earlier than any existing one, so prepend
- mFullBackupQueue.add(0, newEntry);
- }
- }
- writeFullBackupScheduleAsync();
- }
-
- private boolean fullBackupAllowable(IBackupTransport transport) {
- if (transport == null) {
- Slog.w(TAG, "Transport not present; full data backup not performed");
- return false;
- }
-
- // Don't proceed unless we have already established package metadata
- // for the current dataset via a key/value backup pass.
- try {
- File stateDir = new File(mBaseStateDir, transport.transportDirName());
- File pmState = new File(stateDir, PACKAGE_MANAGER_SENTINEL);
- if (pmState.length() <= 0) {
- if (DEBUG) {
- Slog.i(TAG, "Full backup requested but dataset not yet initialized");
- }
- return false;
- }
- } catch (Exception e) {
- Slog.w(TAG, "Unable to get transport name: " + e.getMessage());
- return false;
- }
-
- return true;
- }
-
- /**
- * Conditions are right for a full backup operation, so run one. The model we use is
- * to perform one app backup per scheduled job execution, and to reschedule the job
- * with zero latency as long as conditions remain right and we still have work to do.
- *
- * <p>This is the "start a full backup operation" entry point called by the scheduled job.
- *
- * @return Whether ongoing work will continue. The return value here will be passed
- * along as the return value to the scheduled job's onStartJob() callback.
- */
- @Override
- public boolean beginFullBackup(FullBackupJob scheduledJob) {
- final long now = System.currentTimeMillis();
- FullBackupEntry entry = null;
- final long fullBackupInterval;
- final long keyValueBackupInterval;
- synchronized (mConstants) {
- fullBackupInterval = mConstants.getFullBackupIntervalMilliseconds();
- keyValueBackupInterval = mConstants.getKeyValueBackupIntervalMilliseconds();
- }
- long latency = fullBackupInterval;
-
- if (!mEnabled || !mProvisioned) {
- // Backups are globally disabled, so don't proceed. We also don't reschedule
- // the job driving automatic backups; that job will be scheduled again when
- // the user enables backup.
- if (MORE_DEBUG) {
- Slog.i(TAG, "beginFullBackup but e=" + mEnabled
- + " p=" + mProvisioned + "; ignoring");
- }
- return false;
- }
-
- // Don't run the backup if we're in battery saver mode, but reschedule
- // to try again in the not-so-distant future.
- final PowerSaveState result =
- mPowerManager.getPowerSaveState(ServiceType.FULL_BACKUP);
- if (result.batterySaverEnabled) {
- if (DEBUG) Slog.i(TAG, "Deferring scheduled full backups in battery saver mode");
- FullBackupJob.schedule(mContext, keyValueBackupInterval, mConstants);
- return false;
- }
-
- if (DEBUG_SCHEDULING) {
- Slog.i(TAG, "Beginning scheduled full backup operation");
- }
-
- // Great; we're able to run full backup jobs now. See if we have any work to do.
- synchronized (mQueueLock) {
- if (mRunningFullBackupTask != null) {
- Slog.e(TAG, "Backup triggered but one already/still running!");
- return false;
- }
-
- // At this point we think that we have work to do, but possibly not right now.
- // Any exit without actually running backups will also require that we
- // reschedule the job.
- boolean runBackup = true;
- boolean headBusy;
-
- do {
- // Recheck each time, because culling due to ineligibility may
- // have emptied the queue.
- if (mFullBackupQueue.size() == 0) {
- // no work to do so just bow out
- if (DEBUG) {
- Slog.i(TAG, "Backup queue empty; doing nothing");
- }
- runBackup = false;
- break;
- }
-
- headBusy = false;
-
- if (!fullBackupAllowable(mTransportManager.getCurrentTransportBinder())) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Preconditions not met; not running full backup");
- }
- runBackup = false;
- // Typically this means we haven't run a key/value backup yet. Back off
- // full-backup operations by the key/value job's run interval so that
- // next time we run, we are likely to be able to make progress.
- latency = keyValueBackupInterval;
- }
-
- if (runBackup) {
- entry = mFullBackupQueue.get(0);
- long timeSinceRun = now - entry.lastBackup;
- runBackup = (timeSinceRun >= fullBackupInterval);
- if (!runBackup) {
- // It's too early to back up the next thing in the queue, so bow out
- if (MORE_DEBUG) {
- Slog.i(TAG, "Device ready but too early to back up next app");
- }
- // Wait until the next app in the queue falls due for a full data backup
- latency = fullBackupInterval - timeSinceRun;
- break; // we know we aren't doing work yet, so bail.
- }
-
- try {
- PackageInfo appInfo = mPackageManager.getPackageInfo(entry.packageName, 0);
- if (!appGetsFullBackup(appInfo)) {
- // The head app isn't supposed to get full-data backups [any more];
- // so we cull it and force a loop around to consider the new head
- // app.
- if (MORE_DEBUG) {
- Slog.i(TAG, "Culling package " + entry.packageName
- + " in full-backup queue but not eligible");
- }
- mFullBackupQueue.remove(0);
- headBusy = true; // force the while() condition
- continue;
- }
-
- final int privFlags = appInfo.applicationInfo.privateFlags;
- headBusy = (privFlags & PRIVATE_FLAG_BACKUP_IN_FOREGROUND) == 0
- && mActivityManager.isAppForeground(appInfo.applicationInfo.uid);
-
- if (headBusy) {
- final long nextEligible = System.currentTimeMillis()
- + BUSY_BACKOFF_MIN_MILLIS
- + mTokenGenerator.nextInt(BUSY_BACKOFF_FUZZ);
- if (DEBUG_SCHEDULING) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
- Slog.i(TAG, "Full backup time but " + entry.packageName
- + " is busy; deferring to "
- + sdf.format(new Date(nextEligible)));
- }
- // This relocates the app's entry from the head of the queue to
- // its order-appropriate position further down, so upon looping
- // a new candidate will be considered at the head.
- enqueueFullBackup(entry.packageName, nextEligible - fullBackupInterval);
- }
- } catch (NameNotFoundException nnf) {
- // So, we think we want to back this up, but it turns out the package
- // in question is no longer installed. We want to drop it from the
- // queue entirely and move on, but if there's nothing else in the queue
- // we should bail entirely. headBusy cannot have been set to true yet.
- runBackup = (mFullBackupQueue.size() > 1);
- } catch (RemoteException e) {
- // Cannot happen; the Activity Manager is in the same process
- }
- }
- } while (headBusy);
-
- if (!runBackup) {
- if (DEBUG_SCHEDULING) {
- Slog.i(TAG, "Nothing pending full backup; rescheduling +" + latency);
- }
- final long deferTime = latency; // pin for the closure
- mBackupHandler.post(new Runnable() {
- @Override public void run() {
- FullBackupJob.schedule(mContext, deferTime, mConstants);
- }
- });
- return false;
- }
-
- // Okay, the top thing is ready for backup now. Do it.
- mFullBackupQueue.remove(0);
- CountDownLatch latch = new CountDownLatch(1);
- String[] pkg = new String[] {entry.packageName};
- mRunningFullBackupTask = new PerformFullTransportBackupTask(null, pkg, true,
- scheduledJob, latch, null, null, false /* userInitiated */);
- // Acquiring wakelock for PerformFullTransportBackupTask before its start.
- mWakelock.acquire();
- (new Thread(mRunningFullBackupTask)).start();
- }
-
- return true;
- }
-
- // The job scheduler says our constraints don't hold any more,
- // so tear down any ongoing backup task right away.
- @Override
- public void endFullBackup() {
- // offload the mRunningFullBackupTask.handleCancel() call to another thread,
- // as we might have to wait for mCancelLock
- Runnable endFullBackupRunnable = new Runnable() {
- @Override
- public void run() {
- PerformFullTransportBackupTask pftbt = null;
- synchronized (mQueueLock) {
- if (mRunningFullBackupTask != null) {
- pftbt = mRunningFullBackupTask;
- }
- }
- if (pftbt != null) {
- if (DEBUG_SCHEDULING) {
- Slog.i(TAG, "Telling running backup to stop");
- }
- pftbt.handleCancel(true);
- }
- }
- };
- new Thread(endFullBackupRunnable, "end-full-backup").start();
- }
-
- // ----- Restore infrastructure -----
-
- abstract class RestoreEngine {
- static final String TAG = "RestoreEngine";
-
- public static final int SUCCESS = 0;
- public static final int TARGET_FAILURE = -2;
- public static final int TRANSPORT_FAILURE = -3;
-
- private AtomicBoolean mRunning = new AtomicBoolean(false);
- private AtomicInteger mResult = new AtomicInteger(SUCCESS);
-
- public boolean isRunning() {
- return mRunning.get();
- }
-
- public void setRunning(boolean stillRunning) {
- synchronized (mRunning) {
- mRunning.set(stillRunning);
- mRunning.notifyAll();
- }
- }
-
- public int waitForResult() {
- synchronized (mRunning) {
- while (isRunning()) {
- try {
- mRunning.wait();
- } catch (InterruptedException e) {}
- }
- }
- return getResult();
- }
-
- public int getResult() {
- return mResult.get();
- }
-
- public void setResult(int result) {
- mResult.set(result);
- }
-
- // TODO: abstract restore state and APIs
- }
-
- // ----- Full restore from a file/socket -----
-
- enum RestorePolicy {
- IGNORE,
- ACCEPT,
- ACCEPT_IF_APK
- }
-
- // Full restore engine, used by both adb restore and transport-based full restore
- class FullRestoreEngine extends RestoreEngine {
- // Task in charge of monitoring timeouts
- BackupRestoreTask mMonitorTask;
-
- // Dedicated observer, if any
- IFullBackupRestoreObserver mObserver;
-
- IBackupManagerMonitor mMonitor;
-
- // Where we're delivering the file data as we go
- IBackupAgent mAgent;
-
- // Are we permitted to only deliver a specific package's metadata?
- PackageInfo mOnlyPackage;
-
- boolean mAllowApks;
- boolean mAllowObbs;
-
- // Which package are we currently handling data for?
- String mAgentPackage;
-
- // Info for working with the target app process
- ApplicationInfo mTargetApp;
-
- // Machinery for restoring OBBs
- FullBackupObbConnection mObbConnection = null;
-
- // possible handling states for a given package in the restore dataset
- final HashMap<String, RestorePolicy> mPackagePolicies
- = new HashMap<String, RestorePolicy>();
-
- // installer package names for each encountered app, derived from the manifests
- final HashMap<String, String> mPackageInstallers = new HashMap<String, String>();
-
- // Signatures for a given package found in its manifest file
- final HashMap<String, Signature[]> mManifestSignatures
- = new HashMap<String, Signature[]>();
-
- // Packages we've already wiped data on when restoring their first file
- final HashSet<String> mClearedPackages = new HashSet<String>();
-
- // How much data have we moved?
- long mBytes;
-
- // Working buffer
- byte[] mBuffer;
-
- // Pipes for moving data
- ParcelFileDescriptor[] mPipes = null;
-
- // Widget blob to be restored out-of-band
- byte[] mWidgetData = null;
-
- private final int mEphemeralOpToken;
-
- // Runner that can be placed in a separate thread to do in-process
- // invocations of the full restore API asynchronously. Used by adb restore.
- class RestoreFileRunnable implements Runnable {
- IBackupAgent mAgent;
- FileMetadata mInfo;
- ParcelFileDescriptor mSocket;
- int mToken;
-
- RestoreFileRunnable(IBackupAgent agent, FileMetadata info,
- ParcelFileDescriptor socket, int token) throws IOException {
- mAgent = agent;
- mInfo = info;
- mToken = token;
-
- // This class is used strictly for process-local binder invocations. The
- // semantics of ParcelFileDescriptor differ in this case; in particular, we
- // do not automatically get a 'dup'ed descriptor that we can can continue
- // to use asynchronously from the caller. So, we make sure to dup it ourselves
- // before proceeding to do the restore.
- mSocket = ParcelFileDescriptor.dup(socket.getFileDescriptor());
- }
-
- @Override
- public void run() {
- try {
- mAgent.doRestoreFile(mSocket, mInfo.size, mInfo.type,
- mInfo.domain, mInfo.path, mInfo.mode, mInfo.mtime,
- mToken, mBackupManagerBinder);
- } catch (RemoteException e) {
- // never happens; this is used strictly for local binder calls
- }
- }
- }
-
- public FullRestoreEngine(BackupRestoreTask monitorTask, IFullBackupRestoreObserver observer,
- IBackupManagerMonitor monitor, PackageInfo onlyPackage, boolean allowApks,
- boolean allowObbs, int ephemeralOpToken) {
- mEphemeralOpToken = ephemeralOpToken;
- mMonitorTask = monitorTask;
- mObserver = observer;
- mMonitor = monitor;
- mOnlyPackage = onlyPackage;
- mAllowApks = allowApks;
- mAllowObbs = allowObbs;
- mBuffer = new byte[32 * 1024];
- mBytes = 0;
- }
-
- public IBackupAgent getAgent() {
- return mAgent;
- }
-
- public byte[] getWidgetData() {
- return mWidgetData;
- }
-
- public boolean restoreOneFile(InputStream instream, boolean mustKillAgent) {
- if (!isRunning()) {
- Slog.w(TAG, "Restore engine used after halting");
- return false;
- }
-
- FileMetadata info;
- try {
- if (MORE_DEBUG) {
- Slog.v(TAG, "Reading tar header for restoring file");
- }
- info = readTarHeaders(instream);
- if (info != null) {
- if (MORE_DEBUG) {
- dumpFileMetadata(info);
- }
-
- final String pkg = info.packageName;
- if (!pkg.equals(mAgentPackage)) {
- // In the single-package case, it's a semantic error to expect
- // one app's data but see a different app's on the wire
- if (mOnlyPackage != null) {
- if (!pkg.equals(mOnlyPackage.packageName)) {
- Slog.w(TAG, "Expected data for " + mOnlyPackage
- + " but saw " + pkg);
- setResult(RestoreEngine.TRANSPORT_FAILURE);
- setRunning(false);
- return false;
- }
- }
-
- // okay, change in package; set up our various
- // bookkeeping if we haven't seen it yet
- if (!mPackagePolicies.containsKey(pkg)) {
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- }
-
- // Clean up the previous agent relationship if necessary,
- // and let the observer know we're considering a new app.
- if (mAgent != null) {
- if (DEBUG) Slog.d(TAG, "Saw new package; finalizing old one");
- // Now we're really done
- tearDownPipes();
- tearDownAgent(mTargetApp);
- mTargetApp = null;
- mAgentPackage = null;
- }
- }
-
- if (info.path.equals(BACKUP_MANIFEST_FILENAME)) {
- mPackagePolicies.put(pkg, readAppManifest(info, instream));
- mPackageInstallers.put(pkg, info.installerPackageName);
- // We've read only the manifest content itself at this point,
- // so consume the footer before looping around to the next
- // input file
- skipTarPadding(info.size, instream);
- sendOnRestorePackage(pkg);
- } else if (info.path.equals(BACKUP_METADATA_FILENAME)) {
- // Metadata blobs!
- readMetadata(info, instream);
- skipTarPadding(info.size, instream);
- } else {
- // Non-manifest, so it's actual file data. Is this a package
- // we're ignoring?
- boolean okay = true;
- RestorePolicy policy = mPackagePolicies.get(pkg);
- switch (policy) {
- case IGNORE:
- okay = false;
- break;
-
- case ACCEPT_IF_APK:
- // If we're in accept-if-apk state, then the first file we
- // see MUST be the apk.
- if (info.domain.equals(FullBackup.APK_TREE_TOKEN)) {
- if (DEBUG) Slog.d(TAG, "APK file; installing");
- // Try to install the app.
- String installerName = mPackageInstallers.get(pkg);
- okay = installApk(info, installerName, instream);
- // good to go; promote to ACCEPT
- mPackagePolicies.put(pkg, (okay)
- ? RestorePolicy.ACCEPT
- : RestorePolicy.IGNORE);
- // At this point we've consumed this file entry
- // ourselves, so just strip the tar footer and
- // go on to the next file in the input stream
- skipTarPadding(info.size, instream);
- return true;
- } else {
- // File data before (or without) the apk. We can't
- // handle it coherently in this case so ignore it.
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- okay = false;
- }
- break;
-
- case ACCEPT:
- if (info.domain.equals(FullBackup.APK_TREE_TOKEN)) {
- if (DEBUG) Slog.d(TAG, "apk present but ACCEPT");
- // we can take the data without the apk, so we
- // *want* to do so. skip the apk by declaring this
- // one file not-okay without changing the restore
- // policy for the package.
- okay = false;
- }
- break;
-
- default:
- // Something has gone dreadfully wrong when determining
- // the restore policy from the manifest. Ignore the
- // rest of this package's data.
- Slog.e(TAG, "Invalid policy from manifest");
- okay = false;
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- break;
- }
-
- // Is it a *file* we need to drop?
- if (!isRestorableFile(info)) {
- okay = false;
- }
-
- // If the policy is satisfied, go ahead and set up to pipe the
- // data to the agent.
- if (MORE_DEBUG && okay && mAgent != null) {
- Slog.i(TAG, "Reusing existing agent instance");
- }
- if (okay && mAgent == null) {
- if (MORE_DEBUG) Slog.d(TAG, "Need to launch agent for " + pkg);
-
- try {
- mTargetApp = mPackageManager.getApplicationInfo(pkg, 0);
-
- // If we haven't sent any data to this app yet, we probably
- // need to clear it first. Check that.
- if (!mClearedPackages.contains(pkg)) {
- // apps with their own backup agents are
- // responsible for coherently managing a full
- // restore.
- if (mTargetApp.backupAgentName == null) {
- if (DEBUG) Slog.d(TAG, "Clearing app data preparatory to full restore");
- clearApplicationDataSynchronous(pkg);
- } else {
- if (MORE_DEBUG) Slog.d(TAG, "backup agent ("
- + mTargetApp.backupAgentName + ") => no clear");
- }
- mClearedPackages.add(pkg);
- } else {
- if (MORE_DEBUG) {
- Slog.d(TAG, "We've initialized this app already; no clear required");
- }
- }
-
- // All set; now set up the IPC and launch the agent
- setUpPipes();
- mAgent = bindToAgentSynchronous(mTargetApp,
- ApplicationThreadConstants.BACKUP_MODE_RESTORE_FULL);
- mAgentPackage = pkg;
- } catch (IOException e) {
- // fall through to error handling
- } catch (NameNotFoundException e) {
- // fall through to error handling
- }
-
- if (mAgent == null) {
- Slog.e(TAG, "Unable to create agent for " + pkg);
- okay = false;
- tearDownPipes();
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- }
- }
-
- // Sanity check: make sure we never give data to the wrong app. This
- // should never happen but a little paranoia here won't go amiss.
- if (okay && !pkg.equals(mAgentPackage)) {
- Slog.e(TAG, "Restoring data for " + pkg
- + " but agent is for " + mAgentPackage);
- okay = false;
- }
-
- // At this point we have an agent ready to handle the full
- // restore data as well as a pipe for sending data to
- // that agent. Tell the agent to start reading from the
- // pipe.
- if (okay) {
- boolean agentSuccess = true;
- long toCopy = info.size;
- try {
- prepareOperationTimeout(mEphemeralOpToken,
- TIMEOUT_FULL_BACKUP_INTERVAL, mMonitorTask,
- OP_TYPE_RESTORE_WAIT);
-
- if (info.domain.equals(FullBackup.OBB_TREE_TOKEN)) {
- if (DEBUG) Slog.d(TAG, "Restoring OBB file for " + pkg
- + " : " + info.path);
- mObbConnection.restoreObbFile(pkg, mPipes[0],
- info.size, info.type, info.path, info.mode,
- info.mtime, mEphemeralOpToken, mBackupManagerBinder);
- } else {
- if (MORE_DEBUG) Slog.d(TAG, "Invoking agent to restore file "
- + info.path);
- // fire up the app's agent listening on the socket. If
- // the agent is running in the system process we can't
- // just invoke it asynchronously, so we provide a thread
- // for it here.
- if (mTargetApp.processName.equals("system")) {
- Slog.d(TAG, "system process agent - spinning a thread");
- RestoreFileRunnable runner = new RestoreFileRunnable(
- mAgent, info, mPipes[0], mEphemeralOpToken);
- new Thread(runner, "restore-sys-runner").start();
- } else {
- mAgent.doRestoreFile(mPipes[0], info.size, info.type,
- info.domain, info.path, info.mode, info.mtime,
- mEphemeralOpToken, mBackupManagerBinder);
- }
- }
- } catch (IOException e) {
- // couldn't dup the socket for a process-local restore
- Slog.d(TAG, "Couldn't establish restore");
- agentSuccess = false;
- okay = false;
- } catch (RemoteException e) {
- // whoops, remote entity went away. We'll eat the content
- // ourselves, then, and not copy it over.
- Slog.e(TAG, "Agent crashed during full restore");
- agentSuccess = false;
- okay = false;
- }
-
- // Copy over the data if the agent is still good
- if (okay) {
- if (MORE_DEBUG) {
- Slog.v(TAG, " copying to restore agent: "
- + toCopy + " bytes");
- }
- boolean pipeOkay = true;
- FileOutputStream pipe = new FileOutputStream(
- mPipes[1].getFileDescriptor());
- while (toCopy > 0) {
- int toRead = (toCopy > mBuffer.length)
- ? mBuffer.length : (int)toCopy;
- int nRead = instream.read(mBuffer, 0, toRead);
- if (nRead >= 0) mBytes += nRead;
- if (nRead <= 0) break;
- toCopy -= nRead;
-
- // send it to the output pipe as long as things
- // are still good
- if (pipeOkay) {
- try {
- pipe.write(mBuffer, 0, nRead);
- } catch (IOException e) {
- Slog.e(TAG, "Failed to write to restore pipe: "
- + e.getMessage());
- pipeOkay = false;
- }
- }
- }
-
- // done sending that file! Now we just need to consume
- // the delta from info.size to the end of block.
- skipTarPadding(info.size, instream);
-
- // and now that we've sent it all, wait for the remote
- // side to acknowledge receipt
- agentSuccess = waitUntilOperationComplete(mEphemeralOpToken);
- }
-
- // okay, if the remote end failed at any point, deal with
- // it by ignoring the rest of the restore on it
- if (!agentSuccess) {
- Slog.w(TAG, "Agent failure; ending restore");
- mBackupHandler.removeMessages(MSG_RESTORE_OPERATION_TIMEOUT);
- tearDownPipes();
- tearDownAgent(mTargetApp);
- mAgent = null;
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
-
- // If this was a single-package restore, we halt immediately
- // with an agent error under these circumstances
- if (mOnlyPackage != null) {
- setResult(RestoreEngine.TARGET_FAILURE);
- setRunning(false);
- return false;
- }
- }
- }
-
- // Problems setting up the agent communication, an explicitly
- // dropped file, or an already-ignored package: skip to the
- // next stream entry by reading and discarding this file.
- if (!okay) {
- if (MORE_DEBUG) Slog.d(TAG, "[discarding file content]");
- long bytesToConsume = (info.size + 511) & ~511;
- while (bytesToConsume > 0) {
- int toRead = (bytesToConsume > mBuffer.length)
- ? mBuffer.length : (int)bytesToConsume;
- long nRead = instream.read(mBuffer, 0, toRead);
- if (nRead >= 0) mBytes += nRead;
- if (nRead <= 0) break;
- bytesToConsume -= nRead;
- }
- }
- }
- }
- } catch (IOException e) {
- if (DEBUG) Slog.w(TAG, "io exception on restore socket read: " + e.getMessage());
- setResult(RestoreEngine.TRANSPORT_FAILURE);
- info = null;
- }
-
- // If we got here we're either running smoothly or we've finished
- if (info == null) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "No [more] data for this package; tearing down");
- }
- tearDownPipes();
- setRunning(false);
- if (mustKillAgent) {
- tearDownAgent(mTargetApp);
- }
- }
- return (info != null);
- }
-
- void setUpPipes() throws IOException {
- mPipes = ParcelFileDescriptor.createPipe();
- }
-
- void tearDownPipes() {
- // Teardown might arise from the inline restore processing or from the asynchronous
- // timeout mechanism, and these might race. Make sure we don't try to close and
- // null out the pipes twice.
- synchronized (this) {
- if (mPipes != null) {
- try {
- mPipes[0].close();
- mPipes[0] = null;
- mPipes[1].close();
- mPipes[1] = null;
- } catch (IOException e) {
- Slog.w(TAG, "Couldn't close agent pipes", e);
- }
- mPipes = null;
- }
- }
- }
-
- void tearDownAgent(ApplicationInfo app) {
- if (mAgent != null) {
- tearDownAgentAndKill(app);
- mAgent = null;
- }
- }
-
- void handleTimeout() {
- tearDownPipes();
- setResult(RestoreEngine.TARGET_FAILURE);
- setRunning(false);
- }
-
- class RestoreInstallObserver extends PackageInstallObserver {
- final AtomicBoolean mDone = new AtomicBoolean();
- String mPackageName;
- int mResult;
-
- public void reset() {
- synchronized (mDone) {
- mDone.set(false);
- }
- }
-
- public void waitForCompletion() {
- synchronized (mDone) {
- while (mDone.get() == false) {
- try {
- mDone.wait();
- } catch (InterruptedException e) { }
- }
- }
- }
-
- int getResult() {
- return mResult;
- }
-
- @Override
- public void onPackageInstalled(String packageName, int returnCode,
- String msg, Bundle extras) {
- synchronized (mDone) {
- mResult = returnCode;
- mPackageName = packageName;
- mDone.set(true);
- mDone.notifyAll();
- }
- }
- }
-
- class RestoreDeleteObserver extends IPackageDeleteObserver.Stub {
- final AtomicBoolean mDone = new AtomicBoolean();
- int mResult;
-
- public void reset() {
- synchronized (mDone) {
- mDone.set(false);
- }
- }
-
- public void waitForCompletion() {
- synchronized (mDone) {
- while (mDone.get() == false) {
- try {
- mDone.wait();
- } catch (InterruptedException e) { }
- }
- }
- }
-
- @Override
- public void packageDeleted(String packageName, int returnCode) throws RemoteException {
- synchronized (mDone) {
- mResult = returnCode;
- mDone.set(true);
- mDone.notifyAll();
- }
- }
- }
-
- final RestoreInstallObserver mInstallObserver = new RestoreInstallObserver();
- final RestoreDeleteObserver mDeleteObserver = new RestoreDeleteObserver();
-
- boolean installApk(FileMetadata info, String installerPackage, InputStream instream) {
- boolean okay = true;
-
- if (DEBUG) Slog.d(TAG, "Installing from backup: " + info.packageName);
-
- // The file content is an .apk file. Copy it out to a staging location and
- // attempt to install it.
- File apkFile = new File(mDataDir, info.packageName);
- try {
- FileOutputStream apkStream = new FileOutputStream(apkFile);
- byte[] buffer = new byte[32 * 1024];
- long size = info.size;
- while (size > 0) {
- long toRead = (buffer.length < size) ? buffer.length : size;
- int didRead = instream.read(buffer, 0, (int)toRead);
- if (didRead >= 0) mBytes += didRead;
- apkStream.write(buffer, 0, didRead);
- size -= didRead;
- }
- apkStream.close();
-
- // make sure the installer can read it
- apkFile.setReadable(true, false);
-
- // Now install it
- Uri packageUri = Uri.fromFile(apkFile);
- mInstallObserver.reset();
- mPackageManager.installPackage(packageUri, mInstallObserver,
- PackageManager.INSTALL_REPLACE_EXISTING | PackageManager.INSTALL_FROM_ADB,
- installerPackage);
- mInstallObserver.waitForCompletion();
-
- if (mInstallObserver.getResult() != PackageManager.INSTALL_SUCCEEDED) {
- // The only time we continue to accept install of data even if the
- // apk install failed is if we had already determined that we could
- // accept the data regardless.
- if (mPackagePolicies.get(info.packageName) != RestorePolicy.ACCEPT) {
- okay = false;
- }
- } else {
- // Okay, the install succeeded. Make sure it was the right app.
- boolean uninstall = false;
- if (!mInstallObserver.mPackageName.equals(info.packageName)) {
- Slog.w(TAG, "Restore stream claimed to include apk for "
- + info.packageName + " but apk was really "
- + mInstallObserver.mPackageName);
- // delete the package we just put in place; it might be fraudulent
- okay = false;
- uninstall = true;
- } else {
- try {
- PackageInfo pkg = mPackageManager.getPackageInfo(info.packageName,
- PackageManager.GET_SIGNATURES);
- if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_ALLOW_BACKUP) == 0) {
- Slog.w(TAG, "Restore stream contains apk of package "
- + info.packageName + " but it disallows backup/restore");
- okay = false;
- } else {
- // So far so good -- do the signatures match the manifest?
- Signature[] sigs = mManifestSignatures.get(info.packageName);
- if (signaturesMatch(sigs, pkg)) {
- // If this is a system-uid app without a declared backup agent,
- // don't restore any of the file data.
- if ((pkg.applicationInfo.uid < Process.FIRST_APPLICATION_UID)
- && (pkg.applicationInfo.backupAgentName == null)) {
- Slog.w(TAG, "Installed app " + info.packageName
- + " has restricted uid and no agent");
- okay = false;
- }
- } else {
- Slog.w(TAG, "Installed app " + info.packageName
- + " signatures do not match restore manifest");
- okay = false;
- uninstall = true;
- }
- }
- } catch (NameNotFoundException e) {
- Slog.w(TAG, "Install of package " + info.packageName
- + " succeeded but now not found");
- okay = false;
- }
- }
-
- // If we're not okay at this point, we need to delete the package
- // that we just installed.
- if (uninstall) {
- mDeleteObserver.reset();
- mPackageManager.deletePackage(mInstallObserver.mPackageName,
- mDeleteObserver, 0);
- mDeleteObserver.waitForCompletion();
- }
- }
- } catch (IOException e) {
- Slog.e(TAG, "Unable to transcribe restored apk for install");
- okay = false;
- } finally {
- apkFile.delete();
- }
-
- return okay;
- }
-
- // Given an actual file content size, consume the post-content padding mandated
- // by the tar format.
- void skipTarPadding(long size, InputStream instream) throws IOException {
- long partial = (size + 512) % 512;
- if (partial > 0) {
- final int needed = 512 - (int)partial;
- if (MORE_DEBUG) {
- Slog.i(TAG, "Skipping tar padding: " + needed + " bytes");
- }
- byte[] buffer = new byte[needed];
- if (readExactly(instream, buffer, 0, needed) == needed) {
- mBytes += needed;
- } else throw new IOException("Unexpected EOF in padding");
- }
- }
-
- // Read a widget metadata file, returning the restored blob
- void readMetadata(FileMetadata info, InputStream instream) throws IOException {
- // Fail on suspiciously large widget dump files
- if (info.size > 64 * 1024) {
- throw new IOException("Metadata too big; corrupt? size=" + info.size);
- }
-
- byte[] buffer = new byte[(int) info.size];
- if (readExactly(instream, buffer, 0, (int)info.size) == info.size) {
- mBytes += info.size;
- } else throw new IOException("Unexpected EOF in widget data");
-
- String[] str = new String[1];
- int offset = extractLine(buffer, 0, str);
- int version = Integer.parseInt(str[0]);
- if (version == BACKUP_MANIFEST_VERSION) {
- offset = extractLine(buffer, offset, str);
- final String pkg = str[0];
- if (info.packageName.equals(pkg)) {
- // Data checks out -- the rest of the buffer is a concatenation of
- // binary blobs as described in the comment at writeAppWidgetData()
- ByteArrayInputStream bin = new ByteArrayInputStream(buffer,
- offset, buffer.length - offset);
- DataInputStream in = new DataInputStream(bin);
- while (bin.available() > 0) {
- int token = in.readInt();
- int size = in.readInt();
- if (size > 64 * 1024) {
- throw new IOException("Datum "
- + Integer.toHexString(token)
- + " too big; corrupt? size=" + info.size);
- }
- switch (token) {
- case BACKUP_WIDGET_METADATA_TOKEN:
- {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Got widget metadata for " + info.packageName);
- }
- mWidgetData = new byte[size];
- in.read(mWidgetData);
- break;
- }
- default:
- {
- if (DEBUG) {
- Slog.i(TAG, "Ignoring metadata blob "
- + Integer.toHexString(token)
- + " for " + info.packageName);
- }
- in.skipBytes(size);
- break;
- }
- }
- }
- } else {
- Slog.w(TAG, "Metadata mismatch: package " + info.packageName
- + " but widget data for " + pkg);
-
- Bundle monitoringExtras = putMonitoringExtra(null,
- EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName);
- monitoringExtras = putMonitoringExtra(monitoringExtras,
- BackupManagerMonitor.EXTRA_LOG_WIDGET_PACKAGE_NAME, pkg);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_WIDGET_METADATA_MISMATCH,
- null,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- monitoringExtras);
- }
- } else {
- Slog.w(TAG, "Unsupported metadata version " + version);
-
- Bundle monitoringExtras = putMonitoringExtra(null, EXTRA_LOG_EVENT_PACKAGE_NAME,
- info.packageName);
- monitoringExtras = putMonitoringExtra(monitoringExtras,
- EXTRA_LOG_EVENT_PACKAGE_VERSION, version);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_WIDGET_UNKNOWN_VERSION,
- null,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- monitoringExtras);
- }
- }
-
- // Returns a policy constant
- RestorePolicy readAppManifest(FileMetadata info, InputStream instream)
- throws IOException {
- // Fail on suspiciously large manifest files
- if (info.size > 64 * 1024) {
- throw new IOException("Restore manifest too big; corrupt? size=" + info.size);
- }
-
- byte[] buffer = new byte[(int) info.size];
- if (MORE_DEBUG) {
- Slog.i(TAG, " readAppManifest() looking for " + info.size + " bytes, "
- + mBytes + " already consumed");
- }
- if (readExactly(instream, buffer, 0, (int)info.size) == info.size) {
- mBytes += info.size;
- } else throw new IOException("Unexpected EOF in manifest");
-
- RestorePolicy policy = RestorePolicy.IGNORE;
- String[] str = new String[1];
- int offset = 0;
-
- try {
- offset = extractLine(buffer, offset, str);
- int version = Integer.parseInt(str[0]);
- if (version == BACKUP_MANIFEST_VERSION) {
- offset = extractLine(buffer, offset, str);
- String manifestPackage = str[0];
- // TODO: handle <original-package>
- if (manifestPackage.equals(info.packageName)) {
- offset = extractLine(buffer, offset, str);
- version = Integer.parseInt(str[0]); // app version
- offset = extractLine(buffer, offset, str);
- // This is the platform version, which we don't use, but we parse it
- // as a safety against corruption in the manifest.
- Integer.parseInt(str[0]);
- offset = extractLine(buffer, offset, str);
- info.installerPackageName = (str[0].length() > 0) ? str[0] : null;
- offset = extractLine(buffer, offset, str);
- boolean hasApk = str[0].equals("1");
- offset = extractLine(buffer, offset, str);
- int numSigs = Integer.parseInt(str[0]);
- if (numSigs > 0) {
- Signature[] sigs = new Signature[numSigs];
- for (int i = 0; i < numSigs; i++) {
- offset = extractLine(buffer, offset, str);
- sigs[i] = new Signature(str[0]);
- }
- mManifestSignatures.put(info.packageName, sigs);
-
- // Okay, got the manifest info we need...
- try {
- PackageInfo pkgInfo = mPackageManager.getPackageInfo(
- info.packageName, PackageManager.GET_SIGNATURES);
- // Fall through to IGNORE if the app explicitly disallows backup
- final int flags = pkgInfo.applicationInfo.flags;
- if ((flags & ApplicationInfo.FLAG_ALLOW_BACKUP) != 0) {
- // Restore system-uid-space packages only if they have
- // defined a custom backup agent
- if ((pkgInfo.applicationInfo.uid >= Process.FIRST_APPLICATION_UID)
- || (pkgInfo.applicationInfo.backupAgentName != null)) {
- // Verify signatures against any installed version; if they
- // don't match, then we fall though and ignore the data. The
- // signatureMatch() method explicitly ignores the signature
- // check for packages installed on the system partition, because
- // such packages are signed with the platform cert instead of
- // the app developer's cert, so they're different on every
- // device.
- if (signaturesMatch(sigs, pkgInfo)) {
- if ((pkgInfo.applicationInfo.flags
- & ApplicationInfo.FLAG_RESTORE_ANY_VERSION) != 0) {
- Slog.i(TAG, "Package has restoreAnyVersion; taking data");
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_RESTORE_ANY_VERSION,
- pkgInfo,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- policy = RestorePolicy.ACCEPT;
- } else if (pkgInfo.versionCode >= version) {
- Slog.i(TAG, "Sig + version match; taking data");
- policy = RestorePolicy.ACCEPT;
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_VERSIONS_MATCH,
- pkgInfo,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- } else {
- // The data is from a newer version of the app than
- // is presently installed. That means we can only
- // use it if the matching apk is also supplied.
- if (mAllowApks) {
- Slog.i(TAG, "Data version " + version
- + " is newer than installed version "
- + pkgInfo.versionCode
- + " - requiring apk");
- policy = RestorePolicy.ACCEPT_IF_APK;
- } else {
- Slog.i(TAG, "Data requires newer version "
- + version + "; ignoring");
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_VERSION_OF_BACKUP_OLDER,
- pkgInfo,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- putMonitoringExtra(null,
- EXTRA_LOG_OLD_VERSION,
- version));
-
- policy = RestorePolicy.IGNORE;
- }
- }
- } else {
- Slog.w(TAG, "Restore manifest signatures do not match "
- + "installed application for " + info.packageName);
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_FULL_RESTORE_SIGNATURE_MISMATCH,
- pkgInfo,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- }
- } else {
- Slog.w(TAG, "Package " + info.packageName
- + " is system level with no agent");
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_SYSTEM_APP_NO_AGENT,
- pkgInfo,
- LOG_EVENT_CATEGORY_AGENT,
- null);
- }
- } else {
- if (DEBUG) Slog.i(TAG, "Restore manifest from "
- + info.packageName + " but allowBackup=false");
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_FULL_RESTORE_ALLOW_BACKUP_FALSE,
- pkgInfo,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- }
- } catch (NameNotFoundException e) {
- // Okay, the target app isn't installed. We can process
- // the restore properly only if the dataset provides the
- // apk file and we can successfully install it.
- if (mAllowApks) {
- if (DEBUG) Slog.i(TAG, "Package " + info.packageName
- + " not installed; requiring apk in dataset");
- policy = RestorePolicy.ACCEPT_IF_APK;
- } else {
- policy = RestorePolicy.IGNORE;
- }
- Bundle monitoringExtras = putMonitoringExtra(null,
- EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName);
- monitoringExtras = putMonitoringExtra(monitoringExtras,
- EXTRA_LOG_POLICY_ALLOW_APKS, mAllowApks);
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_APK_NOT_INSTALLED,
- null,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- monitoringExtras);
- }
-
- if (policy == RestorePolicy.ACCEPT_IF_APK && !hasApk) {
- Slog.i(TAG, "Cannot restore package " + info.packageName
- + " without the matching .apk");
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_CANNOT_RESTORE_WITHOUT_APK,
- null,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- putMonitoringExtra(null,
- EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName));
- }
- } else {
- Slog.i(TAG, "Missing signature on backed-up package "
- + info.packageName);
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_MISSING_SIGNATURE,
- null,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- putMonitoringExtra(null,
- EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName));
- }
- } else {
- Slog.i(TAG, "Expected package " + info.packageName
- + " but restore manifest claims " + manifestPackage);
- Bundle monitoringExtras = putMonitoringExtra(null,
- EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName);
- monitoringExtras = putMonitoringExtra(monitoringExtras,
- EXTRA_LOG_MANIFEST_PACKAGE_NAME, manifestPackage);
- mMonitor = monitorEvent(mMonitor,
- LOG_EVENT_ID_EXPECTED_DIFFERENT_PACKAGE,
- null,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- monitoringExtras);
- }
- } else {
- Slog.i(TAG, "Unknown restore manifest version " + version
- + " for package " + info.packageName);
- Bundle monitoringExtras = putMonitoringExtra(null,
- EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName);
- monitoringExtras = putMonitoringExtra(monitoringExtras,
- EXTRA_LOG_EVENT_PACKAGE_VERSION, version);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_UNKNOWN_VERSION,
- null,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- monitoringExtras);
-
- }
- } catch (NumberFormatException e) {
- Slog.w(TAG, "Corrupt restore manifest for package " + info.packageName);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_CORRUPT_MANIFEST,
- null,
- LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- putMonitoringExtra(null, EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName));
- } catch (IllegalArgumentException e) {
- Slog.w(TAG, e.getMessage());
- }
-
- return policy;
- }
-
- // Builds a line from a byte buffer starting at 'offset', and returns
- // the index of the next unconsumed data in the buffer.
- int extractLine(byte[] buffer, int offset, String[] outStr) throws IOException {
- final int end = buffer.length;
- if (offset >= end) throw new IOException("Incomplete data");
-
- int pos;
- for (pos = offset; pos < end; pos++) {
- byte c = buffer[pos];
- // at LF we declare end of line, and return the next char as the
- // starting point for the next time through
- if (c == '\n') {
- break;
- }
- }
- outStr[0] = new String(buffer, offset, pos - offset);
- pos++; // may be pointing an extra byte past the end but that's okay
- return pos;
- }
-
- void dumpFileMetadata(FileMetadata info) {
- if (MORE_DEBUG) {
- StringBuilder b = new StringBuilder(128);
-
- // mode string
- b.append((info.type == BackupAgent.TYPE_DIRECTORY) ? 'd' : '-');
- b.append(((info.mode & 0400) != 0) ? 'r' : '-');
- b.append(((info.mode & 0200) != 0) ? 'w' : '-');
- b.append(((info.mode & 0100) != 0) ? 'x' : '-');
- b.append(((info.mode & 0040) != 0) ? 'r' : '-');
- b.append(((info.mode & 0020) != 0) ? 'w' : '-');
- b.append(((info.mode & 0010) != 0) ? 'x' : '-');
- b.append(((info.mode & 0004) != 0) ? 'r' : '-');
- b.append(((info.mode & 0002) != 0) ? 'w' : '-');
- b.append(((info.mode & 0001) != 0) ? 'x' : '-');
- b.append(String.format(" %9d ", info.size));
-
- Date stamp = new Date(info.mtime);
- b.append(new SimpleDateFormat("MMM dd HH:mm:ss ").format(stamp));
-
- b.append(info.packageName);
- b.append(" :: ");
- b.append(info.domain);
- b.append(" :: ");
- b.append(info.path);
-
- Slog.i(TAG, b.toString());
- }
- }
-
- // Consume a tar file header block [sequence] and accumulate the relevant metadata
- FileMetadata readTarHeaders(InputStream instream) throws IOException {
- byte[] block = new byte[512];
- FileMetadata info = null;
-
- boolean gotHeader = readTarHeader(instream, block);
- if (gotHeader) {
- try {
- // okay, presume we're okay, and extract the various metadata
- info = new FileMetadata();
- info.size = extractRadix(block, TAR_HEADER_OFFSET_FILESIZE,
- TAR_HEADER_LENGTH_FILESIZE, TAR_HEADER_LONG_RADIX);
- info.mtime = extractRadix(block, TAR_HEADER_OFFSET_MODTIME,
- TAR_HEADER_LENGTH_MODTIME, TAR_HEADER_LONG_RADIX);
- info.mode = extractRadix(block, TAR_HEADER_OFFSET_MODE,
- TAR_HEADER_LENGTH_MODE, TAR_HEADER_LONG_RADIX);
-
- info.path = extractString(block, TAR_HEADER_OFFSET_PATH_PREFIX,
- TAR_HEADER_LENGTH_PATH_PREFIX);
- String path = extractString(block, TAR_HEADER_OFFSET_PATH,
- TAR_HEADER_LENGTH_PATH);
- if (path.length() > 0) {
- if (info.path.length() > 0) info.path += '/';
- info.path += path;
- }
-
- // tar link indicator field: 1 byte at offset 156 in the header.
- int typeChar = block[TAR_HEADER_OFFSET_TYPE_CHAR];
- if (typeChar == 'x') {
- // pax extended header, so we need to read that
- gotHeader = readPaxExtendedHeader(instream, info);
- if (gotHeader) {
- // and after a pax extended header comes another real header -- read
- // that to find the real file type
- gotHeader = readTarHeader(instream, block);
- }
- if (!gotHeader) throw new IOException("Bad or missing pax header");
-
- typeChar = block[TAR_HEADER_OFFSET_TYPE_CHAR];
- }
-
- switch (typeChar) {
- case '0': info.type = BackupAgent.TYPE_FILE; break;
- case '5': {
- info.type = BackupAgent.TYPE_DIRECTORY;
- if (info.size != 0) {
- Slog.w(TAG, "Directory entry with nonzero size in header");
- info.size = 0;
- }
- break;
- }
- case 0: {
- // presume EOF
- if (MORE_DEBUG) Slog.w(TAG, "Saw type=0 in tar header block, info=" + info);
- return null;
- }
- default: {
- Slog.e(TAG, "Unknown tar entity type: " + typeChar);
- throw new IOException("Unknown entity type " + typeChar);
- }
- }
-
- // Parse out the path
- //
- // first: apps/shared/unrecognized
- if (FullBackup.SHARED_PREFIX.regionMatches(0,
- info.path, 0, FullBackup.SHARED_PREFIX.length())) {
- // File in shared storage. !!! TODO: implement this.
- info.path = info.path.substring(FullBackup.SHARED_PREFIX.length());
- info.packageName = SHARED_BACKUP_AGENT_PACKAGE;
- info.domain = FullBackup.SHARED_STORAGE_TOKEN;
- if (DEBUG) Slog.i(TAG, "File in shared storage: " + info.path);
- } else if (FullBackup.APPS_PREFIX.regionMatches(0,
- info.path, 0, FullBackup.APPS_PREFIX.length())) {
- // App content! Parse out the package name and domain
-
- // strip the apps/ prefix
- info.path = info.path.substring(FullBackup.APPS_PREFIX.length());
-
- // extract the package name
- int slash = info.path.indexOf('/');
- if (slash < 0) throw new IOException("Illegal semantic path in " + info.path);
- info.packageName = info.path.substring(0, slash);
- info.path = info.path.substring(slash+1);
-
- // if it's a manifest or metadata payload we're done, otherwise parse
- // out the domain into which the file will be restored
- if (!info.path.equals(BACKUP_MANIFEST_FILENAME)
- && !info.path.equals(BACKUP_METADATA_FILENAME)) {
- slash = info.path.indexOf('/');
- if (slash < 0) {
- throw new IOException("Illegal semantic path in non-manifest "
- + info.path);
- }
- info.domain = info.path.substring(0, slash);
- info.path = info.path.substring(slash + 1);
- }
- }
- } catch (IOException e) {
- if (DEBUG) {
- Slog.e(TAG, "Parse error in header: " + e.getMessage());
- if (MORE_DEBUG) {
- HEXLOG(block);
- }
- }
- throw e;
- }
- }
- return info;
- }
-
- private boolean isRestorableFile(FileMetadata info) {
- if (FullBackup.CACHE_TREE_TOKEN.equals(info.domain)) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Dropping cache file path " + info.path);
- }
- return false;
- }
-
- if (FullBackup.ROOT_TREE_TOKEN.equals(info.domain)) {
- // It's possible this is "no-backup" dir contents in an archive stream
- // produced on a device running a version of the OS that predates that
- // API. Respect the no-backup intention and don't let the data get to
- // the app.
- if (info.path.startsWith("no_backup/")) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Dropping no_backup file path " + info.path);
- }
- return false;
- }
- }
-
- // The path needs to be canonical
- if (info.path.contains("..") || info.path.contains("//")) {
- if (MORE_DEBUG) {
- Slog.w(TAG, "Dropping invalid path " + info.path);
- }
- return false;
- }
-
- // Otherwise we think this file is good to go
- return true;
- }
-
- private void HEXLOG(byte[] block) {
- int offset = 0;
- int todo = block.length;
- StringBuilder buf = new StringBuilder(64);
- while (todo > 0) {
- buf.append(String.format("%04x ", offset));
- int numThisLine = (todo > 16) ? 16 : todo;
- for (int i = 0; i < numThisLine; i++) {
- buf.append(String.format("%02x ", block[offset+i]));
- }
- Slog.i("hexdump", buf.toString());
- buf.setLength(0);
- todo -= numThisLine;
- offset += numThisLine;
- }
- }
-
- // Read exactly the given number of bytes into a buffer at the stated offset.
- // Returns false if EOF is encountered before the requested number of bytes
- // could be read.
- int readExactly(InputStream in, byte[] buffer, int offset, int size)
- throws IOException {
- if (size <= 0) throw new IllegalArgumentException("size must be > 0");
-if (MORE_DEBUG) Slog.i(TAG, " ... readExactly(" + size + ") called");
- int soFar = 0;
- while (soFar < size) {
- int nRead = in.read(buffer, offset + soFar, size - soFar);
- if (nRead <= 0) {
- if (MORE_DEBUG) Slog.w(TAG, "- wanted exactly " + size + " but got only " + soFar);
- break;
- }
- soFar += nRead;
-if (MORE_DEBUG) Slog.v(TAG, " + got " + nRead + "; now wanting " + (size - soFar));
- }
- return soFar;
- }
-
- boolean readTarHeader(InputStream instream, byte[] block) throws IOException {
- final int got = readExactly(instream, block, 0, 512);
- if (got == 0) return false; // Clean EOF
- if (got < 512) throw new IOException("Unable to read full block header");
- mBytes += 512;
- return true;
- }
-
- // overwrites 'info' fields based on the pax extended header
- boolean readPaxExtendedHeader(InputStream instream, FileMetadata info)
- throws IOException {
- // We should never see a pax extended header larger than this
- if (info.size > 32*1024) {
- Slog.w(TAG, "Suspiciously large pax header size " + info.size
- + " - aborting");
- throw new IOException("Sanity failure: pax header size " + info.size);
- }
-
- // read whole blocks, not just the content size
- int numBlocks = (int)((info.size + 511) >> 9);
- byte[] data = new byte[numBlocks * 512];
- if (readExactly(instream, data, 0, data.length) < data.length) {
- throw new IOException("Unable to read full pax header");
- }
- mBytes += data.length;
-
- final int contentSize = (int) info.size;
- int offset = 0;
- do {
- // extract the line at 'offset'
- int eol = offset+1;
- while (eol < contentSize && data[eol] != ' ') eol++;
- if (eol >= contentSize) {
- // error: we just hit EOD looking for the end of the size field
- throw new IOException("Invalid pax data");
- }
- // eol points to the space between the count and the key
- int linelen = (int) extractRadix(data, offset, eol - offset, 10);
- int key = eol + 1; // start of key=value
- eol = offset + linelen - 1; // trailing LF
- int value;
- for (value = key+1; data[value] != '=' && value <= eol; value++);
- if (value > eol) {
- throw new IOException("Invalid pax declaration");
- }
-
- // pax requires that key/value strings be in UTF-8
- String keyStr = new String(data, key, value-key, "UTF-8");
- // -1 to strip the trailing LF
- String valStr = new String(data, value+1, eol-value-1, "UTF-8");
-
- if ("path".equals(keyStr)) {
- info.path = valStr;
- } else if ("size".equals(keyStr)) {
- info.size = Long.parseLong(valStr);
- } else {
- if (DEBUG) Slog.i(TAG, "Unhandled pax key: " + key);
- }
-
- offset += linelen;
- } while (offset < contentSize);
-
- return true;
- }
-
- long extractRadix(byte[] data, int offset, int maxChars, int radix)
- throws IOException {
- long value = 0;
- final int end = offset + maxChars;
- for (int i = offset; i < end; i++) {
- final byte b = data[i];
- // Numeric fields in tar can terminate with either NUL or SPC
- if (b == 0 || b == ' ') break;
- if (b < '0' || b > ('0' + radix - 1)) {
- throw new IOException("Invalid number in header: '" + (char)b
- + "' for radix " + radix);
- }
- value = radix * value + (b - '0');
- }
- return value;
- }
-
- String extractString(byte[] data, int offset, int maxChars) throws IOException {
- final int end = offset + maxChars;
- int eos = offset;
- // tar string fields terminate early with a NUL
- while (eos < end && data[eos] != 0) eos++;
- return new String(data, offset, eos-offset, "US-ASCII");
- }
-
- void sendStartRestore() {
- if (mObserver != null) {
- try {
- mObserver.onStartRestore();
- } catch (RemoteException e) {
- Slog.w(TAG, "full restore observer went away: startRestore");
- mObserver = null;
- }
- }
- }
-
- void sendOnRestorePackage(String name) {
- if (mObserver != null) {
- try {
- // TODO: use a more user-friendly name string
- mObserver.onRestorePackage(name);
- } catch (RemoteException e) {
- Slog.w(TAG, "full restore observer went away: restorePackage");
- mObserver = null;
- }
- }
- }
-
- void sendEndRestore() {
- if (mObserver != null) {
- try {
- mObserver.onEndRestore();
- } catch (RemoteException e) {
- Slog.w(TAG, "full restore observer went away: endRestore");
- mObserver = null;
- }
- }
- }
- }
-
- // ***** end new engine class ***
-
- // Used for synchronizing doRestoreFinished during adb restore
- class AdbRestoreFinishedLatch implements BackupRestoreTask {
- static final String TAG = "AdbRestoreFinishedLatch";
- final CountDownLatch mLatch;
- private final int mCurrentOpToken;
-
- AdbRestoreFinishedLatch(int currentOpToken) {
- mLatch = new CountDownLatch(1);
- mCurrentOpToken = currentOpToken;
- }
-
- void await() {
- boolean latched = false;
- try {
- latched = mLatch.await(TIMEOUT_FULL_BACKUP_INTERVAL, TimeUnit.MILLISECONDS);
- } catch (InterruptedException e) {
- Slog.w(TAG, "Interrupted!");
- }
- }
-
- @Override
- public void execute() {
- // Unused
- }
-
- @Override
- public void operationComplete(long result) {
- if (MORE_DEBUG) {
- Slog.w(TAG, "adb onRestoreFinished() complete");
- }
- mLatch.countDown();
- removeOperation(mCurrentOpToken);
- }
-
- @Override
- public void handleCancel(boolean cancelAll) {
- if (DEBUG) {
- Slog.w(TAG, "adb onRestoreFinished() timed out");
- }
- mLatch.countDown();
- removeOperation(mCurrentOpToken);
- }
- }
-
- class PerformAdbRestoreTask implements Runnable {
- ParcelFileDescriptor mInputFile;
- String mCurrentPassword;
- String mDecryptPassword;
- IFullBackupRestoreObserver mObserver;
- AtomicBoolean mLatchObject;
- IBackupAgent mAgent;
- PackageManagerBackupAgent mPackageManagerBackupAgent;
- String mAgentPackage;
- ApplicationInfo mTargetApp;
- FullBackupObbConnection mObbConnection = null;
- ParcelFileDescriptor[] mPipes = null;
- byte[] mWidgetData = null;
-
- long mBytes;
-
- // Runner that can be placed on a separate thread to do in-process invocation
- // of the "restore finished" API asynchronously. Used by adb restore.
- class RestoreFinishedRunnable implements Runnable {
- final IBackupAgent mAgent;
- final int mToken;
-
- RestoreFinishedRunnable(IBackupAgent agent, int token) {
- mAgent = agent;
- mToken = token;
- }
-
- @Override
- public void run() {
- try {
- mAgent.doRestoreFinished(mToken, mBackupManagerBinder);
- } catch (RemoteException e) {
- // never happens; this is used only for local binder calls
- }
- }
- }
-
- // possible handling states for a given package in the restore dataset
- final HashMap<String, RestorePolicy> mPackagePolicies
- = new HashMap<String, RestorePolicy>();
-
- // installer package names for each encountered app, derived from the manifests
- final HashMap<String, String> mPackageInstallers = new HashMap<String, String>();
-
- // Signatures for a given package found in its manifest file
- final HashMap<String, Signature[]> mManifestSignatures
- = new HashMap<String, Signature[]>();
-
- // Packages we've already wiped data on when restoring their first file
- final HashSet<String> mClearedPackages = new HashSet<String>();
-
- PerformAdbRestoreTask(ParcelFileDescriptor fd, String curPassword, String decryptPassword,
- IFullBackupRestoreObserver observer, AtomicBoolean latch) {
- mInputFile = fd;
- mCurrentPassword = curPassword;
- mDecryptPassword = decryptPassword;
- mObserver = observer;
- mLatchObject = latch;
- mAgent = null;
- mPackageManagerBackupAgent = makeMetadataAgent();
- mAgentPackage = null;
- mTargetApp = null;
- mObbConnection = new FullBackupObbConnection();
-
- // Which packages we've already wiped data on. We prepopulate this
- // with a whitelist of packages known to be unclearable.
- mClearedPackages.add("android");
- mClearedPackages.add(SETTINGS_PACKAGE);
- }
-
- class RestoreFileRunnable implements Runnable {
- IBackupAgent mAgent;
- FileMetadata mInfo;
- ParcelFileDescriptor mSocket;
- int mToken;
-
- RestoreFileRunnable(IBackupAgent agent, FileMetadata info,
- ParcelFileDescriptor socket, int token) throws IOException {
- mAgent = agent;
- mInfo = info;
- mToken = token;
-
- // This class is used strictly for process-local binder invocations. The
- // semantics of ParcelFileDescriptor differ in this case; in particular, we
- // do not automatically get a 'dup'ed descriptor that we can can continue
- // to use asynchronously from the caller. So, we make sure to dup it ourselves
- // before proceeding to do the restore.
- mSocket = ParcelFileDescriptor.dup(socket.getFileDescriptor());
- }
-
- @Override
- public void run() {
- try {
- mAgent.doRestoreFile(mSocket, mInfo.size, mInfo.type,
- mInfo.domain, mInfo.path, mInfo.mode, mInfo.mtime,
- mToken, mBackupManagerBinder);
- } catch (RemoteException e) {
- // never happens; this is used strictly for local binder calls
- }
- }
- }
-
- @Override
- public void run() {
- Slog.i(TAG, "--- Performing full-dataset restore ---");
- mObbConnection.establish();
- sendStartRestore();
-
- // Are we able to restore shared-storage data?
- if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
- mPackagePolicies.put(SHARED_BACKUP_AGENT_PACKAGE, RestorePolicy.ACCEPT);
- }
-
- FileInputStream rawInStream = null;
- DataInputStream rawDataIn = null;
- try {
- if (!backupPasswordMatches(mCurrentPassword)) {
- if (DEBUG) Slog.w(TAG, "Backup password mismatch; aborting");
- return;
- }
-
- mBytes = 0;
- byte[] buffer = new byte[32 * 1024];
- rawInStream = new FileInputStream(mInputFile.getFileDescriptor());
- rawDataIn = new DataInputStream(rawInStream);
-
- // First, parse out the unencrypted/uncompressed header
- boolean compressed = false;
- InputStream preCompressStream = rawInStream;
- final InputStream in;
-
- boolean okay = false;
- final int headerLen = BACKUP_FILE_HEADER_MAGIC.length();
- byte[] streamHeader = new byte[headerLen];
- rawDataIn.readFully(streamHeader);
- byte[] magicBytes = BACKUP_FILE_HEADER_MAGIC.getBytes("UTF-8");
- if (Arrays.equals(magicBytes, streamHeader)) {
- // okay, header looks good. now parse out the rest of the fields.
- String s = readHeaderLine(rawInStream);
- final int archiveVersion = Integer.parseInt(s);
- if (archiveVersion <= BACKUP_FILE_VERSION) {
- // okay, it's a version we recognize. if it's version 1, we may need
- // to try two different PBKDF2 regimes to compare checksums.
- final boolean pbkdf2Fallback = (archiveVersion == 1);
-
- s = readHeaderLine(rawInStream);
- compressed = (Integer.parseInt(s) != 0);
- s = readHeaderLine(rawInStream);
- if (s.equals("none")) {
- // no more header to parse; we're good to go
- okay = true;
- } else if (mDecryptPassword != null && mDecryptPassword.length() > 0) {
- preCompressStream = decodeAesHeaderAndInitialize(s, pbkdf2Fallback,
- rawInStream);
- if (preCompressStream != null) {
- okay = true;
- }
- } else Slog.w(TAG, "Archive is encrypted but no password given");
- } else Slog.w(TAG, "Wrong header version: " + s);
- } else Slog.w(TAG, "Didn't read the right header magic");
-
- if (!okay) {
- Slog.w(TAG, "Invalid restore data; aborting.");
- return;
- }
-
- // okay, use the right stream layer based on compression
- in = (compressed) ? new InflaterInputStream(preCompressStream) : preCompressStream;
-
- boolean didRestore;
- do {
- didRestore = restoreOneFile(in, buffer);
- } while (didRestore);
-
- if (MORE_DEBUG) Slog.v(TAG, "Done consuming input tarfile, total bytes=" + mBytes);
- } catch (IOException e) {
- Slog.e(TAG, "Unable to read restore input");
- } finally {
- tearDownPipes();
- tearDownAgent(mTargetApp, true);
-
- try {
- if (rawDataIn != null) rawDataIn.close();
- if (rawInStream != null) rawInStream.close();
- mInputFile.close();
- } catch (IOException e) {
- Slog.w(TAG, "Close of restore data pipe threw", e);
- /* nothing we can do about this */
- }
- synchronized (mLatchObject) {
- mLatchObject.set(true);
- mLatchObject.notifyAll();
- }
- mObbConnection.tearDown();
- sendEndRestore();
- Slog.d(TAG, "Full restore pass complete.");
- mWakelock.release();
- }
- }
-
- String readHeaderLine(InputStream in) throws IOException {
- int c;
- StringBuilder buffer = new StringBuilder(80);
- while ((c = in.read()) >= 0) {
- if (c == '\n') break; // consume and discard the newlines
- buffer.append((char)c);
- }
- return buffer.toString();
- }
-
- InputStream attemptMasterKeyDecryption(String algorithm, byte[] userSalt, byte[] ckSalt,
- int rounds, String userIvHex, String masterKeyBlobHex, InputStream rawInStream,
- boolean doLog) {
- InputStream result = null;
-
- try {
- Cipher c = Cipher.getInstance("AES/CBC/PKCS5Padding");
- SecretKey userKey = buildPasswordKey(algorithm, mDecryptPassword, userSalt,
- rounds);
- byte[] IV = hexToByteArray(userIvHex);
- IvParameterSpec ivSpec = new IvParameterSpec(IV);
- c.init(Cipher.DECRYPT_MODE,
- new SecretKeySpec(userKey.getEncoded(), "AES"),
- ivSpec);
- byte[] mkCipher = hexToByteArray(masterKeyBlobHex);
- byte[] mkBlob = c.doFinal(mkCipher);
-
- // first, the master key IV
- int offset = 0;
- int len = mkBlob[offset++];
- IV = Arrays.copyOfRange(mkBlob, offset, offset + len);
- offset += len;
- // then the master key itself
- len = mkBlob[offset++];
- byte[] mk = Arrays.copyOfRange(mkBlob,
- offset, offset + len);
- offset += len;
- // and finally the master key checksum hash
- len = mkBlob[offset++];
- byte[] mkChecksum = Arrays.copyOfRange(mkBlob,
- offset, offset + len);
-
- // now validate the decrypted master key against the checksum
- byte[] calculatedCk = makeKeyChecksum(algorithm, mk, ckSalt, rounds);
- if (Arrays.equals(calculatedCk, mkChecksum)) {
- ivSpec = new IvParameterSpec(IV);
- c.init(Cipher.DECRYPT_MODE,
- new SecretKeySpec(mk, "AES"),
- ivSpec);
- // Only if all of the above worked properly will 'result' be assigned
- result = new CipherInputStream(rawInStream, c);
- } else if (doLog) Slog.w(TAG, "Incorrect password");
- } catch (InvalidAlgorithmParameterException e) {
- if (doLog) Slog.e(TAG, "Needed parameter spec unavailable!", e);
- } catch (BadPaddingException e) {
- // This case frequently occurs when the wrong password is used to decrypt
- // the master key. Use the identical "incorrect password" log text as is
- // used in the checksum failure log in order to avoid providing additional
- // information to an attacker.
- if (doLog) Slog.w(TAG, "Incorrect password");
- } catch (IllegalBlockSizeException e) {
- if (doLog) Slog.w(TAG, "Invalid block size in master key");
- } catch (NoSuchAlgorithmException e) {
- if (doLog) Slog.e(TAG, "Needed decryption algorithm unavailable!");
- } catch (NoSuchPaddingException e) {
- if (doLog) Slog.e(TAG, "Needed padding mechanism unavailable!");
- } catch (InvalidKeyException e) {
- if (doLog) Slog.w(TAG, "Illegal password; aborting");
- }
-
- return result;
- }
-
- InputStream decodeAesHeaderAndInitialize(String encryptionName, boolean pbkdf2Fallback,
- InputStream rawInStream) {
- InputStream result = null;
- try {
- if (encryptionName.equals(ENCRYPTION_ALGORITHM_NAME)) {
-
- String userSaltHex = readHeaderLine(rawInStream); // 5
- byte[] userSalt = hexToByteArray(userSaltHex);
-
- String ckSaltHex = readHeaderLine(rawInStream); // 6
- byte[] ckSalt = hexToByteArray(ckSaltHex);
-
- int rounds = Integer.parseInt(readHeaderLine(rawInStream)); // 7
- String userIvHex = readHeaderLine(rawInStream); // 8
-
- String masterKeyBlobHex = readHeaderLine(rawInStream); // 9
-
- // decrypt the master key blob
- result = attemptMasterKeyDecryption(PBKDF_CURRENT, userSalt, ckSalt,
- rounds, userIvHex, masterKeyBlobHex, rawInStream, false);
- if (result == null && pbkdf2Fallback) {
- result = attemptMasterKeyDecryption(PBKDF_FALLBACK, userSalt, ckSalt,
- rounds, userIvHex, masterKeyBlobHex, rawInStream, true);
- }
- } else Slog.w(TAG, "Unsupported encryption method: " + encryptionName);
- } catch (NumberFormatException e) {
- Slog.w(TAG, "Can't parse restore data header");
- } catch (IOException e) {
- Slog.w(TAG, "Can't read input header");
- }
-
- return result;
- }
-
- boolean restoreOneFile(InputStream instream, byte[] buffer) {
- FileMetadata info;
- try {
- info = readTarHeaders(instream);
- if (info != null) {
- if (MORE_DEBUG) {
- dumpFileMetadata(info);
- }
-
- final String pkg = info.packageName;
- if (!pkg.equals(mAgentPackage)) {
- // okay, change in package; set up our various
- // bookkeeping if we haven't seen it yet
- if (!mPackagePolicies.containsKey(pkg)) {
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- }
-
- // Clean up the previous agent relationship if necessary,
- // and let the observer know we're considering a new app.
- if (mAgent != null) {
- if (DEBUG) Slog.d(TAG, "Saw new package; finalizing old one");
- // Now we're really done
- tearDownPipes();
- tearDownAgent(mTargetApp, true);
- mTargetApp = null;
- mAgentPackage = null;
- }
- }
-
- if (info.path.equals(BACKUP_MANIFEST_FILENAME)) {
- mPackagePolicies.put(pkg, readAppManifest(info, instream));
- mPackageInstallers.put(pkg, info.installerPackageName);
- // We've read only the manifest content itself at this point,
- // so consume the footer before looping around to the next
- // input file
- skipTarPadding(info.size, instream);
- sendOnRestorePackage(pkg);
- } else if (info.path.equals(BACKUP_METADATA_FILENAME)) {
- // Metadata blobs!
- readMetadata(info, instream);
- skipTarPadding(info.size, instream);
- } else {
- // Non-manifest, so it's actual file data. Is this a package
- // we're ignoring?
- boolean okay = true;
- RestorePolicy policy = mPackagePolicies.get(pkg);
- switch (policy) {
- case IGNORE:
- okay = false;
- break;
-
- case ACCEPT_IF_APK:
- // If we're in accept-if-apk state, then the first file we
- // see MUST be the apk.
- if (info.domain.equals(FullBackup.APK_TREE_TOKEN)) {
- if (DEBUG) Slog.d(TAG, "APK file; installing");
- // Try to install the app.
- String installerName = mPackageInstallers.get(pkg);
- okay = installApk(info, installerName, instream);
- // good to go; promote to ACCEPT
- mPackagePolicies.put(pkg, (okay)
- ? RestorePolicy.ACCEPT
- : RestorePolicy.IGNORE);
- // At this point we've consumed this file entry
- // ourselves, so just strip the tar footer and
- // go on to the next file in the input stream
- skipTarPadding(info.size, instream);
- return true;
- } else {
- // File data before (or without) the apk. We can't
- // handle it coherently in this case so ignore it.
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- okay = false;
- }
- break;
-
- case ACCEPT:
- if (info.domain.equals(FullBackup.APK_TREE_TOKEN)) {
- if (DEBUG) Slog.d(TAG, "apk present but ACCEPT");
- // we can take the data without the apk, so we
- // *want* to do so. skip the apk by declaring this
- // one file not-okay without changing the restore
- // policy for the package.
- okay = false;
- }
- break;
-
- default:
- // Something has gone dreadfully wrong when determining
- // the restore policy from the manifest. Ignore the
- // rest of this package's data.
- Slog.e(TAG, "Invalid policy from manifest");
- okay = false;
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- break;
- }
-
- // The path needs to be canonical
- if (info.path.contains("..") || info.path.contains("//")) {
- if (MORE_DEBUG) {
- Slog.w(TAG, "Dropping invalid path " + info.path);
- }
- okay = false;
- }
-
- // If the policy is satisfied, go ahead and set up to pipe the
- // data to the agent.
- if (DEBUG && okay && mAgent != null) {
- Slog.i(TAG, "Reusing existing agent instance");
- }
- if (okay && mAgent == null) {
- if (DEBUG) Slog.d(TAG, "Need to launch agent for " + pkg);
-
- try {
- mTargetApp = mPackageManager.getApplicationInfo(pkg, 0);
-
- // If we haven't sent any data to this app yet, we probably
- // need to clear it first. Check that.
- if (!mClearedPackages.contains(pkg)) {
- // apps with their own backup agents are
- // responsible for coherently managing a full
- // restore.
- if (mTargetApp.backupAgentName == null) {
- if (DEBUG) Slog.d(TAG, "Clearing app data preparatory to full restore");
- clearApplicationDataSynchronous(pkg);
- } else {
- if (DEBUG) Slog.d(TAG, "backup agent ("
- + mTargetApp.backupAgentName + ") => no clear");
- }
- mClearedPackages.add(pkg);
- } else {
- if (DEBUG) Slog.d(TAG, "We've initialized this app already; no clear required");
- }
-
- // All set; now set up the IPC and launch the agent
- setUpPipes();
- mAgent = bindToAgentSynchronous(mTargetApp,
- FullBackup.KEY_VALUE_DATA_TOKEN.equals(info.domain)
- ? ApplicationThreadConstants.BACKUP_MODE_INCREMENTAL
- : ApplicationThreadConstants.BACKUP_MODE_RESTORE_FULL);
- mAgentPackage = pkg;
- } catch (IOException e) {
- // fall through to error handling
- } catch (NameNotFoundException e) {
- // fall through to error handling
- }
-
- if (mAgent == null) {
- if (DEBUG) Slog.d(TAG, "Unable to create agent for " + pkg);
- okay = false;
- tearDownPipes();
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- }
- }
-
- // Sanity check: make sure we never give data to the wrong app. This
- // should never happen but a little paranoia here won't go amiss.
- if (okay && !pkg.equals(mAgentPackage)) {
- Slog.e(TAG, "Restoring data for " + pkg
- + " but agent is for " + mAgentPackage);
- okay = false;
- }
-
- // At this point we have an agent ready to handle the full
- // restore data as well as a pipe for sending data to
- // that agent. Tell the agent to start reading from the
- // pipe.
- if (okay) {
- boolean agentSuccess = true;
- long toCopy = info.size;
- final boolean isSharedStorage = pkg.equals(SHARED_BACKUP_AGENT_PACKAGE);
- final long timeout = isSharedStorage ?
- TIMEOUT_SHARED_BACKUP_INTERVAL : TIMEOUT_RESTORE_INTERVAL;
- final int token = generateRandomIntegerToken();
- try {
- prepareOperationTimeout(token, timeout, null,
- OP_TYPE_RESTORE_WAIT);
- if (FullBackup.OBB_TREE_TOKEN.equals(info.domain)) {
- if (DEBUG) Slog.d(TAG, "Restoring OBB file for " + pkg
- + " : " + info.path);
- mObbConnection.restoreObbFile(pkg, mPipes[0],
- info.size, info.type, info.path, info.mode,
- info.mtime, token, mBackupManagerBinder);
- } else if (FullBackup.KEY_VALUE_DATA_TOKEN.equals(info.domain)) {
- if (DEBUG) Slog.d(TAG, "Restoring key-value file for " + pkg
- + " : " + info.path);
- KeyValueAdbRestoreEngine restoreEngine =
- new KeyValueAdbRestoreEngine(BackupManagerService.this,
- mDataDir, info, mPipes[0], mAgent, token);
- new Thread(restoreEngine, "restore-key-value-runner").start();
- } else {
- if (DEBUG) Slog.d(TAG, "Invoking agent to restore file "
- + info.path);
- // fire up the app's agent listening on the socket. If
- // the agent is running in the system process we can't
- // just invoke it asynchronously, so we provide a thread
- // for it here.
- if (mTargetApp.processName.equals("system")) {
- Slog.d(TAG, "system process agent - spinning a thread");
- RestoreFileRunnable runner = new RestoreFileRunnable(
- mAgent, info, mPipes[0], token);
- new Thread(runner, "restore-sys-runner").start();
- } else {
- mAgent.doRestoreFile(mPipes[0], info.size, info.type,
- info.domain, info.path, info.mode, info.mtime,
- token, mBackupManagerBinder);
- }
- }
- } catch (IOException e) {
- // couldn't dup the socket for a process-local restore
- Slog.d(TAG, "Couldn't establish restore");
- agentSuccess = false;
- okay = false;
- } catch (RemoteException e) {
- // whoops, remote entity went away. We'll eat the content
- // ourselves, then, and not copy it over.
- Slog.e(TAG, "Agent crashed during full restore");
- agentSuccess = false;
- okay = false;
- }
-
- // Copy over the data if the agent is still good
- if (okay) {
- boolean pipeOkay = true;
- FileOutputStream pipe = new FileOutputStream(
- mPipes[1].getFileDescriptor());
- while (toCopy > 0) {
- int toRead = (toCopy > buffer.length)
- ? buffer.length : (int)toCopy;
- int nRead = instream.read(buffer, 0, toRead);
- if (nRead >= 0) mBytes += nRead;
- if (nRead <= 0) break;
- toCopy -= nRead;
-
- // send it to the output pipe as long as things
- // are still good
- if (pipeOkay) {
- try {
- pipe.write(buffer, 0, nRead);
- } catch (IOException e) {
- Slog.e(TAG, "Failed to write to restore pipe", e);
- pipeOkay = false;
- }
- }
- }
-
- // done sending that file! Now we just need to consume
- // the delta from info.size to the end of block.
- skipTarPadding(info.size, instream);
-
- // and now that we've sent it all, wait for the remote
- // side to acknowledge receipt
- agentSuccess = waitUntilOperationComplete(token);
- }
-
- // okay, if the remote end failed at any point, deal with
- // it by ignoring the rest of the restore on it
- if (!agentSuccess) {
- if (DEBUG) {
- Slog.d(TAG, "Agent failure restoring " + pkg + "; now ignoring");
- }
- mBackupHandler.removeMessages(MSG_RESTORE_OPERATION_TIMEOUT);
- tearDownPipes();
- tearDownAgent(mTargetApp, false);
- mPackagePolicies.put(pkg, RestorePolicy.IGNORE);
- }
- }
-
- // Problems setting up the agent communication, or an already-
- // ignored package: skip to the next tar stream entry by
- // reading and discarding this file.
- if (!okay) {
- if (DEBUG) Slog.d(TAG, "[discarding file content]");
- long bytesToConsume = (info.size + 511) & ~511;
- while (bytesToConsume > 0) {
- int toRead = (bytesToConsume > buffer.length)
- ? buffer.length : (int)bytesToConsume;
- long nRead = instream.read(buffer, 0, toRead);
- if (nRead >= 0) mBytes += nRead;
- if (nRead <= 0) break;
- bytesToConsume -= nRead;
- }
- }
- }
- }
- } catch (IOException e) {
- if (DEBUG) Slog.w(TAG, "io exception on restore socket read", e);
- // treat as EOF
- info = null;
- }
-
- return (info != null);
- }
-
- void setUpPipes() throws IOException {
- mPipes = ParcelFileDescriptor.createPipe();
- }
-
- void tearDownPipes() {
- if (mPipes != null) {
- try {
- mPipes[0].close();
- mPipes[0] = null;
- mPipes[1].close();
- mPipes[1] = null;
- } catch (IOException e) {
- Slog.w(TAG, "Couldn't close agent pipes", e);
- }
- mPipes = null;
- }
- }
-
- void tearDownAgent(ApplicationInfo app, boolean doRestoreFinished) {
- if (mAgent != null) {
- try {
- // In the adb restore case, we do restore-finished here
- if (doRestoreFinished) {
- final int token = generateRandomIntegerToken();
- final AdbRestoreFinishedLatch latch = new AdbRestoreFinishedLatch(token);
- prepareOperationTimeout(token, TIMEOUT_FULL_BACKUP_INTERVAL, latch,
- OP_TYPE_RESTORE_WAIT);
- if (mTargetApp.processName.equals("system")) {
- if (MORE_DEBUG) {
- Slog.d(TAG, "system agent - restoreFinished on thread");
- }
- Runnable runner = new RestoreFinishedRunnable(mAgent, token);
- new Thread(runner, "restore-sys-finished-runner").start();
- } else {
- mAgent.doRestoreFinished(token, mBackupManagerBinder);
- }
-
- latch.await();
- }
-
- // unbind and tidy up even on timeout or failure, just in case
- mActivityManager.unbindBackupAgent(app);
-
- // The agent was running with a stub Application object, so shut it down.
- // !!! We hardcode the confirmation UI's package name here rather than use a
- // manifest flag! TODO something less direct.
- if (app.uid >= Process.FIRST_APPLICATION_UID
- && !app.packageName.equals("com.android.backupconfirm")) {
- if (DEBUG) Slog.d(TAG, "Killing host process");
- mActivityManager.killApplicationProcess(app.processName, app.uid);
- } else {
- if (DEBUG) Slog.d(TAG, "Not killing after full restore");
- }
- } catch (RemoteException e) {
- Slog.d(TAG, "Lost app trying to shut down");
- }
- mAgent = null;
- }
- }
-
- class RestoreInstallObserver extends PackageInstallObserver {
- final AtomicBoolean mDone = new AtomicBoolean();
- String mPackageName;
- int mResult;
-
- public void reset() {
- synchronized (mDone) {
- mDone.set(false);
- }
- }
-
- public void waitForCompletion() {
- synchronized (mDone) {
- while (mDone.get() == false) {
- try {
- mDone.wait();
- } catch (InterruptedException e) { }
- }
- }
- }
-
- int getResult() {
- return mResult;
- }
-
- @Override
- public void onPackageInstalled(String packageName, int returnCode,
- String msg, Bundle extras) {
- synchronized (mDone) {
- mResult = returnCode;
- mPackageName = packageName;
- mDone.set(true);
- mDone.notifyAll();
- }
- }
- }
-
- class RestoreDeleteObserver extends IPackageDeleteObserver.Stub {
- final AtomicBoolean mDone = new AtomicBoolean();
- int mResult;
-
- public void reset() {
- synchronized (mDone) {
- mDone.set(false);
- }
- }
-
- public void waitForCompletion() {
- synchronized (mDone) {
- while (mDone.get() == false) {
- try {
- mDone.wait();
- } catch (InterruptedException e) { }
- }
- }
- }
-
- @Override
- public void packageDeleted(String packageName, int returnCode) throws RemoteException {
- synchronized (mDone) {
- mResult = returnCode;
- mDone.set(true);
- mDone.notifyAll();
- }
- }
- }
-
- final RestoreInstallObserver mInstallObserver = new RestoreInstallObserver();
- final RestoreDeleteObserver mDeleteObserver = new RestoreDeleteObserver();
-
- boolean installApk(FileMetadata info, String installerPackage, InputStream instream) {
- boolean okay = true;
-
- if (DEBUG) Slog.d(TAG, "Installing from backup: " + info.packageName);
-
- // The file content is an .apk file. Copy it out to a staging location and
- // attempt to install it.
- File apkFile = new File(mDataDir, info.packageName);
- try {
- FileOutputStream apkStream = new FileOutputStream(apkFile);
- byte[] buffer = new byte[32 * 1024];
- long size = info.size;
- while (size > 0) {
- long toRead = (buffer.length < size) ? buffer.length : size;
- int didRead = instream.read(buffer, 0, (int)toRead);
- if (didRead >= 0) mBytes += didRead;
- apkStream.write(buffer, 0, didRead);
- size -= didRead;
- }
- apkStream.close();
-
- // make sure the installer can read it
- apkFile.setReadable(true, false);
-
- // Now install it
- Uri packageUri = Uri.fromFile(apkFile);
- mInstallObserver.reset();
- mPackageManager.installPackage(packageUri, mInstallObserver,
- PackageManager.INSTALL_REPLACE_EXISTING | PackageManager.INSTALL_FROM_ADB,
- installerPackage);
- mInstallObserver.waitForCompletion();
-
- if (mInstallObserver.getResult() != PackageManager.INSTALL_SUCCEEDED) {
- // The only time we continue to accept install of data even if the
- // apk install failed is if we had already determined that we could
- // accept the data regardless.
- if (mPackagePolicies.get(info.packageName) != RestorePolicy.ACCEPT) {
- okay = false;
- }
- } else {
- // Okay, the install succeeded. Make sure it was the right app.
- boolean uninstall = false;
- if (!mInstallObserver.mPackageName.equals(info.packageName)) {
- Slog.w(TAG, "Restore stream claimed to include apk for "
- + info.packageName + " but apk was really "
- + mInstallObserver.mPackageName);
- // delete the package we just put in place; it might be fraudulent
- okay = false;
- uninstall = true;
- } else {
- try {
- PackageInfo pkg = mPackageManager.getPackageInfo(info.packageName,
- PackageManager.GET_SIGNATURES);
- if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_ALLOW_BACKUP) == 0) {
- Slog.w(TAG, "Restore stream contains apk of package "
- + info.packageName + " but it disallows backup/restore");
- okay = false;
- } else {
- // So far so good -- do the signatures match the manifest?
- Signature[] sigs = mManifestSignatures.get(info.packageName);
- if (signaturesMatch(sigs, pkg)) {
- // If this is a system-uid app without a declared backup agent,
- // don't restore any of the file data.
- if ((pkg.applicationInfo.uid < Process.FIRST_APPLICATION_UID)
- && (pkg.applicationInfo.backupAgentName == null)) {
- Slog.w(TAG, "Installed app " + info.packageName
- + " has restricted uid and no agent");
- okay = false;
- }
- } else {
- Slog.w(TAG, "Installed app " + info.packageName
- + " signatures do not match restore manifest");
- okay = false;
- uninstall = true;
- }
- }
- } catch (NameNotFoundException e) {
- Slog.w(TAG, "Install of package " + info.packageName
- + " succeeded but now not found");
- okay = false;
- }
- }
-
- // If we're not okay at this point, we need to delete the package
- // that we just installed.
- if (uninstall) {
- mDeleteObserver.reset();
- mPackageManager.deletePackage(mInstallObserver.mPackageName,
- mDeleteObserver, 0);
- mDeleteObserver.waitForCompletion();
- }
- }
- } catch (IOException e) {
- Slog.e(TAG, "Unable to transcribe restored apk for install");
- okay = false;
- } finally {
- apkFile.delete();
- }
-
- return okay;
- }
-
- // Given an actual file content size, consume the post-content padding mandated
- // by the tar format.
- void skipTarPadding(long size, InputStream instream) throws IOException {
- long partial = (size + 512) % 512;
- if (partial > 0) {
- final int needed = 512 - (int)partial;
- byte[] buffer = new byte[needed];
- if (readExactly(instream, buffer, 0, needed) == needed) {
- mBytes += needed;
- } else throw new IOException("Unexpected EOF in padding");
- }
- }
-
- // Read a widget metadata file, returning the restored blob
- void readMetadata(FileMetadata info, InputStream instream) throws IOException {
- // Fail on suspiciously large widget dump files
- if (info.size > 64 * 1024) {
- throw new IOException("Metadata too big; corrupt? size=" + info.size);
- }
-
- byte[] buffer = new byte[(int) info.size];
- if (readExactly(instream, buffer, 0, (int)info.size) == info.size) {
- mBytes += info.size;
- } else throw new IOException("Unexpected EOF in widget data");
-
- String[] str = new String[1];
- int offset = extractLine(buffer, 0, str);
- int version = Integer.parseInt(str[0]);
- if (version == BACKUP_MANIFEST_VERSION) {
- offset = extractLine(buffer, offset, str);
- final String pkg = str[0];
- if (info.packageName.equals(pkg)) {
- // Data checks out -- the rest of the buffer is a concatenation of
- // binary blobs as described in the comment at writeAppWidgetData()
- ByteArrayInputStream bin = new ByteArrayInputStream(buffer,
- offset, buffer.length - offset);
- DataInputStream in = new DataInputStream(bin);
- while (bin.available() > 0) {
- int token = in.readInt();
- int size = in.readInt();
- if (size > 64 * 1024) {
- throw new IOException("Datum "
- + Integer.toHexString(token)
- + " too big; corrupt? size=" + info.size);
- }
- switch (token) {
- case BACKUP_WIDGET_METADATA_TOKEN:
- {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Got widget metadata for " + info.packageName);
- }
- mWidgetData = new byte[size];
- in.read(mWidgetData);
- break;
- }
- default:
- {
- if (DEBUG) {
- Slog.i(TAG, "Ignoring metadata blob "
- + Integer.toHexString(token)
- + " for " + info.packageName);
- }
- in.skipBytes(size);
- break;
- }
- }
- }
- } else {
- Slog.w(TAG, "Metadata mismatch: package " + info.packageName
- + " but widget data for " + pkg);
- }
- } else {
- Slog.w(TAG, "Unsupported metadata version " + version);
- }
- }
-
- // Returns a policy constant; takes a buffer arg to reduce memory churn
- RestorePolicy readAppManifest(FileMetadata info, InputStream instream)
- throws IOException {
- // Fail on suspiciously large manifest files
- if (info.size > 64 * 1024) {
- throw new IOException("Restore manifest too big; corrupt? size=" + info.size);
- }
-
- byte[] buffer = new byte[(int) info.size];
- if (readExactly(instream, buffer, 0, (int)info.size) == info.size) {
- mBytes += info.size;
- } else throw new IOException("Unexpected EOF in manifest");
-
- RestorePolicy policy = RestorePolicy.IGNORE;
- String[] str = new String[1];
- int offset = 0;
-
- try {
- offset = extractLine(buffer, offset, str);
- int version = Integer.parseInt(str[0]);
- if (version == BACKUP_MANIFEST_VERSION) {
- offset = extractLine(buffer, offset, str);
- String manifestPackage = str[0];
- // TODO: handle <original-package>
- if (manifestPackage.equals(info.packageName)) {
- offset = extractLine(buffer, offset, str);
- version = Integer.parseInt(str[0]); // app version
- offset = extractLine(buffer, offset, str);
- // This is the platform version, which we don't use, but we parse it
- // as a safety against corruption in the manifest.
- Integer.parseInt(str[0]);
- offset = extractLine(buffer, offset, str);
- info.installerPackageName = (str[0].length() > 0) ? str[0] : null;
- offset = extractLine(buffer, offset, str);
- boolean hasApk = str[0].equals("1");
- offset = extractLine(buffer, offset, str);
- int numSigs = Integer.parseInt(str[0]);
- if (numSigs > 0) {
- Signature[] sigs = new Signature[numSigs];
- for (int i = 0; i < numSigs; i++) {
- offset = extractLine(buffer, offset, str);
- sigs[i] = new Signature(str[0]);
- }
- mManifestSignatures.put(info.packageName, sigs);
-
- // Okay, got the manifest info we need...
- try {
- PackageInfo pkgInfo = mPackageManager.getPackageInfo(
- info.packageName, PackageManager.GET_SIGNATURES);
- // Fall through to IGNORE if the app explicitly disallows backup
- final int flags = pkgInfo.applicationInfo.flags;
- if ((flags & ApplicationInfo.FLAG_ALLOW_BACKUP) != 0) {
- // Restore system-uid-space packages only if they have
- // defined a custom backup agent
- if ((pkgInfo.applicationInfo.uid >= Process.FIRST_APPLICATION_UID)
- || (pkgInfo.applicationInfo.backupAgentName != null)) {
- // Verify signatures against any installed version; if they
- // don't match, then we fall though and ignore the data. The
- // signatureMatch() method explicitly ignores the signature
- // check for packages installed on the system partition, because
- // such packages are signed with the platform cert instead of
- // the app developer's cert, so they're different on every
- // device.
- if (signaturesMatch(sigs, pkgInfo)) {
- if ((pkgInfo.applicationInfo.flags
- & ApplicationInfo.FLAG_RESTORE_ANY_VERSION) != 0) {
- Slog.i(TAG, "Package has restoreAnyVersion; taking data");
- policy = RestorePolicy.ACCEPT;
- } else if (pkgInfo.versionCode >= version) {
- Slog.i(TAG, "Sig + version match; taking data");
- policy = RestorePolicy.ACCEPT;
- } else {
- // The data is from a newer version of the app than
- // is presently installed. That means we can only
- // use it if the matching apk is also supplied.
- Slog.d(TAG, "Data version " + version
- + " is newer than installed version "
- + pkgInfo.versionCode + " - requiring apk");
- policy = RestorePolicy.ACCEPT_IF_APK;
- }
- } else {
- Slog.w(TAG, "Restore manifest signatures do not match "
- + "installed application for " + info.packageName);
- }
- } else {
- Slog.w(TAG, "Package " + info.packageName
- + " is system level with no agent");
- }
- } else {
- if (DEBUG) Slog.i(TAG, "Restore manifest from "
- + info.packageName + " but allowBackup=false");
- }
- } catch (NameNotFoundException e) {
- // Okay, the target app isn't installed. We can process
- // the restore properly only if the dataset provides the
- // apk file and we can successfully install it.
- if (DEBUG) Slog.i(TAG, "Package " + info.packageName
- + " not installed; requiring apk in dataset");
- policy = RestorePolicy.ACCEPT_IF_APK;
- }
-
- if (policy == RestorePolicy.ACCEPT_IF_APK && !hasApk) {
- Slog.i(TAG, "Cannot restore package " + info.packageName
- + " without the matching .apk");
- }
- } else {
- Slog.i(TAG, "Missing signature on backed-up package "
- + info.packageName);
- }
- } else {
- Slog.i(TAG, "Expected package " + info.packageName
- + " but restore manifest claims " + manifestPackage);
- }
- } else {
- Slog.i(TAG, "Unknown restore manifest version " + version
- + " for package " + info.packageName);
- }
- } catch (NumberFormatException e) {
- Slog.w(TAG, "Corrupt restore manifest for package " + info.packageName);
- } catch (IllegalArgumentException e) {
- Slog.w(TAG, e.getMessage());
- }
-
- return policy;
- }
-
- // Builds a line from a byte buffer starting at 'offset', and returns
- // the index of the next unconsumed data in the buffer.
- int extractLine(byte[] buffer, int offset, String[] outStr) throws IOException {
- final int end = buffer.length;
- if (offset >= end) throw new IOException("Incomplete data");
-
- int pos;
- for (pos = offset; pos < end; pos++) {
- byte c = buffer[pos];
- // at LF we declare end of line, and return the next char as the
- // starting point for the next time through
- if (c == '\n') {
- break;
- }
- }
- outStr[0] = new String(buffer, offset, pos - offset);
- pos++; // may be pointing an extra byte past the end but that's okay
- return pos;
- }
-
- void dumpFileMetadata(FileMetadata info) {
- if (DEBUG) {
- StringBuilder b = new StringBuilder(128);
-
- // mode string
- b.append((info.type == BackupAgent.TYPE_DIRECTORY) ? 'd' : '-');
- b.append(((info.mode & 0400) != 0) ? 'r' : '-');
- b.append(((info.mode & 0200) != 0) ? 'w' : '-');
- b.append(((info.mode & 0100) != 0) ? 'x' : '-');
- b.append(((info.mode & 0040) != 0) ? 'r' : '-');
- b.append(((info.mode & 0020) != 0) ? 'w' : '-');
- b.append(((info.mode & 0010) != 0) ? 'x' : '-');
- b.append(((info.mode & 0004) != 0) ? 'r' : '-');
- b.append(((info.mode & 0002) != 0) ? 'w' : '-');
- b.append(((info.mode & 0001) != 0) ? 'x' : '-');
- b.append(String.format(" %9d ", info.size));
-
- Date stamp = new Date(info.mtime);
- b.append(new SimpleDateFormat("MMM dd HH:mm:ss ").format(stamp));
-
- b.append(info.packageName);
- b.append(" :: ");
- b.append(info.domain);
- b.append(" :: ");
- b.append(info.path);
-
- Slog.i(TAG, b.toString());
- }
- }
-
- // Consume a tar file header block [sequence] and accumulate the relevant metadata
- FileMetadata readTarHeaders(InputStream instream) throws IOException {
- byte[] block = new byte[512];
- FileMetadata info = null;
-
- boolean gotHeader = readTarHeader(instream, block);
- if (gotHeader) {
- try {
- // okay, presume we're okay, and extract the various metadata
- info = new FileMetadata();
- info.size = extractRadix(block, 124, 12, 8);
- info.mtime = extractRadix(block, 136, 12, 8);
- info.mode = extractRadix(block, 100, 8, 8);
-
- info.path = extractString(block, 345, 155); // prefix
- String path = extractString(block, 0, 100);
- if (path.length() > 0) {
- if (info.path.length() > 0) info.path += '/';
- info.path += path;
- }
-
- // tar link indicator field: 1 byte at offset 156 in the header.
- int typeChar = block[156];
- if (typeChar == 'x') {
- // pax extended header, so we need to read that
- gotHeader = readPaxExtendedHeader(instream, info);
- if (gotHeader) {
- // and after a pax extended header comes another real header -- read
- // that to find the real file type
- gotHeader = readTarHeader(instream, block);
- }
- if (!gotHeader) throw new IOException("Bad or missing pax header");
-
- typeChar = block[156];
- }
-
- switch (typeChar) {
- case '0': info.type = BackupAgent.TYPE_FILE; break;
- case '5': {
- info.type = BackupAgent.TYPE_DIRECTORY;
- if (info.size != 0) {
- Slog.w(TAG, "Directory entry with nonzero size in header");
- info.size = 0;
- }
- break;
- }
- case 0: {
- // presume EOF
- if (DEBUG) Slog.w(TAG, "Saw type=0 in tar header block, info=" + info);
- return null;
- }
- default: {
- Slog.e(TAG, "Unknown tar entity type: " + typeChar);
- throw new IOException("Unknown entity type " + typeChar);
- }
- }
-
- // Parse out the path
- //
- // first: apps/shared/unrecognized
- if (FullBackup.SHARED_PREFIX.regionMatches(0,
- info.path, 0, FullBackup.SHARED_PREFIX.length())) {
- // File in shared storage. !!! TODO: implement this.
- info.path = info.path.substring(FullBackup.SHARED_PREFIX.length());
- info.packageName = SHARED_BACKUP_AGENT_PACKAGE;
- info.domain = FullBackup.SHARED_STORAGE_TOKEN;
- if (DEBUG) Slog.i(TAG, "File in shared storage: " + info.path);
- } else if (FullBackup.APPS_PREFIX.regionMatches(0,
- info.path, 0, FullBackup.APPS_PREFIX.length())) {
- // App content! Parse out the package name and domain
-
- // strip the apps/ prefix
- info.path = info.path.substring(FullBackup.APPS_PREFIX.length());
-
- // extract the package name
- int slash = info.path.indexOf('/');
- if (slash < 0) throw new IOException("Illegal semantic path in " + info.path);
- info.packageName = info.path.substring(0, slash);
- info.path = info.path.substring(slash+1);
-
- // if it's a manifest or metadata payload we're done, otherwise parse
- // out the domain into which the file will be restored
- if (!info.path.equals(BACKUP_MANIFEST_FILENAME)
- && !info.path.equals(BACKUP_METADATA_FILENAME)) {
- slash = info.path.indexOf('/');
- if (slash < 0) throw new IOException("Illegal semantic path in non-manifest " + info.path);
- info.domain = info.path.substring(0, slash);
- info.path = info.path.substring(slash + 1);
- }
- }
- } catch (IOException e) {
- if (DEBUG) {
- Slog.e(TAG, "Parse error in header: " + e.getMessage());
- HEXLOG(block);
- }
- throw e;
- }
- }
- return info;
- }
-
- private void HEXLOG(byte[] block) {
- int offset = 0;
- int todo = block.length;
- StringBuilder buf = new StringBuilder(64);
- while (todo > 0) {
- buf.append(String.format("%04x ", offset));
- int numThisLine = (todo > 16) ? 16 : todo;
- for (int i = 0; i < numThisLine; i++) {
- buf.append(String.format("%02x ", block[offset+i]));
- }
- Slog.i("hexdump", buf.toString());
- buf.setLength(0);
- todo -= numThisLine;
- offset += numThisLine;
- }
- }
-
- // Read exactly the given number of bytes into a buffer at the stated offset.
- // Returns false if EOF is encountered before the requested number of bytes
- // could be read.
- int readExactly(InputStream in, byte[] buffer, int offset, int size)
- throws IOException {
- if (size <= 0) throw new IllegalArgumentException("size must be > 0");
-
- int soFar = 0;
- while (soFar < size) {
- int nRead = in.read(buffer, offset + soFar, size - soFar);
- if (nRead <= 0) {
- if (MORE_DEBUG) Slog.w(TAG, "- wanted exactly " + size + " but got only " + soFar);
- break;
- }
- soFar += nRead;
- }
- return soFar;
- }
-
- boolean readTarHeader(InputStream instream, byte[] block) throws IOException {
- final int got = readExactly(instream, block, 0, 512);
- if (got == 0) return false; // Clean EOF
- if (got < 512) throw new IOException("Unable to read full block header");
- mBytes += 512;
- return true;
- }
-
- // overwrites 'info' fields based on the pax extended header
- boolean readPaxExtendedHeader(InputStream instream, FileMetadata info)
- throws IOException {
- // We should never see a pax extended header larger than this
- if (info.size > 32*1024) {
- Slog.w(TAG, "Suspiciously large pax header size " + info.size
- + " - aborting");
- throw new IOException("Sanity failure: pax header size " + info.size);
- }
-
- // read whole blocks, not just the content size
- int numBlocks = (int)((info.size + 511) >> 9);
- byte[] data = new byte[numBlocks * 512];
- if (readExactly(instream, data, 0, data.length) < data.length) {
- throw new IOException("Unable to read full pax header");
- }
- mBytes += data.length;
-
- final int contentSize = (int) info.size;
- int offset = 0;
- do {
- // extract the line at 'offset'
- int eol = offset+1;
- while (eol < contentSize && data[eol] != ' ') eol++;
- if (eol >= contentSize) {
- // error: we just hit EOD looking for the end of the size field
- throw new IOException("Invalid pax data");
- }
- // eol points to the space between the count and the key
- int linelen = (int) extractRadix(data, offset, eol - offset, 10);
- int key = eol + 1; // start of key=value
- eol = offset + linelen - 1; // trailing LF
- int value;
- for (value = key+1; data[value] != '=' && value <= eol; value++);
- if (value > eol) {
- throw new IOException("Invalid pax declaration");
- }
-
- // pax requires that key/value strings be in UTF-8
- String keyStr = new String(data, key, value-key, "UTF-8");
- // -1 to strip the trailing LF
- String valStr = new String(data, value+1, eol-value-1, "UTF-8");
-
- if ("path".equals(keyStr)) {
- info.path = valStr;
- } else if ("size".equals(keyStr)) {
- info.size = Long.parseLong(valStr);
- } else {
- if (DEBUG) Slog.i(TAG, "Unhandled pax key: " + key);
- }
-
- offset += linelen;
- } while (offset < contentSize);
-
- return true;
- }
-
- long extractRadix(byte[] data, int offset, int maxChars, int radix)
- throws IOException {
- long value = 0;
- final int end = offset + maxChars;
- for (int i = offset; i < end; i++) {
- final byte b = data[i];
- // Numeric fields in tar can terminate with either NUL or SPC
- if (b == 0 || b == ' ') break;
- if (b < '0' || b > ('0' + radix - 1)) {
- throw new IOException("Invalid number in header: '" + (char)b + "' for radix " + radix);
- }
- value = radix * value + (b - '0');
- }
- return value;
- }
-
- String extractString(byte[] data, int offset, int maxChars) throws IOException {
- final int end = offset + maxChars;
- int eos = offset;
- // tar string fields terminate early with a NUL
- while (eos < end && data[eos] != 0) eos++;
- return new String(data, offset, eos-offset, "US-ASCII");
- }
-
- void sendStartRestore() {
- if (mObserver != null) {
- try {
- mObserver.onStartRestore();
- } catch (RemoteException e) {
- Slog.w(TAG, "full restore observer went away: startRestore");
- mObserver = null;
- }
- }
- }
-
- void sendOnRestorePackage(String name) {
- if (mObserver != null) {
- try {
- // TODO: use a more user-friendly name string
- mObserver.onRestorePackage(name);
- } catch (RemoteException e) {
- Slog.w(TAG, "full restore observer went away: restorePackage");
- mObserver = null;
- }
- }
- }
-
- void sendEndRestore() {
- if (mObserver != null) {
- try {
- mObserver.onEndRestore();
- } catch (RemoteException e) {
- Slog.w(TAG, "full restore observer went away: endRestore");
- mObserver = null;
- }
- }
- }
- }
-
- // ----- Restore handling -----
-
- /**
- * Returns whether the signatures stored {@param storedSigs}, coming from the source apk, match
- * the signatures of the apk installed on the device, the target apk. If the target resides in
- * the system partition we return true. Otherwise it's considered a match if both conditions
- * hold:
- *
- * <ul>
- * <li>Source and target have at least one signature each
- * <li>Target contains all signatures in source
- * </ul>
- *
- * Note that if {@param target} is null we return false.
- */
- static boolean signaturesMatch(Signature[] storedSigs, PackageInfo target) {
- if (target == null) {
- return false;
- }
-
- // If the target resides on the system partition, we allow it to restore
- // data from the like-named package in a restore set even if the signatures
- // do not match. (Unlike general applications, those flashed to the system
- // partition will be signed with the device's platform certificate, so on
- // different phones the same system app will have different signatures.)
- if ((target.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
- if (MORE_DEBUG) {
- Slog.v(TAG, "System app " + target.packageName + " - skipping sig check");
- }
- return true;
- }
-
- Signature[] deviceSigs = target.signatures;
- if (MORE_DEBUG) {
- Slog.v(TAG, "signaturesMatch(): stored=" + storedSigs + " device=" + deviceSigs);
- }
-
- // Don't allow unsigned apps on either end
- if (ArrayUtils.isEmpty(storedSigs) || ArrayUtils.isEmpty(deviceSigs)) {
- return false;
- }
-
- // Signatures can be added over time, so the target-device apk needs to contain all the
- // source-device apk signatures, but not necessarily the other way around.
- int nStored = storedSigs.length;
- int nDevice = deviceSigs.length;
-
- for (int i=0; i < nStored; i++) {
- boolean match = false;
- for (int j=0; j < nDevice; j++) {
- if (storedSigs[i].equals(deviceSigs[j])) {
- match = true;
- break;
- }
- }
- if (!match) {
- return false;
- }
- }
- return true;
- }
-
- // Used by both incremental and full restore
- void restoreWidgetData(String packageName, byte[] widgetData) {
- // Apply the restored widget state and generate the ID update for the app
- // TODO: http://b/22388012
- if (MORE_DEBUG) {
- Slog.i(TAG, "Incorporating restored widget data");
- }
- AppWidgetBackupBridge.restoreWidgetState(packageName, widgetData, UserHandle.USER_SYSTEM);
- }
-
- // *****************************
- // NEW UNIFIED RESTORE IMPLEMENTATION
- // *****************************
-
- // states of the unified-restore state machine
- enum UnifiedRestoreState {
- INITIAL,
- RUNNING_QUEUE,
- RESTORE_KEYVALUE,
- RESTORE_FULL,
- RESTORE_FINISHED,
- FINAL
- }
-
- class PerformUnifiedRestoreTask implements BackupRestoreTask {
- // Transport we're working with to do the restore
- private IBackupTransport mTransport;
-
- // Where per-transport saved state goes
- File mStateDir;
-
- // Restore observer; may be null
- private IRestoreObserver mObserver;
-
- // BackuoManagerMonitor; may be null
- private IBackupManagerMonitor mMonitor;
-
- // Token identifying the dataset to the transport
- private long mToken;
-
- // When this is a restore-during-install, this is the token identifying the
- // operation to the Package Manager, and we must ensure that we let it know
- // when we're finished.
- private int mPmToken;
-
- // When this is restore-during-install, we need to tell the package manager
- // whether we actually launched the app, because this affects notifications
- // around externally-visible state transitions.
- private boolean mDidLaunch;
-
- // Is this a whole-system restore, i.e. are we establishing a new ancestral
- // dataset to base future restore-at-install operations from?
- private boolean mIsSystemRestore;
-
- // If this is a single-package restore, what package are we interested in?
- private PackageInfo mTargetPackage;
-
- // In all cases, the calculated list of packages that we are trying to restore
- private List<PackageInfo> mAcceptSet;
-
- // Our bookkeeping about the ancestral dataset
- private PackageManagerBackupAgent mPmAgent;
-
- // Currently-bound backup agent for restore + restoreFinished purposes
- private IBackupAgent mAgent;
-
- // What sort of restore we're doing now
- private RestoreDescription mRestoreDescription;
-
- // The package we're currently restoring
- private PackageInfo mCurrentPackage;
-
- // Widget-related data handled as part of this restore operation
- private byte[] mWidgetData;
-
- // Number of apps restored in this pass
- private int mCount;
-
- // When did we start?
- private long mStartRealtime;
-
- // State machine progress
- private UnifiedRestoreState mState;
-
- // How are things going?
- private int mStatus;
-
- // Done?
- private boolean mFinished;
-
- // Key/value: bookkeeping about staged data and files for agent access
- private File mBackupDataName;
- private File mStageName;
- private File mSavedStateName;
- private File mNewStateName;
- ParcelFileDescriptor mBackupData;
- ParcelFileDescriptor mNewState;
-
- private final int mEphemeralOpToken;
-
- // Invariant: mWakelock is already held, and this task is responsible for
- // releasing it at the end of the restore operation.
- PerformUnifiedRestoreTask(IBackupTransport transport, IRestoreObserver observer,
- IBackupManagerMonitor monitor, long restoreSetToken, PackageInfo targetPackage,
- int pmToken, boolean isFullSystemRestore, String[] filterSet) {
- mEphemeralOpToken = generateRandomIntegerToken();
- mState = UnifiedRestoreState.INITIAL;
- mStartRealtime = SystemClock.elapsedRealtime();
-
- mTransport = transport;
- mObserver = observer;
- mMonitor = monitor;
- mToken = restoreSetToken;
- mPmToken = pmToken;
- mTargetPackage = targetPackage;
- mIsSystemRestore = isFullSystemRestore;
- mFinished = false;
- mDidLaunch = false;
-
- if (targetPackage != null) {
- // Single package restore
- mAcceptSet = new ArrayList<PackageInfo>();
- mAcceptSet.add(targetPackage);
- } else {
- // Everything possible, or a target set
- if (filterSet == null) {
- // We want everything and a pony
- List<PackageInfo> apps =
- PackageManagerBackupAgent.getStorableApplications(mPackageManager);
- filterSet = packagesToNames(apps);
- if (DEBUG) {
- Slog.i(TAG, "Full restore; asking about " + filterSet.length + " apps");
- }
- }
-
- mAcceptSet = new ArrayList<PackageInfo>(filterSet.length);
-
- // Pro tem, we insist on moving the settings provider package to last place.
- // Keep track of whether it's in the list, and bump it down if so. We also
- // want to do the system package itself first if it's called for.
- boolean hasSystem = false;
- boolean hasSettings = false;
- for (int i = 0; i < filterSet.length; i++) {
- try {
- PackageInfo info = mPackageManager.getPackageInfo(filterSet[i], 0);
- if ("android".equals(info.packageName)) {
- hasSystem = true;
- continue;
- }
- if (SETTINGS_PACKAGE.equals(info.packageName)) {
- hasSettings = true;
- continue;
- }
-
- if (appIsEligibleForBackup(info.applicationInfo, mPackageManager)) {
- mAcceptSet.add(info);
- }
- } catch (NameNotFoundException e) {
- // requested package name doesn't exist; ignore it
- }
- }
- if (hasSystem) {
- try {
- mAcceptSet.add(0, mPackageManager.getPackageInfo("android", 0));
- } catch (NameNotFoundException e) {
- // won't happen; we know a priori that it's valid
- }
- }
- if (hasSettings) {
- try {
- mAcceptSet.add(mPackageManager.getPackageInfo(SETTINGS_PACKAGE, 0));
- } catch (NameNotFoundException e) {
- // this one is always valid too
- }
- }
- }
-
- if (MORE_DEBUG) {
- Slog.v(TAG, "Restore; accept set size is " + mAcceptSet.size());
- for (PackageInfo info : mAcceptSet) {
- Slog.v(TAG, " " + info.packageName);
- }
- }
- }
-
- private String[] packagesToNames(List<PackageInfo> apps) {
- final int N = apps.size();
- String[] names = new String[N];
- for (int i = 0; i < N; i++) {
- names[i] = apps.get(i).packageName;
- }
- return names;
- }
-
- // Execute one tick of whatever state machine the task implements
- @Override
- public void execute() {
- if (MORE_DEBUG) Slog.v(TAG, "*** Executing restore step " + mState);
- switch (mState) {
- case INITIAL:
- startRestore();
- break;
-
- case RUNNING_QUEUE:
- dispatchNextRestore();
- break;
-
- case RESTORE_KEYVALUE:
- restoreKeyValue();
- break;
-
- case RESTORE_FULL:
- restoreFull();
- break;
-
- case RESTORE_FINISHED:
- restoreFinished();
- break;
-
- case FINAL:
- if (!mFinished) finalizeRestore();
- else {
- Slog.e(TAG, "Duplicate finish");
- }
- mFinished = true;
- break;
- }
- }
-
- /*
- * SKETCH OF OPERATION
- *
- * create one of these PerformUnifiedRestoreTask objects, telling it which
- * dataset & transport to address, and then parameters within the restore
- * operation: single target package vs many, etc.
- *
- * 1. transport.startRestore(token, list-of-packages). If we need @pm@ it is
- * always placed first and the settings provider always placed last [for now].
- *
- * 1a [if we needed @pm@ then nextRestorePackage() and restore the PMBA inline]
- *
- * [ state change => RUNNING_QUEUE ]
- *
- * NOW ITERATE:
- *
- * { 3. t.nextRestorePackage()
- * 4. does the metadata for this package allow us to restore it?
- * does the on-disk app permit us to restore it? [re-check allowBackup etc]
- * 5. is this a key/value dataset? => key/value agent restore
- * [ state change => RESTORE_KEYVALUE ]
- * 5a. spin up agent
- * 5b. t.getRestoreData() to stage it properly
- * 5c. call into agent to perform restore
- * 5d. tear down agent
- * [ state change => RUNNING_QUEUE ]
- *
- * 6. else it's a stream dataset:
- * [ state change => RESTORE_FULL ]
- * 6a. instantiate the engine for a stream restore: engine handles agent lifecycles
- * 6b. spin off engine runner on separate thread
- * 6c. ITERATE getNextFullRestoreDataChunk() and copy data to engine runner socket
- * [ state change => RUNNING_QUEUE ]
- * }
- *
- * [ state change => FINAL ]
- *
- * 7. t.finishRestore(), release wakelock, etc.
- *
- *
- */
-
- // state INITIAL : set up for the restore and read the metadata if necessary
- private void startRestore() {
- sendStartRestore(mAcceptSet.size());
-
- // If we're starting a full-system restore, set up to begin widget ID remapping
- if (mIsSystemRestore) {
- // TODO: http://b/22388012
- AppWidgetBackupBridge.restoreStarting(UserHandle.USER_SYSTEM);
- }
-
- try {
- String transportDir = mTransport.transportDirName();
- mStateDir = new File(mBaseStateDir, transportDir);
-
- // Fetch the current metadata from the dataset first
- PackageInfo pmPackage = new PackageInfo();
- pmPackage.packageName = PACKAGE_MANAGER_SENTINEL;
- mAcceptSet.add(0, pmPackage);
-
- PackageInfo[] packages = mAcceptSet.toArray(new PackageInfo[0]);
- mStatus = mTransport.startRestore(mToken, packages);
- if (mStatus != BackupTransport.TRANSPORT_OK) {
- Slog.e(TAG, "Transport error " + mStatus + "; no restore possible");
- mStatus = BackupTransport.TRANSPORT_ERROR;
- executeNextState(UnifiedRestoreState.FINAL);
- return;
- }
-
- RestoreDescription desc = mTransport.nextRestorePackage();
- if (desc == null) {
- Slog.e(TAG, "No restore metadata available; halting");
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_NO_RESTORE_METADATA_AVAILABLE,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null);
- mStatus = BackupTransport.TRANSPORT_ERROR;
- executeNextState(UnifiedRestoreState.FINAL);
- return;
- }
- if (!PACKAGE_MANAGER_SENTINEL.equals(desc.getPackageName())) {
- Slog.e(TAG, "Required package metadata but got "
- + desc.getPackageName());
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_NO_PM_METADATA_RECEIVED,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null);
- mStatus = BackupTransport.TRANSPORT_ERROR;
- executeNextState(UnifiedRestoreState.FINAL);
- return;
- }
-
- // Pull the Package Manager metadata from the restore set first
- mCurrentPackage = new PackageInfo();
- mCurrentPackage.packageName = PACKAGE_MANAGER_SENTINEL;
- mPmAgent = makeMetadataAgent(null);
- mAgent = IBackupAgent.Stub.asInterface(mPmAgent.onBind());
- if (MORE_DEBUG) {
- Slog.v(TAG, "initiating restore for PMBA");
- }
- initiateOneRestore(mCurrentPackage, 0);
- // The PM agent called operationComplete() already, because our invocation
- // of it is process-local and therefore synchronous. That means that the
- // next-state message (RUNNING_QUEUE) is already enqueued. Only if we're
- // unable to proceed with running the queue do we remove that pending
- // message and jump straight to the FINAL state. Because this was
- // synchronous we also know that we should cancel the pending timeout
- // message.
- mBackupHandler.removeMessages(MSG_RESTORE_OPERATION_TIMEOUT);
-
- // Verify that the backup set includes metadata. If not, we can't do
- // signature/version verification etc, so we simply do not proceed with
- // the restore operation.
- if (!mPmAgent.hasMetadata()) {
- Slog.e(TAG, "PM agent has no metadata, so not restoring");
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_PM_AGENT_HAS_NO_METADATA,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE,
- PACKAGE_MANAGER_SENTINEL,
- "Package manager restore metadata missing");
- mStatus = BackupTransport.TRANSPORT_ERROR;
- mBackupHandler.removeMessages(MSG_BACKUP_RESTORE_STEP, this);
- executeNextState(UnifiedRestoreState.FINAL);
- return;
- }
-
- // Success; cache the metadata and continue as expected with the
- // next state already enqueued
-
- } catch (Exception e) {
- // If we lost the transport at any time, halt
- Slog.e(TAG, "Unable to contact transport for restore: " + e.getMessage());
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_LOST_TRANSPORT,
- null,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, null);
- mStatus = BackupTransport.TRANSPORT_ERROR;
- mBackupHandler.removeMessages(MSG_BACKUP_RESTORE_STEP, this);
- executeNextState(UnifiedRestoreState.FINAL);
- return;
- }
- }
-
- // state RUNNING_QUEUE : figure out what the next thing to be restored is,
- // and fire the appropriate next step
- private void dispatchNextRestore() {
- UnifiedRestoreState nextState = UnifiedRestoreState.FINAL;
- try {
- mRestoreDescription = mTransport.nextRestorePackage();
- final String pkgName = (mRestoreDescription != null)
- ? mRestoreDescription.getPackageName() : null;
- if (pkgName == null) {
- Slog.e(TAG, "Failure getting next package name");
- EventLog.writeEvent(EventLogTags.RESTORE_TRANSPORT_FAILURE);
- nextState = UnifiedRestoreState.FINAL;
- return;
- } else if (mRestoreDescription == RestoreDescription.NO_MORE_PACKAGES) {
- // Yay we've reached the end cleanly
- if (DEBUG) {
- Slog.v(TAG, "No more packages; finishing restore");
- }
- int millis = (int) (SystemClock.elapsedRealtime() - mStartRealtime);
- EventLog.writeEvent(EventLogTags.RESTORE_SUCCESS, mCount, millis);
- nextState = UnifiedRestoreState.FINAL;
- return;
- }
-
- if (DEBUG) {
- Slog.i(TAG, "Next restore package: " + mRestoreDescription);
- }
- sendOnRestorePackage(pkgName);
-
- Metadata metaInfo = mPmAgent.getRestoredMetadata(pkgName);
- if (metaInfo == null) {
- Slog.e(TAG, "No metadata for " + pkgName);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, pkgName,
- "Package metadata missing");
- nextState = UnifiedRestoreState.RUNNING_QUEUE;
- return;
- }
-
- try {
- mCurrentPackage = mPackageManager.getPackageInfo(
- pkgName, PackageManager.GET_SIGNATURES);
- } catch (NameNotFoundException e) {
- // Whoops, we thought we could restore this package but it
- // turns out not to be present. Skip it.
- Slog.e(TAG, "Package not present: " + pkgName);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_NOT_PRESENT,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- null);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, pkgName,
- "Package missing on device");
- nextState = UnifiedRestoreState.RUNNING_QUEUE;
- return;
- }
-
- if (metaInfo.versionCode > mCurrentPackage.versionCode) {
- // Data is from a "newer" version of the app than we have currently
- // installed. If the app has not declared that it is prepared to
- // handle this case, we do not attempt the restore.
- if ((mCurrentPackage.applicationInfo.flags
- & ApplicationInfo.FLAG_RESTORE_ANY_VERSION) == 0) {
- String message = "Source version " + metaInfo.versionCode
- + " > installed version " + mCurrentPackage.versionCode;
- Slog.w(TAG, "Package " + pkgName + ": " + message);
- Bundle monitoringExtras = putMonitoringExtra(null,
- BackupManagerMonitor.EXTRA_LOG_RESTORE_VERSION,
- metaInfo.versionCode);
- monitoringExtras = putMonitoringExtra(monitoringExtras,
- BackupManagerMonitor.EXTRA_LOG_RESTORE_ANYWAY, false);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_RESTORE_VERSION_HIGHER,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- monitoringExtras);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE,
- pkgName, message);
- nextState = UnifiedRestoreState.RUNNING_QUEUE;
- return;
- } else {
- if (DEBUG) Slog.v(TAG, "Source version " + metaInfo.versionCode
- + " > installed version " + mCurrentPackage.versionCode
- + " but restoreAnyVersion");
- Bundle monitoringExtras = putMonitoringExtra(null,
- BackupManagerMonitor.EXTRA_LOG_RESTORE_VERSION,
- metaInfo.versionCode);
- monitoringExtras = putMonitoringExtra(monitoringExtras,
- BackupManagerMonitor.EXTRA_LOG_RESTORE_ANYWAY, true);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_RESTORE_VERSION_HIGHER,
- mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY,
- monitoringExtras);
- }
- }
-
- if (MORE_DEBUG) Slog.v(TAG, "Package " + pkgName
- + " restore version [" + metaInfo.versionCode
- + "] is compatible with installed version ["
- + mCurrentPackage.versionCode + "]");
-
- // Reset per-package preconditions and fire the appropriate next state
- mWidgetData = null;
- final int type = mRestoreDescription.getDataType();
- if (type == RestoreDescription.TYPE_KEY_VALUE) {
- nextState = UnifiedRestoreState.RESTORE_KEYVALUE;
- } else if (type == RestoreDescription.TYPE_FULL_STREAM) {
- nextState = UnifiedRestoreState.RESTORE_FULL;
- } else {
- // Unknown restore type; ignore this package and move on
- Slog.e(TAG, "Unrecognized restore type " + type);
- nextState = UnifiedRestoreState.RUNNING_QUEUE;
- return;
- }
- } catch (Exception e) {
- Slog.e(TAG, "Can't get next restore target from transport; halting: "
- + e.getMessage());
- EventLog.writeEvent(EventLogTags.RESTORE_TRANSPORT_FAILURE);
- nextState = UnifiedRestoreState.FINAL;
- return;
- } finally {
- executeNextState(nextState);
- }
- }
-
- // state RESTORE_KEYVALUE : restore one package via key/value API set
- private void restoreKeyValue() {
- // Initiating the restore will pass responsibility for the state machine's
- // progress to the agent callback, so we do not always execute the
- // next state here.
- final String packageName = mCurrentPackage.packageName;
- // Validate some semantic requirements that apply in this way
- // only to the key/value restore API flow
- if (mCurrentPackage.applicationInfo.backupAgentName == null
- || "".equals(mCurrentPackage.applicationInfo.backupAgentName)) {
- if (MORE_DEBUG) {
- Slog.i(TAG, "Data exists for package " + packageName
- + " but app has no agent; skipping");
- }
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_APP_HAS_NO_AGENT, mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, null);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, packageName,
- "Package has no agent");
- executeNextState(UnifiedRestoreState.RUNNING_QUEUE);
- return;
- }
-
- Metadata metaInfo = mPmAgent.getRestoredMetadata(packageName);
- if (!BackupUtils.signaturesMatch(metaInfo.sigHashes, mCurrentPackage)) {
- Slog.w(TAG, "Signature mismatch restoring " + packageName);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_SIGNATURE_MISMATCH, mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, packageName,
- "Signature mismatch");
- executeNextState(UnifiedRestoreState.RUNNING_QUEUE);
- return;
- }
-
- // Good to go! Set up and bind the agent...
- mAgent = bindToAgentSynchronous(
- mCurrentPackage.applicationInfo,
- ApplicationThreadConstants.BACKUP_MODE_INCREMENTAL);
- if (mAgent == null) {
- Slog.w(TAG, "Can't find backup agent for " + packageName);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_CANT_FIND_AGENT, mCurrentPackage,
- BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, packageName,
- "Restore agent missing");
- executeNextState(UnifiedRestoreState.RUNNING_QUEUE);
- return;
- }
-
- // Whatever happens next, we've launched the target app now; remember that.
- mDidLaunch = true;
-
- // And then finally start the restore on this agent
- try {
- initiateOneRestore(mCurrentPackage, metaInfo.versionCode);
- ++mCount;
- } catch (Exception e) {
- Slog.e(TAG, "Error when attempting restore: " + e.toString());
- keyValueAgentErrorCleanup();
- executeNextState(UnifiedRestoreState.RUNNING_QUEUE);
- }
- }
-
- // Guts of a key/value restore operation
- void initiateOneRestore(PackageInfo app, int appVersionCode) {
- final String packageName = app.packageName;
-
- if (DEBUG) Slog.d(TAG, "initiateOneRestore packageName=" + packageName);
-
- // !!! TODO: get the dirs from the transport
- mBackupDataName = new File(mDataDir, packageName + ".restore");
- mStageName = new File(mDataDir, packageName + ".stage");
- mNewStateName = new File(mStateDir, packageName + ".new");
- mSavedStateName = new File(mStateDir, packageName);
-
- // don't stage the 'android' package where the wallpaper data lives. this is
- // an optimization: we know there's no widget data hosted/published by that
- // package, and this way we avoid doing a spurious copy of MB-sized wallpaper
- // data following the download.
- boolean staging = !packageName.equals("android");
- ParcelFileDescriptor stage;
- File downloadFile = (staging) ? mStageName : mBackupDataName;
-
- try {
- // Run the transport's restore pass
- stage = ParcelFileDescriptor.open(downloadFile,
- ParcelFileDescriptor.MODE_READ_WRITE |
- ParcelFileDescriptor.MODE_CREATE |
- ParcelFileDescriptor.MODE_TRUNCATE);
-
- if (mTransport.getRestoreData(stage) != BackupTransport.TRANSPORT_OK) {
- // Transport-level failure, so we wind everything up and
- // terminate the restore operation.
- Slog.e(TAG, "Error getting restore data for " + packageName);
- EventLog.writeEvent(EventLogTags.RESTORE_TRANSPORT_FAILURE);
- stage.close();
- downloadFile.delete();
- executeNextState(UnifiedRestoreState.FINAL);
- return;
- }
-
- // We have the data from the transport. Now we extract and strip
- // any per-package metadata (typically widget-related information)
- // if appropriate
- if (staging) {
- stage.close();
- stage = ParcelFileDescriptor.open(downloadFile,
- ParcelFileDescriptor.MODE_READ_ONLY);
-
- mBackupData = ParcelFileDescriptor.open(mBackupDataName,
- ParcelFileDescriptor.MODE_READ_WRITE |
- ParcelFileDescriptor.MODE_CREATE |
- ParcelFileDescriptor.MODE_TRUNCATE);
-
- BackupDataInput in = new BackupDataInput(stage.getFileDescriptor());
- BackupDataOutput out = new BackupDataOutput(mBackupData.getFileDescriptor());
- byte[] buffer = new byte[8192]; // will grow when needed
- while (in.readNextHeader()) {
- final String key = in.getKey();
- final int size = in.getDataSize();
-
- // is this a special key?
- if (key.equals(KEY_WIDGET_STATE)) {
- if (DEBUG) {
- Slog.i(TAG, "Restoring widget state for " + packageName);
- }
- mWidgetData = new byte[size];
- in.readEntityData(mWidgetData, 0, size);
- } else {
- if (size > buffer.length) {
- buffer = new byte[size];
- }
- in.readEntityData(buffer, 0, size);
- out.writeEntityHeader(key, size);
- out.writeEntityData(buffer, size);
- }
- }
-
- mBackupData.close();
- }
-
- // Okay, we have the data. Now have the agent do the restore.
- stage.close();
-
- mBackupData = ParcelFileDescriptor.open(mBackupDataName,
- ParcelFileDescriptor.MODE_READ_ONLY);
-
- mNewState = ParcelFileDescriptor.open(mNewStateName,
- ParcelFileDescriptor.MODE_READ_WRITE |
- ParcelFileDescriptor.MODE_CREATE |
- ParcelFileDescriptor.MODE_TRUNCATE);
-
- // Kick off the restore, checking for hung agents. The timeout or
- // the operationComplete() callback will schedule the next step,
- // so we do not do that here.
- prepareOperationTimeout(mEphemeralOpToken, TIMEOUT_RESTORE_INTERVAL,
- this, OP_TYPE_RESTORE_WAIT);
- mAgent.doRestore(mBackupData, appVersionCode, mNewState,
- mEphemeralOpToken, mBackupManagerBinder);
- } catch (Exception e) {
- Slog.e(TAG, "Unable to call app for restore: " + packageName, e);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE,
- packageName, e.toString());
- keyValueAgentErrorCleanup(); // clears any pending timeout messages as well
-
- // After a restore failure we go back to running the queue. If there
- // are no more packages to be restored that will be handled by the
- // next step.
- executeNextState(UnifiedRestoreState.RUNNING_QUEUE);
- }
- }
-
- // state RESTORE_FULL : restore one package via streaming engine
- private void restoreFull() {
- // None of this can run on the work looper here, so we spin asynchronous
- // work like this:
- //
- // StreamFeederThread: read data from mTransport.getNextFullRestoreDataChunk()
- // write it into the pipe to the engine
- // EngineThread: FullRestoreEngine thread communicating with the target app
- //
- // When finished, StreamFeederThread executes next state as appropriate on the
- // backup looper, and the overall unified restore task resumes
- try {
- StreamFeederThread feeder = new StreamFeederThread();
- if (MORE_DEBUG) {
- Slog.i(TAG, "Spinning threads for stream restore of "
- + mCurrentPackage.packageName);
- }
- new Thread(feeder, "unified-stream-feeder").start();
-
- // At this point the feeder is responsible for advancing the restore
- // state, so we're done here.
- } catch (IOException e) {
- // Unable to instantiate the feeder thread -- we need to bail on the
- // current target. We haven't asked the transport for data yet, though,
- // so we can do that simply by going back to running the restore queue.
- Slog.e(TAG, "Unable to construct pipes for stream restore!");
- executeNextState(UnifiedRestoreState.RUNNING_QUEUE);
- }
- }
-
- // state RESTORE_FINISHED : provide the "no more data" signpost callback at the end
- private void restoreFinished() {
- if (DEBUG) {
- Slog.d(TAG, "restoreFinished packageName=" + mCurrentPackage.packageName);
- }
- try {
- prepareOperationTimeout(mEphemeralOpToken, TIMEOUT_RESTORE_FINISHED_INTERVAL, this,
- OP_TYPE_RESTORE_WAIT);
- mAgent.doRestoreFinished(mEphemeralOpToken, mBackupManagerBinder);
- // If we get this far, the callback or timeout will schedule the
- // next restore state, so we're done
- } catch (Exception e) {
- final String packageName = mCurrentPackage.packageName;
- Slog.e(TAG, "Unable to finalize restore of " + packageName);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE,
- packageName, e.toString());
- keyValueAgentErrorCleanup();
- executeNextState(UnifiedRestoreState.RUNNING_QUEUE);
- }
- }
-
- class StreamFeederThread extends RestoreEngine implements Runnable, BackupRestoreTask {
- final String TAG = "StreamFeederThread";
- FullRestoreEngine mEngine;
- EngineThread mEngineThread;
-
- // pipe through which we read data from the transport. [0] read, [1] write
- ParcelFileDescriptor[] mTransportPipes;
-
- // pipe through which the engine will read data. [0] read, [1] write
- ParcelFileDescriptor[] mEnginePipes;
-
- private final int mEphemeralOpToken;
-
- public StreamFeederThread() throws IOException {
- mEphemeralOpToken = generateRandomIntegerToken();
- mTransportPipes = ParcelFileDescriptor.createPipe();
- mEnginePipes = ParcelFileDescriptor.createPipe();
- setRunning(true);
- }
-
- @Override
- public void run() {
- UnifiedRestoreState nextState = UnifiedRestoreState.RUNNING_QUEUE;
- int status = BackupTransport.TRANSPORT_OK;
-
- EventLog.writeEvent(EventLogTags.FULL_RESTORE_PACKAGE,
- mCurrentPackage.packageName);
-
- mEngine = new FullRestoreEngine(this, null, mMonitor, mCurrentPackage, false, false, mEphemeralOpToken);
- mEngineThread = new EngineThread(mEngine, mEnginePipes[0]);
-
- ParcelFileDescriptor eWriteEnd = mEnginePipes[1];
- ParcelFileDescriptor tReadEnd = mTransportPipes[0];
- ParcelFileDescriptor tWriteEnd = mTransportPipes[1];
-
- int bufferSize = 32 * 1024;
- byte[] buffer = new byte[bufferSize];
- FileOutputStream engineOut = new FileOutputStream(eWriteEnd.getFileDescriptor());
- FileInputStream transportIn = new FileInputStream(tReadEnd.getFileDescriptor());
-
- // spin up the engine and start moving data to it
- new Thread(mEngineThread, "unified-restore-engine").start();
-
- try {
- while (status == BackupTransport.TRANSPORT_OK) {
- // have the transport write some of the restoring data to us
- int result = mTransport.getNextFullRestoreDataChunk(tWriteEnd);
- if (result > 0) {
- // The transport wrote this many bytes of restore data to the
- // pipe, so pass it along to the engine.
- if (MORE_DEBUG) {
- Slog.v(TAG, " <- transport provided chunk size " + result);
- }
- if (result > bufferSize) {
- bufferSize = result;
- buffer = new byte[bufferSize];
- }
- int toCopy = result;
- while (toCopy > 0) {
- int n = transportIn.read(buffer, 0, toCopy);
- engineOut.write(buffer, 0, n);
- toCopy -= n;
- if (MORE_DEBUG) {
- Slog.v(TAG, " -> wrote " + n + " to engine, left=" + toCopy);
- }
- }
- } else if (result == BackupTransport.NO_MORE_DATA) {
- // Clean finish. Wind up and we're done!
- if (MORE_DEBUG) {
- Slog.i(TAG, "Got clean full-restore EOF for "
- + mCurrentPackage.packageName);
- }
- status = BackupTransport.TRANSPORT_OK;
- break;
- } else {
- // Transport reported some sort of failure; the fall-through
- // handling will deal properly with that.
- Slog.e(TAG, "Error " + result + " streaming restore for "
- + mCurrentPackage.packageName);
- EventLog.writeEvent(EventLogTags.RESTORE_TRANSPORT_FAILURE);
- status = result;
- }
- }
- if (MORE_DEBUG) Slog.v(TAG, "Done copying to engine, falling through");
- } catch (IOException e) {
- // We lost our ability to communicate via the pipes. That's worrying
- // but potentially recoverable; abandon this package's restore but
- // carry on with the next restore target.
- Slog.e(TAG, "Unable to route data for restore");
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE,
- mCurrentPackage.packageName, "I/O error on pipes");
- status = BackupTransport.AGENT_ERROR;
- } catch (Exception e) {
- // The transport threw; terminate the whole operation. Closing
- // the sockets will wake up the engine and it will then tidy up the
- // remote end.
- Slog.e(TAG, "Transport failed during restore: " + e.getMessage());
- EventLog.writeEvent(EventLogTags.RESTORE_TRANSPORT_FAILURE);
- status = BackupTransport.TRANSPORT_ERROR;
- } finally {
- // Close the transport pipes and *our* end of the engine pipe,
- // but leave the engine thread's end open so that it properly
- // hits EOF and winds up its operations.
- IoUtils.closeQuietly(mEnginePipes[1]);
- IoUtils.closeQuietly(mTransportPipes[0]);
- IoUtils.closeQuietly(mTransportPipes[1]);
-
- // Don't proceed until the engine has wound up operations
- mEngineThread.waitForResult();
-
- // Now we're really done with this one too
- IoUtils.closeQuietly(mEnginePipes[0]);
-
- // In all cases we want to remember whether we launched
- // the target app as part of our work so far.
- mDidLaunch = (mEngine.getAgent() != null);
-
- // If we hit a transport-level error, we are done with everything;
- // if we hit an agent error we just go back to running the queue.
- if (status == BackupTransport.TRANSPORT_OK) {
- // Clean finish means we issue the restore-finished callback
- nextState = UnifiedRestoreState.RESTORE_FINISHED;
-
- // the engine bound the target's agent, so recover that binding
- // to use for the callback.
- mAgent = mEngine.getAgent();
-
- // and the restored widget data, if any
- mWidgetData = mEngine.getWidgetData();
- } else {
- // Something went wrong somewhere. Whether it was at the transport
- // level is immaterial; we need to tell the transport to bail
- try {
- mTransport.abortFullRestore();
- } catch (Exception e) {
- // transport itself is dead; make sure we handle this as a
- // fatal error
- Slog.e(TAG, "Transport threw from abortFullRestore: " + e.getMessage());
- status = BackupTransport.TRANSPORT_ERROR;
- }
-
- // We also need to wipe the current target's data, as it's probably
- // in an incoherent state.
- clearApplicationDataSynchronous(mCurrentPackage.packageName);
-
- // Schedule the next state based on the nature of our failure
- if (status == BackupTransport.TRANSPORT_ERROR) {
- nextState = UnifiedRestoreState.FINAL;
- } else {
- nextState = UnifiedRestoreState.RUNNING_QUEUE;
- }
- }
- executeNextState(nextState);
- setRunning(false);
- }
- }
-
- // BackupRestoreTask interface, specifically for timeout handling
-
- @Override
- public void execute() { /* intentionally empty */ }
-
- @Override
- public void operationComplete(long result) { /* intentionally empty */ }
-
- // The app has timed out handling a restoring file
- @Override
- public void handleCancel(boolean cancelAll) {
- removeOperation(mEphemeralOpToken);
- if (DEBUG) {
- Slog.w(TAG, "Full-data restore target timed out; shutting down");
- }
-
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_FULL_RESTORE_TIMEOUT,
- mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, null);
- mEngineThread.handleTimeout();
-
- IoUtils.closeQuietly(mEnginePipes[1]);
- mEnginePipes[1] = null;
- IoUtils.closeQuietly(mEnginePipes[0]);
- mEnginePipes[0] = null;
- }
- }
-
- class EngineThread implements Runnable {
- FullRestoreEngine mEngine;
- FileInputStream mEngineStream;
-
- EngineThread(FullRestoreEngine engine, ParcelFileDescriptor engineSocket) {
- mEngine = engine;
- engine.setRunning(true);
- // We *do* want this FileInputStream to own the underlying fd, so that
- // when we are finished with it, it closes this end of the pipe in a way
- // that signals its other end.
- mEngineStream = new FileInputStream(engineSocket.getFileDescriptor(), true);
- }
-
- public boolean isRunning() {
- return mEngine.isRunning();
- }
-
- public int waitForResult() {
- return mEngine.waitForResult();
- }
-
- @Override
- public void run() {
- try {
- while (mEngine.isRunning()) {
- // Tell it to be sure to leave the agent instance up after finishing
- mEngine.restoreOneFile(mEngineStream, false);
- }
- } finally {
- // Because mEngineStream adopted its underlying FD, this also
- // closes this end of the pipe.
- IoUtils.closeQuietly(mEngineStream);
- }
- }
-
- public void handleTimeout() {
- IoUtils.closeQuietly(mEngineStream);
- mEngine.handleTimeout();
- }
- }
-
- // state FINAL : tear everything down and we're done.
- private void finalizeRestore() {
- if (MORE_DEBUG) Slog.d(TAG, "finishing restore mObserver=" + mObserver);
-
- try {
- mTransport.finishRestore();
- } catch (Exception e) {
- Slog.e(TAG, "Error finishing restore", e);
- }
-
- // Tell the observer we're done
- if (mObserver != null) {
- try {
- mObserver.restoreFinished(mStatus);
- } catch (RemoteException e) {
- Slog.d(TAG, "Restore observer died at restoreFinished");
- }
- }
-
- // Clear any ongoing session timeout.
- mBackupHandler.removeMessages(MSG_RESTORE_SESSION_TIMEOUT);
-
- // If we have a PM token, we must under all circumstances be sure to
- // handshake when we've finished.
- if (mPmToken > 0) {
- if (MORE_DEBUG) Slog.v(TAG, "finishing PM token " + mPmToken);
- try {
- mPackageManagerBinder.finishPackageInstall(mPmToken, mDidLaunch);
- } catch (RemoteException e) { /* can't happen */ }
- } else {
- // We were invoked via an active restore session, not by the Package
- // Manager, so start up the session timeout again.
- mBackupHandler.sendEmptyMessageDelayed(MSG_RESTORE_SESSION_TIMEOUT,
- TIMEOUT_RESTORE_INTERVAL);
- }
-
- // Kick off any work that may be needed regarding app widget restores
- // TODO: http://b/22388012
- AppWidgetBackupBridge.restoreFinished(UserHandle.USER_SYSTEM);
-
- // If this was a full-system restore, record the ancestral
- // dataset information
- if (mIsSystemRestore && mPmAgent != null) {
- mAncestralPackages = mPmAgent.getRestoredPackages();
- mAncestralToken = mToken;
- writeRestoreTokens();
- }
-
- // done; we can finally release the wakelock and be legitimately done.
- Slog.i(TAG, "Restore complete.");
-
- synchronized (mPendingRestores) {
- if (mPendingRestores.size() > 0) {
- if (DEBUG) {
- Slog.d(TAG, "Starting next pending restore.");
- }
- PerformUnifiedRestoreTask task = mPendingRestores.remove();
- mBackupHandler.sendMessage(
- mBackupHandler.obtainMessage(MSG_BACKUP_RESTORE_STEP, task));
-
- } else {
- mIsRestoreInProgress = false;
- if (MORE_DEBUG) {
- Slog.d(TAG, "No pending restores.");
- }
- }
- }
-
- mWakelock.release();
- }
-
- void keyValueAgentErrorCleanup() {
- // If the agent fails restore, it might have put the app's data
- // into an incoherent state. For consistency we wipe its data
- // again in this case before continuing with normal teardown
- clearApplicationDataSynchronous(mCurrentPackage.packageName);
- keyValueAgentCleanup();
- }
-
- // TODO: clean up naming; this is now used at finish by both k/v and stream restores
- void keyValueAgentCleanup() {
- mBackupDataName.delete();
- mStageName.delete();
- try { if (mBackupData != null) mBackupData.close(); } catch (IOException e) {}
- try { if (mNewState != null) mNewState.close(); } catch (IOException e) {}
- mBackupData = mNewState = null;
-
- // if everything went okay, remember the recorded state now
- //
- // !!! TODO: the restored data could be migrated on the server
- // side into the current dataset. In that case the new state file
- // we just created would reflect the data already extant in the
- // backend, so there'd be nothing more to do. Until that happens,
- // however, we need to make sure that we record the data to the
- // current backend dataset. (Yes, this means shipping the data over
- // the wire in both directions. That's bad, but consistency comes
- // first, then efficiency.) Once we introduce server-side data
- // migration to the newly-restored device's dataset, we will change
- // the following from a discard of the newly-written state to the
- // "correct" operation of renaming into the canonical state blob.
- mNewStateName.delete(); // TODO: remove; see above comment
- //mNewStateName.renameTo(mSavedStateName); // TODO: replace with this
-
- // If this wasn't the PM pseudopackage, tear down the agent side
- if (mCurrentPackage.applicationInfo != null) {
- // unbind and tidy up even on timeout or failure
- try {
- mActivityManager.unbindBackupAgent(mCurrentPackage.applicationInfo);
-
- // The agent was probably running with a stub Application object,
- // which isn't a valid run mode for the main app logic. Shut
- // down the app so that next time it's launched, it gets the
- // usual full initialization. Note that this is only done for
- // full-system restores: when a single app has requested a restore,
- // it is explicitly not killed following that operation.
- //
- // We execute this kill when these conditions hold:
- // 1. it's not a system-uid process,
- // 2. the app did not request its own restore (mTargetPackage == null), and either
- // 3a. the app is a full-data target (TYPE_FULL_STREAM) or
- // b. the app does not state android:killAfterRestore="false" in its manifest
- final int appFlags = mCurrentPackage.applicationInfo.flags;
- final boolean killAfterRestore =
- (mCurrentPackage.applicationInfo.uid >= Process.FIRST_APPLICATION_UID)
- && ((mRestoreDescription.getDataType() == RestoreDescription.TYPE_FULL_STREAM)
- || ((appFlags & ApplicationInfo.FLAG_KILL_AFTER_RESTORE) != 0));
-
- if (mTargetPackage == null && killAfterRestore) {
- if (DEBUG) Slog.d(TAG, "Restore complete, killing host process of "
- + mCurrentPackage.applicationInfo.processName);
- mActivityManager.killApplicationProcess(
- mCurrentPackage.applicationInfo.processName,
- mCurrentPackage.applicationInfo.uid);
- }
- } catch (RemoteException e) {
- // can't happen; we run in the same process as the activity manager
- }
- }
-
- // The caller is responsible for reestablishing the state machine; our
- // responsibility here is to clear the decks for whatever comes next.
- mBackupHandler.removeMessages(MSG_RESTORE_OPERATION_TIMEOUT, this);
- }
-
- @Override
- public void operationComplete(long unusedResult) {
- removeOperation(mEphemeralOpToken);
- if (MORE_DEBUG) {
- Slog.i(TAG, "operationComplete() during restore: target="
- + mCurrentPackage.packageName
- + " state=" + mState);
- }
-
- final UnifiedRestoreState nextState;
- switch (mState) {
- case INITIAL:
- // We've just (manually) restored the PMBA. It doesn't need the
- // additional restore-finished callback so we bypass that and go
- // directly to running the queue.
- nextState = UnifiedRestoreState.RUNNING_QUEUE;
- break;
-
- case RESTORE_KEYVALUE:
- case RESTORE_FULL: {
- // Okay, we've just heard back from the agent that it's done with
- // the restore itself. We now have to send the same agent its
- // doRestoreFinished() callback, so roll into that state.
- nextState = UnifiedRestoreState.RESTORE_FINISHED;
- break;
- }
-
- case RESTORE_FINISHED: {
- // Okay, we're done with this package. Tidy up and go on to the next
- // app in the queue.
- int size = (int) mBackupDataName.length();
- EventLog.writeEvent(EventLogTags.RESTORE_PACKAGE,
- mCurrentPackage.packageName, size);
-
- // Just go back to running the restore queue
- keyValueAgentCleanup();
-
- // If there was widget state associated with this app, get the OS to
- // incorporate it into current bookeeping and then pass that along to
- // the app as part of the restore-time work.
- if (mWidgetData != null) {
- restoreWidgetData(mCurrentPackage.packageName, mWidgetData);
- }
-
- nextState = UnifiedRestoreState.RUNNING_QUEUE;
- break;
- }
-
- default: {
- // Some kind of horrible semantic error; we're in an unexpected state.
- // Back off hard and wind up.
- Slog.e(TAG, "Unexpected restore callback into state " + mState);
- keyValueAgentErrorCleanup();
- nextState = UnifiedRestoreState.FINAL;
- break;
- }
- }
-
- executeNextState(nextState);
- }
-
- // A call to agent.doRestore() or agent.doRestoreFinished() has timed out
- @Override
- public void handleCancel(boolean cancelAll) {
- removeOperation(mEphemeralOpToken);
- Slog.e(TAG, "Timeout restoring application " + mCurrentPackage.packageName);
- mMonitor = monitorEvent(mMonitor,
- BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_RESTORE_TIMEOUT,
- mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, null);
- EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE,
- mCurrentPackage.packageName, "restore timeout");
- // Handle like an agent that threw on invocation: wipe it and go on to the next
- keyValueAgentErrorCleanup();
- executeNextState(UnifiedRestoreState.RUNNING_QUEUE);
- }
-
- void executeNextState(UnifiedRestoreState nextState) {
- if (MORE_DEBUG) Slog.i(TAG, " => executing next step on "
- + this + " nextState=" + nextState);
- mState = nextState;
- Message msg = mBackupHandler.obtainMessage(MSG_BACKUP_RESTORE_STEP, this);
- mBackupHandler.sendMessage(msg);
- }
-
- // restore observer support
- void sendStartRestore(int numPackages) {
- if (mObserver != null) {
- try {
- mObserver.restoreStarting(numPackages);
- } catch (RemoteException e) {
- Slog.w(TAG, "Restore observer went away: startRestore");
- mObserver = null;
- }
- }
- }
-
- void sendOnRestorePackage(String name) {
- if (mObserver != null) {
- if (mObserver != null) {
- try {
- mObserver.onUpdate(mCount, name);
- } catch (RemoteException e) {
- Slog.d(TAG, "Restore observer died in onUpdate");
- mObserver = null;
- }
- }
- }
- }
-
- void sendEndRestore() {
- if (mObserver != null) {
- try {
- mObserver.restoreFinished(mStatus);
- } catch (RemoteException e) {
- Slog.w(TAG, "Restore observer went away: endRestore");
- mObserver = null;
- }
- }
- }
- }
-
- class PerformClearTask implements Runnable {
- IBackupTransport mTransport;
- PackageInfo mPackage;
-
- PerformClearTask(IBackupTransport transport, PackageInfo packageInfo) {
- mTransport = transport;
- mPackage = packageInfo;
- }
-
- public void run() {
- try {
- // Clear the on-device backup state to ensure a full backup next time
- File stateDir = new File(mBaseStateDir, mTransport.transportDirName());
- File stateFile = new File(stateDir, mPackage.packageName);
- stateFile.delete();
-
- // Tell the transport to remove all the persistent storage for the app
- // TODO - need to handle failures
- mTransport.clearBackupData(mPackage);
- } catch (Exception e) {
- Slog.e(TAG, "Transport threw clearing data for " + mPackage + ": " + e.getMessage());
- } finally {
- try {
- // TODO - need to handle failures
- mTransport.finishBackup();
- } catch (Exception e) {
- // Nothing we can do here, alas
- Slog.e(TAG, "Unable to mark clear operation finished: " + e.getMessage());
- }
-
- // Last but not least, release the cpu
- mWakelock.release();
- }
- }
- }
-
- class PerformInitializeTask implements Runnable {
- String[] mQueue;
- IBackupObserver mObserver;
-
- PerformInitializeTask(String[] transportNames, IBackupObserver observer) {
- mQueue = transportNames;
- mObserver = observer;
- }
-
- private void notifyResult(String target, int status) {
- try {
- if (mObserver != null) {
- mObserver.onResult(target, status);
- }
- } catch (RemoteException ignored) {
- mObserver = null; // don't try again
- }
- }
-
- private void notifyFinished(int status) {
- try {
- if (mObserver != null) {
- mObserver.backupFinished(status);
- }
- } catch (RemoteException ignored) {
- mObserver = null;
- }
- }
-
- public void run() {
- // mWakelock is *acquired* when execution begins here
- int result = BackupTransport.TRANSPORT_OK;
- try {
- for (String transportName : mQueue) {
- IBackupTransport transport =
- mTransportManager.getTransportBinder(transportName);
- if (transport == null) {
- Slog.e(TAG, "Requested init for " + transportName + " but not found");
- continue;
- }
-
- Slog.i(TAG, "Initializing (wiping) backup transport storage: " + transportName);
- String transportDirName = transport.transportDirName();
- EventLog.writeEvent(EventLogTags.BACKUP_START, transportDirName);
- long startRealtime = SystemClock.elapsedRealtime();
- int status = transport.initializeDevice();
-
- if (status == BackupTransport.TRANSPORT_OK) {
- status = transport.finishBackup();
- }
-
- // Okay, the wipe really happened. Clean up our local bookkeeping.
- if (status == BackupTransport.TRANSPORT_OK) {
- Slog.i(TAG, "Device init successful");
- int millis = (int) (SystemClock.elapsedRealtime() - startRealtime);
- EventLog.writeEvent(EventLogTags.BACKUP_INITIALIZE);
- resetBackupState(new File(mBaseStateDir, transportDirName));
- EventLog.writeEvent(EventLogTags.BACKUP_SUCCESS, 0, millis);
- synchronized (mQueueLock) {
- recordInitPendingLocked(false, transportName);
- }
- notifyResult(transportName, BackupTransport.TRANSPORT_OK);
- } else {
- // If this didn't work, requeue this one and try again
- // after a suitable interval
- Slog.e(TAG, "Transport error in initializeDevice()");
- EventLog.writeEvent(EventLogTags.BACKUP_TRANSPORT_FAILURE, "(initialize)");
- synchronized (mQueueLock) {
- recordInitPendingLocked(true, transportName);
- }
- notifyResult(transportName, status);
- result = status;
-
- // do this via another alarm to make sure of the wakelock states
- long delay = transport.requestBackupTime();
- Slog.w(TAG, "Init failed on " + transportName + " resched in " + delay);
- mAlarmManager.set(AlarmManager.RTC_WAKEUP,
- System.currentTimeMillis() + delay, mRunInitIntent);
- }
- }
- } catch (Exception e) {
- Slog.e(TAG, "Unexpected error performing init", e);
- result = BackupTransport.TRANSPORT_ERROR;
- } finally {
- // Done; release the wakelock
- notifyFinished(result);
- mWakelock.release();
- }
- }
- }
-
- private void dataChangedImpl(String packageName) {
- HashSet<String> targets = dataChangedTargets(packageName);
- dataChangedImpl(packageName, targets);
- }
-
- private void dataChangedImpl(String packageName, HashSet<String> targets) {
- // Record that we need a backup pass for the caller. Since multiple callers
- // may share a uid, we need to note all candidates within that uid and schedule
- // a backup pass for each of them.
- if (targets == null) {
- Slog.w(TAG, "dataChanged but no participant pkg='" + packageName + "'"
- + " uid=" + Binder.getCallingUid());
- return;
- }
-
- synchronized (mQueueLock) {
- // Note that this client has made data changes that need to be backed up
- if (targets.contains(packageName)) {
- // Add the caller to the set of pending backups. If there is
- // one already there, then overwrite it, but no harm done.
- BackupRequest req = new BackupRequest(packageName);
- if (mPendingBackups.put(packageName, req) == null) {
- if (MORE_DEBUG) Slog.d(TAG, "Now staging backup of " + packageName);
-
- // Journal this request in case of crash. The put()
- // operation returned null when this package was not already
- // in the set; we want to avoid touching the disk redundantly.
- writeToJournalLocked(packageName);
- }
- }
- }
-
- // ...and schedule a backup pass if necessary
- KeyValueBackupJob.schedule(mContext, mConstants);
- }
-
- // Note: packageName is currently unused, but may be in the future
- private HashSet<String> dataChangedTargets(String packageName) {
- // If the caller does not hold the BACKUP permission, it can only request a
- // backup of its own data.
- if ((mContext.checkPermission(android.Manifest.permission.BACKUP, Binder.getCallingPid(),
- Binder.getCallingUid())) == PackageManager.PERMISSION_DENIED) {
- synchronized (mBackupParticipants) {
- return mBackupParticipants.get(Binder.getCallingUid());
- }
- }
-
- // a caller with full permission can ask to back up any participating app
- HashSet<String> targets = new HashSet<String>();
- if (PACKAGE_MANAGER_SENTINEL.equals(packageName)) {
- targets.add(PACKAGE_MANAGER_SENTINEL);
- } else {
- synchronized (mBackupParticipants) {
- int N = mBackupParticipants.size();
- for (int i = 0; i < N; i++) {
- HashSet<String> s = mBackupParticipants.valueAt(i);
- if (s != null) {
- targets.addAll(s);
- }
- }
- }
- }
- return targets;
- }
-
- private void writeToJournalLocked(String str) {
- RandomAccessFile out = null;
- try {
- if (mJournal == null) mJournal = File.createTempFile("journal", null, mJournalDir);
- out = new RandomAccessFile(mJournal, "rws");
- out.seek(out.length());
- out.writeUTF(str);
- } catch (IOException e) {
- Slog.e(TAG, "Can't write " + str + " to backup journal", e);
- mJournal = null;
- } finally {
- try { if (out != null) out.close(); } catch (IOException e) {}
- }
- }
-
- // ----- IBackupManager binder interface -----
-
- @Override
- public void dataChanged(final String packageName) {
- final int callingUserHandle = UserHandle.getCallingUserId();
- if (callingUserHandle != UserHandle.USER_SYSTEM) {
- // TODO: http://b/22388012
- // App is running under a non-owner user profile. For now, we do not back
- // up data from secondary user profiles.
- // TODO: backups for all user profiles although don't add backup for profiles
- // without adding admin control in DevicePolicyManager.
- if (MORE_DEBUG) {
- Slog.v(TAG, "dataChanged(" + packageName + ") ignored because it's user "
- + callingUserHandle);
- }
- return;
- }
-
- final HashSet<String> targets = dataChangedTargets(packageName);
- if (targets == null) {
- Slog.w(TAG, "dataChanged but no participant pkg='" + packageName + "'"
- + " uid=" + Binder.getCallingUid());
- return;
- }
-
- mBackupHandler.post(new Runnable() {
- public void run() {
- dataChangedImpl(packageName, targets);
- }
- });
- }
-
- // Run an initialize operation for the given transport
- @Override
- public void initializeTransports(String[] transportNames, IBackupObserver observer) {
- mContext.enforceCallingPermission(android.Manifest.permission.BACKUP, "initializeTransport");
- if (MORE_DEBUG) {
- Slog.v(TAG, "initializeTransports() of " + transportNames);
- }
-
- final long oldId = Binder.clearCallingIdentity();
- try {
- mWakelock.acquire();
- mBackupHandler.post(new PerformInitializeTask(transportNames, observer));
- } finally {
- Binder.restoreCallingIdentity(oldId);
- }
- }
-
- // Clear the given package's backup data from the current transport
- @Override
- public void clearBackupData(String transportName, String packageName) {
- if (DEBUG) Slog.v(TAG, "clearBackupData() of " + packageName + " on " + transportName);
- PackageInfo info;
- try {
- info = mPackageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
- } catch (NameNotFoundException e) {
- Slog.d(TAG, "No such package '" + packageName + "' - not clearing backup data");
- return;
- }
-
- // If the caller does not hold the BACKUP permission, it can only request a
- // wipe of its own backed-up data.
- HashSet<String> apps;
- if ((mContext.checkPermission(android.Manifest.permission.BACKUP, Binder.getCallingPid(),
- Binder.getCallingUid())) == PackageManager.PERMISSION_DENIED) {
- apps = mBackupParticipants.get(Binder.getCallingUid());
- } else {
- // a caller with full permission can ask to back up any participating app
- // !!! TODO: allow data-clear of ANY app?
- if (MORE_DEBUG) Slog.v(TAG, "Privileged caller, allowing clear of other apps");
- apps = new HashSet<String>();
- int N = mBackupParticipants.size();
- for (int i = 0; i < N; i++) {
- HashSet<String> s = mBackupParticipants.valueAt(i);
- if (s != null) {
- apps.addAll(s);
- }
- }
- }
-
- // Is the given app an available participant?
- if (apps.contains(packageName)) {
- // found it; fire off the clear request
- if (MORE_DEBUG) Slog.v(TAG, "Found the app - running clear process");
- mBackupHandler.removeMessages(MSG_RETRY_CLEAR);
- synchronized (mQueueLock) {
- final IBackupTransport transport =
- mTransportManager.getTransportBinder(transportName);
- if (transport == null) {
- // transport is currently unavailable -- make sure to retry
- Message msg = mBackupHandler.obtainMessage(MSG_RETRY_CLEAR,
- new ClearRetryParams(transportName, packageName));
- mBackupHandler.sendMessageDelayed(msg, TRANSPORT_RETRY_INTERVAL);
- return;
- }
- long oldId = Binder.clearCallingIdentity();
- mWakelock.acquire();
- Message msg = mBackupHandler.obtainMessage(MSG_RUN_CLEAR,
- new ClearParams(transport, info));
- mBackupHandler.sendMessage(msg);
- Binder.restoreCallingIdentity(oldId);
- }
- }
- }
-
- // Run a backup pass immediately for any applications that have declared
- // that they have pending updates.
- @Override
- public void backupNow() {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP, "backupNow");
-
- final PowerSaveState result =
- mPowerManager.getPowerSaveState(ServiceType.KEYVALUE_BACKUP);
- if (result.batterySaverEnabled) {
- if (DEBUG) Slog.v(TAG, "Not running backup while in battery save mode");
- KeyValueBackupJob.schedule(mContext, mConstants); // try again in several hours
- } else {
- if (DEBUG) Slog.v(TAG, "Scheduling immediate backup pass");
- synchronized (mQueueLock) {
- // Fire the intent that kicks off the whole shebang...
- try {
- mRunBackupIntent.send();
- } catch (PendingIntent.CanceledException e) {
- // should never happen
- Slog.e(TAG, "run-backup intent cancelled!");
- }
-
- // ...and cancel any pending scheduled job, because we've just superseded it
- KeyValueBackupJob.cancel(mContext);
- }
- }
- }
-
- boolean deviceIsProvisioned() {
- final ContentResolver resolver = mContext.getContentResolver();
- return (Settings.Global.getInt(resolver, Settings.Global.DEVICE_PROVISIONED, 0) != 0);
- }
-
- // Run a backup pass for the given packages, writing the resulting data stream
- // to the supplied file descriptor. This method is synchronous and does not return
- // to the caller until the backup has been completed.
- //
- // This is the variant used by 'adb backup'; it requires on-screen confirmation
- // by the user because it can be used to offload data over untrusted USB.
- @Override
- public void adbBackup(ParcelFileDescriptor fd, boolean includeApks, boolean includeObbs,
- boolean includeShared, boolean doWidgets, boolean doAllApps, boolean includeSystem,
- boolean compress, boolean doKeyValue, String[] pkgList) {
- mContext.enforceCallingPermission(android.Manifest.permission.BACKUP, "adbBackup");
-
- final int callingUserHandle = UserHandle.getCallingUserId();
- // TODO: http://b/22388012
- if (callingUserHandle != UserHandle.USER_SYSTEM) {
- throw new IllegalStateException("Backup supported only for the device owner");
- }
-
- // Validate
- if (!doAllApps) {
- if (!includeShared) {
- // If we're backing up shared data (sdcard or equivalent), then we can run
- // without any supplied app names. Otherwise, we'd be doing no work, so
- // report the error.
- if (pkgList == null || pkgList.length == 0) {
- throw new IllegalArgumentException(
- "Backup requested but neither shared nor any apps named");
- }
- }
- }
-
- long oldId = Binder.clearCallingIdentity();
- try {
- // Doesn't make sense to do a full backup prior to setup
- if (!deviceIsProvisioned()) {
- Slog.i(TAG, "Backup not supported before setup");
- return;
- }
-
- if (DEBUG) Slog.v(TAG, "Requesting backup: apks=" + includeApks + " obb=" + includeObbs
- + " shared=" + includeShared + " all=" + doAllApps + " system="
- + includeSystem + " includekeyvalue=" + doKeyValue + " pkgs=" + pkgList);
- Slog.i(TAG, "Beginning adb backup...");
-
- AdbBackupParams params = new AdbBackupParams(fd, includeApks, includeObbs,
- includeShared, doWidgets, doAllApps, includeSystem, compress, doKeyValue,
- pkgList);
- final int token = generateRandomIntegerToken();
- synchronized (mAdbBackupRestoreConfirmations) {
- mAdbBackupRestoreConfirmations.put(token, params);
- }
-
- // start up the confirmation UI
- if (DEBUG) Slog.d(TAG, "Starting backup confirmation UI, token=" + token);
- if (!startConfirmationUi(token, FullBackup.FULL_BACKUP_INTENT_ACTION)) {
- Slog.e(TAG, "Unable to launch backup confirmation UI");
- mAdbBackupRestoreConfirmations.delete(token);
- return;
- }
-
- // make sure the screen is lit for the user interaction
- mPowerManager.userActivity(SystemClock.uptimeMillis(),
- PowerManager.USER_ACTIVITY_EVENT_OTHER,
- 0);
-
- // start the confirmation countdown
- startConfirmationTimeout(token, params);
-
- // wait for the backup to be performed
- if (DEBUG) Slog.d(TAG, "Waiting for backup completion...");
- waitForCompletion(params);
- } finally {
- try {
- fd.close();
- } catch (IOException e) {
- Slog.e(TAG, "IO error closing output for adb backup: " + e.getMessage());
- }
- Binder.restoreCallingIdentity(oldId);
- Slog.d(TAG, "Adb backup processing complete.");
- }
- }
-
- @Override
- public void fullTransportBackup(String[] pkgNames) {
- mContext.enforceCallingPermission(android.Manifest.permission.BACKUP,
- "fullTransportBackup");
-
- final int callingUserHandle = UserHandle.getCallingUserId();
- // TODO: http://b/22388012
- if (callingUserHandle != UserHandle.USER_SYSTEM) {
- throw new IllegalStateException("Restore supported only for the device owner");
- }
-
- if (!fullBackupAllowable(mTransportManager.getCurrentTransportBinder())) {
- Slog.i(TAG, "Full backup not currently possible -- key/value backup not yet run?");
- } else {
- if (DEBUG) {
- Slog.d(TAG, "fullTransportBackup()");
- }
-
- final long oldId = Binder.clearCallingIdentity();
- try {
- CountDownLatch latch = new CountDownLatch(1);
- PerformFullTransportBackupTask task = new PerformFullTransportBackupTask(null,
- pkgNames, false, null, latch, null, null, false /* userInitiated */);
- // Acquiring wakelock for PerformFullTransportBackupTask before its start.
- mWakelock.acquire();
- (new Thread(task, "full-transport-master")).start();
- do {
- try {
- latch.await();
- break;
- } catch (InterruptedException e) {
- // Just go back to waiting for the latch to indicate completion
- }
- } while (true);
-
- // We just ran a backup on these packages, so kick them to the end of the queue
- final long now = System.currentTimeMillis();
- for (String pkg : pkgNames) {
- enqueueFullBackup(pkg, now);
- }
- } finally {
- Binder.restoreCallingIdentity(oldId);
- }
- }
-
- if (DEBUG) {
- Slog.d(TAG, "Done with full transport backup.");
- }
- }
-
- @Override
- public void adbRestore(ParcelFileDescriptor fd) {
- mContext.enforceCallingPermission(android.Manifest.permission.BACKUP, "adbRestore");
-
- final int callingUserHandle = UserHandle.getCallingUserId();
- // TODO: http://b/22388012
- if (callingUserHandle != UserHandle.USER_SYSTEM) {
- throw new IllegalStateException("Restore supported only for the device owner");
- }
-
- long oldId = Binder.clearCallingIdentity();
-
- try {
- // Check whether the device has been provisioned -- we don't handle
- // full restores prior to completing the setup process.
- if (!deviceIsProvisioned()) {
- Slog.i(TAG, "Full restore not permitted before setup");
- return;
- }
-
- Slog.i(TAG, "Beginning restore...");
-
- AdbRestoreParams params = new AdbRestoreParams(fd);
- final int token = generateRandomIntegerToken();
- synchronized (mAdbBackupRestoreConfirmations) {
- mAdbBackupRestoreConfirmations.put(token, params);
- }
-
- // start up the confirmation UI
- if (DEBUG) Slog.d(TAG, "Starting restore confirmation UI, token=" + token);
- if (!startConfirmationUi(token, FullBackup.FULL_RESTORE_INTENT_ACTION)) {
- Slog.e(TAG, "Unable to launch restore confirmation");
- mAdbBackupRestoreConfirmations.delete(token);
- return;
- }
-
- // make sure the screen is lit for the user interaction
- mPowerManager.userActivity(SystemClock.uptimeMillis(),
- PowerManager.USER_ACTIVITY_EVENT_OTHER,
- 0);
-
- // start the confirmation countdown
- startConfirmationTimeout(token, params);
-
- // wait for the restore to be performed
- if (DEBUG) Slog.d(TAG, "Waiting for restore completion...");
- waitForCompletion(params);
- } finally {
- try {
- fd.close();
- } catch (IOException e) {
- Slog.w(TAG, "Error trying to close fd after adb restore: " + e);
- }
- Binder.restoreCallingIdentity(oldId);
- Slog.i(TAG, "adb restore processing complete.");
- }
- }
-
- boolean startConfirmationUi(int token, String action) {
- try {
- Intent confIntent = new Intent(action);
- confIntent.setClassName("com.android.backupconfirm",
- "com.android.backupconfirm.BackupRestoreConfirmation");
- confIntent.putExtra(FullBackup.CONF_TOKEN_INTENT_EXTRA, token);
- confIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
- mContext.startActivityAsUser(confIntent, UserHandle.SYSTEM);
- } catch (ActivityNotFoundException e) {
- return false;
- }
- return true;
- }
-
- void startConfirmationTimeout(int token, AdbParams params) {
- if (MORE_DEBUG) Slog.d(TAG, "Posting conf timeout msg after "
- + TIMEOUT_FULL_CONFIRMATION + " millis");
- Message msg = mBackupHandler.obtainMessage(MSG_FULL_CONFIRMATION_TIMEOUT,
- token, 0, params);
- mBackupHandler.sendMessageDelayed(msg, TIMEOUT_FULL_CONFIRMATION);
- }
-
- void waitForCompletion(AdbParams params) {
- synchronized (params.latch) {
- while (params.latch.get() == false) {
- try {
- params.latch.wait();
- } catch (InterruptedException e) { /* never interrupted */ }
- }
- }
- }
-
- void signalAdbBackupRestoreCompletion(AdbParams params) {
- synchronized (params.latch) {
- params.latch.set(true);
- params.latch.notifyAll();
- }
- }
-
- // Confirm that the previously-requested full backup/restore operation can proceed. This
- // is used to require a user-facing disclosure about the operation.
- @Override
- public void acknowledgeAdbBackupOrRestore(int token, boolean allow,
- String curPassword, String encPpassword, IFullBackupRestoreObserver observer) {
- if (DEBUG) Slog.d(TAG, "acknowledgeAdbBackupOrRestore : token=" + token
- + " allow=" + allow);
-
- // TODO: possibly require not just this signature-only permission, but even
- // require that the specific designated confirmation-UI app uid is the caller?
- mContext.enforceCallingPermission(android.Manifest.permission.BACKUP, "acknowledgeAdbBackupOrRestore");
-
- long oldId = Binder.clearCallingIdentity();
- try {
-
- AdbParams params;
- synchronized (mAdbBackupRestoreConfirmations) {
- params = mAdbBackupRestoreConfirmations.get(token);
- if (params != null) {
- mBackupHandler.removeMessages(MSG_FULL_CONFIRMATION_TIMEOUT, params);
- mAdbBackupRestoreConfirmations.delete(token);
-
- if (allow) {
- final int verb = params instanceof AdbBackupParams
- ? MSG_RUN_ADB_BACKUP
- : MSG_RUN_ADB_RESTORE;
-
- params.observer = observer;
- params.curPassword = curPassword;
-
- params.encryptPassword = encPpassword;
-
- if (MORE_DEBUG) Slog.d(TAG, "Sending conf message with verb " + verb);
- mWakelock.acquire();
- Message msg = mBackupHandler.obtainMessage(verb, params);
- mBackupHandler.sendMessage(msg);
- } else {
- Slog.w(TAG, "User rejected full backup/restore operation");
- // indicate completion without having actually transferred any data
- signalAdbBackupRestoreCompletion(params);
- }
- } else {
- Slog.w(TAG, "Attempted to ack full backup/restore with invalid token");
- }
- }
- } finally {
- Binder.restoreCallingIdentity(oldId);
- }
- }
-
- private static boolean backupSettingMigrated(int userId) {
- File base = new File(Environment.getDataDirectory(), "backup");
- File enableFile = new File(base, BACKUP_ENABLE_FILE);
- return enableFile.exists();
- }
-
- private static boolean readBackupEnableState(int userId) {
- File base = new File(Environment.getDataDirectory(), "backup");
- File enableFile = new File(base, BACKUP_ENABLE_FILE);
- if (enableFile.exists()) {
- try (FileInputStream fin = new FileInputStream(enableFile)) {
- int state = fin.read();
- return state != 0;
- } catch (IOException e) {
- // can't read the file; fall through to assume disabled
- Slog.e(TAG, "Cannot read enable state; assuming disabled");
- }
- } else {
- if (DEBUG) {
- Slog.i(TAG, "isBackupEnabled() => false due to absent settings file");
- }
- }
- return false;
- }
-
- private static void writeBackupEnableState(boolean enable, int userId) {
- File base = new File(Environment.getDataDirectory(), "backup");
- File enableFile = new File(base, BACKUP_ENABLE_FILE);
- File stage = new File(base, BACKUP_ENABLE_FILE + "-stage");
- FileOutputStream fout = null;
- try {
- fout = new FileOutputStream(stage);
- fout.write(enable ? 1 : 0);
- fout.close();
- stage.renameTo(enableFile);
- // will be synced immediately by the try-with-resources call to close()
- } catch (IOException|RuntimeException e) {
- // Whoops; looks like we're doomed. Roll everything out, disabled,
- // including the legacy state.
- Slog.e(TAG, "Unable to record backup enable state; reverting to disabled: "
- + e.getMessage());
-
- final ContentResolver r = sInstance.mContext.getContentResolver();
- Settings.Secure.putStringForUser(r,
- Settings.Secure.BACKUP_ENABLED, null, userId);
- enableFile.delete();
- stage.delete();
- } finally {
- IoUtils.closeQuietly(fout);
- }
- }
-
- // Enable/disable backups
- @Override
- public void setBackupEnabled(boolean enable) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "setBackupEnabled");
-
- Slog.i(TAG, "Backup enabled => " + enable);
-
- long oldId = Binder.clearCallingIdentity();
- try {
- boolean wasEnabled = mEnabled;
- synchronized (this) {
- writeBackupEnableState(enable, UserHandle.USER_SYSTEM);
- mEnabled = enable;
- }
-
- synchronized (mQueueLock) {
- if (enable && !wasEnabled && mProvisioned) {
- // if we've just been enabled, start scheduling backup passes
- KeyValueBackupJob.schedule(mContext, mConstants);
- scheduleNextFullBackupJob(0);
- } else if (!enable) {
- // No longer enabled, so stop running backups
- if (MORE_DEBUG) Slog.i(TAG, "Opting out of backup");
-
- KeyValueBackupJob.cancel(mContext);
-
- // This also constitutes an opt-out, so we wipe any data for
- // this device from the backend. We start that process with
- // an alarm in order to guarantee wakelock states.
- if (wasEnabled && mProvisioned) {
- // NOTE: we currently flush every registered transport, not just
- // the currently-active one.
- String[] allTransports = mTransportManager.getBoundTransportNames();
- // build the set of transports for which we are posting an init
- for (String transport : allTransports) {
- recordInitPendingLocked(true, transport);
- }
- mAlarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(),
- mRunInitIntent);
- }
- }
- }
- } finally {
- Binder.restoreCallingIdentity(oldId);
- }
- }
-
- // Enable/disable automatic restore of app data at install time
- @Override
- public void setAutoRestore(boolean doAutoRestore) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "setAutoRestore");
-
- Slog.i(TAG, "Auto restore => " + doAutoRestore);
-
- final long oldId = Binder.clearCallingIdentity();
- try {
- synchronized (this) {
- Settings.Secure.putInt(mContext.getContentResolver(),
- Settings.Secure.BACKUP_AUTO_RESTORE, doAutoRestore ? 1 : 0);
- mAutoRestore = doAutoRestore;
- }
- } finally {
- Binder.restoreCallingIdentity(oldId);
- }
- }
-
- // Mark the backup service as having been provisioned
- @Override
- public void setBackupProvisioned(boolean available) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "setBackupProvisioned");
- /*
- * This is now a no-op; provisioning is simply the device's own setup state.
- */
- }
-
- // Report whether the backup mechanism is currently enabled
- @Override
- public boolean isBackupEnabled() {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP, "isBackupEnabled");
- return mEnabled; // no need to synchronize just to read it
- }
-
- @Override
- public void updateTransportAttributes(
- ComponentName transportComponent,
- String name,
- Intent configurationIntent,
- String currentDestinationString,
- Intent dataManagementIntent,
- String dataManagementLabel) {
- mContext.enforceCallingOrSelfPermission(
- android.Manifest.permission.BACKUP, "updateTransportAttributes");
- Slog.e(TAG, "Unsupported operation");
- }
-
- // Report the name of the currently active transport
- @Override
- public String getCurrentTransport() {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "getCurrentTransport");
- String currentTransport = mTransportManager.getCurrentTransportName();
- if (MORE_DEBUG) Slog.v(TAG, "... getCurrentTransport() returning " + currentTransport);
- return currentTransport;
- }
-
- // Report all known, available backup transports
- @Override
- public String[] listAllTransports() {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP, "listAllTransports");
-
- return mTransportManager.getBoundTransportNames();
- }
-
- @Override
- public ComponentName[] listAllTransportComponents() {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "listAllTransportComponents");
- return mTransportManager.getAllTransportComponents();
- }
-
- @Override
- public String[] getTransportWhitelist() {
- // No permission check, intentionally.
- Set<ComponentName> whitelistedComponents = mTransportManager.getTransportWhitelist();
- String[] whitelistedTransports = new String[whitelistedComponents.size()];
- int i = 0;
- for (ComponentName component : whitelistedComponents) {
- whitelistedTransports[i] = component.flattenToShortString();
- i++;
- }
- return whitelistedTransports;
- }
-
- // Select which transport to use for the next backup operation.
- @Override
- public String selectBackupTransport(String transport) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "selectBackupTransport");
-
- final long oldId = Binder.clearCallingIdentity();
- try {
- String prevTransport = mTransportManager.selectTransport(transport);
- updateStateForTransport(transport);
- Slog.v(TAG, "selectBackupTransport() set " + mTransportManager.getCurrentTransportName()
- + " returning " + prevTransport);
- return prevTransport;
- } finally {
- Binder.restoreCallingIdentity(oldId);
- }
- }
-
- @Override
- public void selectBackupTransportAsync(final ComponentName transport,
- final ISelectBackupTransportCallback listener) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "selectBackupTransportAsync");
-
- final long oldId = Binder.clearCallingIdentity();
-
- Slog.v(TAG, "selectBackupTransportAsync() called with transport " +
- transport.flattenToShortString());
-
- mTransportManager.ensureTransportReady(transport, new TransportManager.TransportReadyCallback() {
- @Override
- public void onSuccess(String transportName) {
- mTransportManager.selectTransport(transportName);
- updateStateForTransport(mTransportManager.getCurrentTransportName());
- Slog.v(TAG, "Transport successfully selected: " + transport.flattenToShortString());
- try {
- listener.onSuccess(transportName);
- } catch (RemoteException e) {
- // Nothing to do here.
- }
- }
-
- @Override
- public void onFailure(int reason) {
- Slog.v(TAG, "Failed to select transport: " + transport.flattenToShortString());
- try {
- listener.onFailure(reason);
- } catch (RemoteException e) {
- // Nothing to do here.
- }
- }
- });
-
- Binder.restoreCallingIdentity(oldId);
- }
-
- private void updateStateForTransport(String newTransportName) {
- // Publish the name change
- Settings.Secure.putString(mContext.getContentResolver(),
- Settings.Secure.BACKUP_TRANSPORT, newTransportName);
-
- // And update our current-dataset bookkeeping
- IBackupTransport transport = mTransportManager.getTransportBinder(newTransportName);
- if (transport != null) {
- try {
- mCurrentToken = transport.getCurrentRestoreSet();
- } catch (Exception e) {
- // Oops. We can't know the current dataset token, so reset and figure it out
- // when we do the next k/v backup operation on this transport.
- mCurrentToken = 0;
- }
- } else {
- // The named transport isn't bound at this particular moment, so we can't
- // know yet what its current dataset token is. Reset as above.
- mCurrentToken = 0;
- }
- }
-
- // Supply the configuration Intent for the given transport. If the name is not one
- // of the available transports, or if the transport does not supply any configuration
- // UI, the method returns null.
- @Override
- public Intent getConfigurationIntent(String transportName) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "getConfigurationIntent");
-
- final IBackupTransport transport = mTransportManager.getTransportBinder(transportName);
- if (transport != null) {
- try {
- final Intent intent = transport.configurationIntent();
- if (MORE_DEBUG) Slog.d(TAG, "getConfigurationIntent() returning config intent "
- + intent);
- return intent;
- } catch (Exception e) {
- /* fall through to return null */
- Slog.e(TAG, "Unable to get configuration intent from transport: " + e.getMessage());
- }
- }
-
- return null;
- }
-
- // Supply the configuration summary string for the given transport. If the name is
- // not one of the available transports, or if the transport does not supply any
- // summary / destination string, the method can return null.
- //
- // This string is used VERBATIM as the summary text of the relevant Settings item!
- @Override
- public String getDestinationString(String transportName) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "getDestinationString");
-
- final IBackupTransport transport = mTransportManager.getTransportBinder(transportName);
- if (transport != null) {
- try {
- final String text = transport.currentDestinationString();
- if (MORE_DEBUG) Slog.d(TAG, "getDestinationString() returning " + text);
- return text;
- } catch (Exception e) {
- /* fall through to return null */
- Slog.e(TAG, "Unable to get string from transport: " + e.getMessage());
- }
- }
-
- return null;
- }
-
- // Supply the manage-data intent for the given transport.
- @Override
- public Intent getDataManagementIntent(String transportName) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "getDataManagementIntent");
-
- final IBackupTransport transport = mTransportManager.getTransportBinder(transportName);
- if (transport != null) {
- try {
- final Intent intent = transport.dataManagementIntent();
- if (MORE_DEBUG) Slog.d(TAG, "getDataManagementIntent() returning intent "
- + intent);
- return intent;
- } catch (Exception e) {
- /* fall through to return null */
- Slog.e(TAG, "Unable to get management intent from transport: " + e.getMessage());
- }
- }
-
- return null;
- }
-
- // Supply the menu label for affordances that fire the manage-data intent
- // for the given transport.
- @Override
- public String getDataManagementLabel(String transportName) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "getDataManagementLabel");
-
- final IBackupTransport transport = mTransportManager.getTransportBinder(transportName);
- if (transport != null) {
- try {
- final String text = transport.dataManagementLabel();
- if (MORE_DEBUG) Slog.d(TAG, "getDataManagementLabel() returning " + text);
- return text;
- } catch (Exception e) {
- /* fall through to return null */
- Slog.e(TAG, "Unable to get management label from transport: " + e.getMessage());
- }
- }
-
- return null;
- }
-
- // Callback: a requested backup agent has been instantiated. This should only
- // be called from the Activity Manager.
- @Override
- public void agentConnected(String packageName, IBinder agentBinder) {
- synchronized(mAgentConnectLock) {
- if (Binder.getCallingUid() == Process.SYSTEM_UID) {
- Slog.d(TAG, "agentConnected pkg=" + packageName + " agent=" + agentBinder);
- IBackupAgent agent = IBackupAgent.Stub.asInterface(agentBinder);
- mConnectedAgent = agent;
- mConnecting = false;
- } else {
- Slog.w(TAG, "Non-system process uid=" + Binder.getCallingUid()
- + " claiming agent connected");
- }
- mAgentConnectLock.notifyAll();
- }
- }
-
- // Callback: a backup agent has failed to come up, or has unexpectedly quit.
- // If the agent failed to come up in the first place, the agentBinder argument
- // will be null. This should only be called from the Activity Manager.
- @Override
- public void agentDisconnected(String packageName) {
- // TODO: handle backup being interrupted
- synchronized(mAgentConnectLock) {
- if (Binder.getCallingUid() == Process.SYSTEM_UID) {
- mConnectedAgent = null;
- mConnecting = false;
- } else {
- Slog.w(TAG, "Non-system process uid=" + Binder.getCallingUid()
- + " claiming agent disconnected");
- }
- mAgentConnectLock.notifyAll();
- }
- }
-
- // An application being installed will need a restore pass, then the Package Manager
- // will need to be told when the restore is finished.
- @Override
- public void restoreAtInstall(String packageName, int token) {
- if (Binder.getCallingUid() != Process.SYSTEM_UID) {
- Slog.w(TAG, "Non-system process uid=" + Binder.getCallingUid()
- + " attemping install-time restore");
- return;
- }
-
- boolean skip = false;
-
- long restoreSet = getAvailableRestoreToken(packageName);
- if (DEBUG) Slog.v(TAG, "restoreAtInstall pkg=" + packageName
- + " token=" + Integer.toHexString(token)
- + " restoreSet=" + Long.toHexString(restoreSet));
- if (restoreSet == 0) {
- if (MORE_DEBUG) Slog.i(TAG, "No restore set");
- skip = true;
- }
-
- // Do we have a transport to fetch data for us?
- IBackupTransport transport = mTransportManager.getCurrentTransportBinder();
- if (transport == null) {
- if (DEBUG) Slog.w(TAG, "No transport");
- skip = true;
- }
-
- if (!mAutoRestore) {
- if (DEBUG) {
- Slog.w(TAG, "Non-restorable state: auto=" + mAutoRestore);
- }
- skip = true;
- }
-
- if (!skip) {
- try {
- // okay, we're going to attempt a restore of this package from this restore set.
- // The eventual message back into the Package Manager to run the post-install
- // steps for 'token' will be issued from the restore handling code.
-
- // This can throw and so *must* happen before the wakelock is acquired
- String dirName = transport.transportDirName();
-
- mWakelock.acquire();
- if (MORE_DEBUG) {
- Slog.d(TAG, "Restore at install of " + packageName);
- }
- Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
- msg.obj = new RestoreParams(transport, dirName, null, null,
- restoreSet, packageName, token);
- mBackupHandler.sendMessage(msg);
- } catch (Exception e) {
- // Calling into the transport broke; back off and proceed with the installation.
- Slog.e(TAG, "Unable to contact transport: " + e.getMessage());
- skip = true;
- }
- }
-
- if (skip) {
- // Auto-restore disabled or no way to attempt a restore; just tell the Package
- // Manager to proceed with the post-install handling for this package.
- if (DEBUG) Slog.v(TAG, "Finishing install immediately");
- try {
- mPackageManagerBinder.finishPackageInstall(token, false);
- } catch (RemoteException e) { /* can't happen */ }
- }
- }
-
- // Hand off a restore session
- @Override
- public IRestoreSession beginRestoreSession(String packageName, String transport) {
- if (DEBUG) Slog.v(TAG, "beginRestoreSession: pkg=" + packageName
- + " transport=" + transport);
-
- boolean needPermission = true;
- if (transport == null) {
- transport = mTransportManager.getCurrentTransportName();
-
- if (packageName != null) {
- PackageInfo app = null;
- try {
- app = mPackageManager.getPackageInfo(packageName, 0);
- } catch (NameNotFoundException nnf) {
- Slog.w(TAG, "Asked to restore nonexistent pkg " + packageName);
- throw new IllegalArgumentException("Package " + packageName + " not found");
- }
-
- if (app.applicationInfo.uid == Binder.getCallingUid()) {
- // So: using the current active transport, and the caller has asked
- // that its own package will be restored. In this narrow use case
- // we do not require the caller to hold the permission.
- needPermission = false;
- }
- }
- }
-
- if (needPermission) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "beginRestoreSession");
- } else {
- if (DEBUG) Slog.d(TAG, "restoring self on current transport; no permission needed");
- }
-
- synchronized(this) {
- if (mActiveRestoreSession != null) {
- Slog.i(TAG, "Restore session requested but one already active");
- return null;
- }
- if (mBackupRunning) {
- Slog.i(TAG, "Restore session requested but currently running backups");
- return null;
- }
- mActiveRestoreSession = new ActiveRestoreSession(packageName, transport);
- mBackupHandler.sendEmptyMessageDelayed(MSG_RESTORE_SESSION_TIMEOUT,
- TIMEOUT_RESTORE_INTERVAL);
- }
- return mActiveRestoreSession;
- }
-
- void clearRestoreSession(ActiveRestoreSession currentSession) {
- synchronized(this) {
- if (currentSession != mActiveRestoreSession) {
- Slog.e(TAG, "ending non-current restore session");
- } else {
- if (DEBUG) Slog.v(TAG, "Clearing restore session and halting timeout");
- mActiveRestoreSession = null;
- mBackupHandler.removeMessages(MSG_RESTORE_SESSION_TIMEOUT);
- }
- }
- }
-
- // Note that a currently-active backup agent has notified us that it has
- // completed the given outstanding asynchronous backup/restore operation.
- @Override
- public void opComplete(int token, long result) {
- if (MORE_DEBUG) {
- Slog.v(TAG, "opComplete: " + Integer.toHexString(token) + " result=" + result);
- }
- Operation op = null;
- synchronized (mCurrentOpLock) {
- op = mCurrentOperations.get(token);
- if (op != null) {
- if (op.state == OP_TIMEOUT) {
- // The operation already timed out, and this is a late response. Tidy up
- // and ignore it; we've already dealt with the timeout.
- op = null;
- mCurrentOperations.delete(token);
- } else if (op.state == OP_ACKNOWLEDGED) {
- if (DEBUG) {
- Slog.w(TAG, "Received duplicate ack for token=" +
- Integer.toHexString(token));
- }
- op = null;
- mCurrentOperations.remove(token);
- } else if (op.state == OP_PENDING) {
- // Can't delete op from mCurrentOperations. waitUntilOperationComplete can be
- // called after we we receive this call.
- op.state = OP_ACKNOWLEDGED;
- }
- }
- mCurrentOpLock.notifyAll();
- }
-
- // The completion callback, if any, is invoked on the handler
- if (op != null && op.callback != null) {
- Pair<BackupRestoreTask, Long> callbackAndResult = Pair.create(op.callback, result);
- Message msg = mBackupHandler.obtainMessage(MSG_OP_COMPLETE, callbackAndResult);
- mBackupHandler.sendMessage(msg);
- }
- }
-
- @Override
- public boolean isAppEligibleForBackup(String packageName) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "isAppEligibleForBackup");
- try {
- PackageInfo packageInfo = mPackageManager.getPackageInfo(packageName,
- PackageManager.GET_SIGNATURES);
- if (!appIsEligibleForBackup(packageInfo.applicationInfo, mPackageManager) ||
- appIsStopped(packageInfo.applicationInfo)) {
- return false;
- }
- IBackupTransport transport = mTransportManager.getCurrentTransportBinder();
- if (transport != null) {
- try {
- return transport.isAppEligibleForBackup(packageInfo,
- appGetsFullBackup(packageInfo));
- } catch (Exception e) {
- Slog.e(TAG, "Unable to ask about eligibility: " + e.getMessage());
- }
- }
- // If transport is not present we couldn't tell that the package is not eligible.
- return true;
- } catch (NameNotFoundException e) {
- return false;
- }
- }
-
- // ----- Restore session -----
-
- class ActiveRestoreSession extends IRestoreSession.Stub {
- private static final String TAG = "RestoreSession";
-
- private String mPackageName;
- private IBackupTransport mRestoreTransport = null;
- RestoreSet[] mRestoreSets = null;
- boolean mEnded = false;
- boolean mTimedOut = false;
-
- ActiveRestoreSession(String packageName, String transport) {
- mPackageName = packageName;
- mRestoreTransport = mTransportManager.getTransportBinder(transport);
- }
-
- public void markTimedOut() {
- mTimedOut = true;
- }
-
- // --- Binder interface ---
- public synchronized int getAvailableRestoreSets(IRestoreObserver observer,
- IBackupManagerMonitor monitor) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "getAvailableRestoreSets");
- if (observer == null) {
- throw new IllegalArgumentException("Observer must not be null");
- }
-
- if (mEnded) {
- throw new IllegalStateException("Restore session already ended");
- }
-
- if (mTimedOut) {
- Slog.i(TAG, "Session already timed out");
- return -1;
- }
-
- long oldId = Binder.clearCallingIdentity();
- try {
- if (mRestoreTransport == null) {
- Slog.w(TAG, "Null transport getting restore sets");
- return -1;
- }
-
- // We know we're doing legit work now, so halt the timeout
- // until we're done. It gets started again when the result
- // comes in.
- mBackupHandler.removeMessages(MSG_RESTORE_SESSION_TIMEOUT);
-
- // spin off the transport request to our service thread
- mWakelock.acquire();
- Message msg = mBackupHandler.obtainMessage(MSG_RUN_GET_RESTORE_SETS,
- new RestoreGetSetsParams(mRestoreTransport, this, observer,
- monitor));
- mBackupHandler.sendMessage(msg);
- return 0;
- } catch (Exception e) {
- Slog.e(TAG, "Error in getAvailableRestoreSets", e);
- return -1;
- } finally {
- Binder.restoreCallingIdentity(oldId);
- }
- }
-
- public synchronized int restoreAll(long token, IRestoreObserver observer,
- IBackupManagerMonitor monitor) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "performRestore");
-
- if (DEBUG) Slog.d(TAG, "restoreAll token=" + Long.toHexString(token)
- + " observer=" + observer);
-
- if (mEnded) {
- throw new IllegalStateException("Restore session already ended");
- }
-
- if (mTimedOut) {
- Slog.i(TAG, "Session already timed out");
- return -1;
- }
-
- if (mRestoreTransport == null || mRestoreSets == null) {
- Slog.e(TAG, "Ignoring restoreAll() with no restore set");
- return -1;
- }
-
- if (mPackageName != null) {
- Slog.e(TAG, "Ignoring restoreAll() on single-package session");
- return -1;
- }
-
- String dirName;
- try {
- dirName = mRestoreTransport.transportDirName();
- } catch (Exception e) {
- // Transport went AWOL; fail.
- Slog.e(TAG, "Unable to get transport dir for restore: " + e.getMessage());
- return -1;
- }
-
- synchronized (mQueueLock) {
- for (int i = 0; i < mRestoreSets.length; i++) {
- if (token == mRestoreSets[i].token) {
- // Real work, so stop the session timeout until we finalize the restore
- mBackupHandler.removeMessages(MSG_RESTORE_SESSION_TIMEOUT);
-
- long oldId = Binder.clearCallingIdentity();
- mWakelock.acquire();
- if (MORE_DEBUG) {
- Slog.d(TAG, "restoreAll() kicking off");
- }
- Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
- msg.obj = new RestoreParams(mRestoreTransport, dirName,
- observer, monitor, token);
- mBackupHandler.sendMessage(msg);
- Binder.restoreCallingIdentity(oldId);
- return 0;
- }
- }
- }
-
- Slog.w(TAG, "Restore token " + Long.toHexString(token) + " not found");
- return -1;
- }
-
- // Restores of more than a single package are treated as 'system' restores
- public synchronized int restoreSome(long token, IRestoreObserver observer,
- IBackupManagerMonitor monitor, String[] packages) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "performRestore");
-
- if (DEBUG) {
- StringBuilder b = new StringBuilder(128);
- b.append("restoreSome token=");
- b.append(Long.toHexString(token));
- b.append(" observer=");
- b.append(observer.toString());
- b.append(" monitor=");
- if (monitor == null) {
- b.append("null");
- } else {
- b.append(monitor.toString());
- }
- b.append(" packages=");
- if (packages == null) {
- b.append("null");
- } else {
- b.append('{');
- boolean first = true;
- for (String s : packages) {
- if (!first) {
- b.append(", ");
- } else first = false;
- b.append(s);
- }
- b.append('}');
- }
- Slog.d(TAG, b.toString());
- }
-
- if (mEnded) {
- throw new IllegalStateException("Restore session already ended");
- }
-
- if (mTimedOut) {
- Slog.i(TAG, "Session already timed out");
- return -1;
- }
-
- if (mRestoreTransport == null || mRestoreSets == null) {
- Slog.e(TAG, "Ignoring restoreAll() with no restore set");
- return -1;
- }
-
- if (mPackageName != null) {
- Slog.e(TAG, "Ignoring restoreAll() on single-package session");
- return -1;
- }
-
- String dirName;
- try {
- dirName = mRestoreTransport.transportDirName();
- } catch (Exception e) {
- // Transport went AWOL; fail.
- Slog.e(TAG, "Unable to get transport name for restoreSome: " + e.getMessage());
- return -1;
- }
-
- synchronized (mQueueLock) {
- for (int i = 0; i < mRestoreSets.length; i++) {
- if (token == mRestoreSets[i].token) {
- // Stop the session timeout until we finalize the restore
- mBackupHandler.removeMessages(MSG_RESTORE_SESSION_TIMEOUT);
-
- long oldId = Binder.clearCallingIdentity();
- mWakelock.acquire();
- if (MORE_DEBUG) {
- Slog.d(TAG, "restoreSome() of " + packages.length + " packages");
- }
- Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
- msg.obj = new RestoreParams(mRestoreTransport, dirName, observer, monitor,
- token, packages, packages.length > 1);
- mBackupHandler.sendMessage(msg);
- Binder.restoreCallingIdentity(oldId);
- return 0;
- }
- }
- }
-
- Slog.w(TAG, "Restore token " + Long.toHexString(token) + " not found");
- return -1;
- }
-
- public synchronized int restorePackage(String packageName, IRestoreObserver observer,
- IBackupManagerMonitor monitor) {
- if (DEBUG) Slog.v(TAG, "restorePackage pkg=" + packageName + " obs=" + observer
- + "monitor=" + monitor);
-
- if (mEnded) {
- throw new IllegalStateException("Restore session already ended");
- }
-
- if (mTimedOut) {
- Slog.i(TAG, "Session already timed out");
- return -1;
- }
-
- if (mPackageName != null) {
- if (! mPackageName.equals(packageName)) {
- Slog.e(TAG, "Ignoring attempt to restore pkg=" + packageName
- + " on session for package " + mPackageName);
- return -1;
- }
- }
-
- PackageInfo app = null;
- try {
- app = mPackageManager.getPackageInfo(packageName, 0);
- } catch (NameNotFoundException nnf) {
- Slog.w(TAG, "Asked to restore nonexistent pkg " + packageName);
- return -1;
- }
-
- // If the caller is not privileged and is not coming from the target
- // app's uid, throw a permission exception back to the caller.
- int perm = mContext.checkPermission(android.Manifest.permission.BACKUP,
- Binder.getCallingPid(), Binder.getCallingUid());
- if ((perm == PackageManager.PERMISSION_DENIED) &&
- (app.applicationInfo.uid != Binder.getCallingUid())) {
- Slog.w(TAG, "restorePackage: bad packageName=" + packageName
- + " or calling uid=" + Binder.getCallingUid());
- throw new SecurityException("No permission to restore other packages");
- }
-
- // So far so good; we're allowed to try to restore this package.
- long oldId = Binder.clearCallingIdentity();
- try {
- // Check whether there is data for it in the current dataset, falling back
- // to the ancestral dataset if not.
- long token = getAvailableRestoreToken(packageName);
- if (DEBUG) Slog.v(TAG, "restorePackage pkg=" + packageName
- + " token=" + Long.toHexString(token));
-
- // If we didn't come up with a place to look -- no ancestral dataset and
- // the app has never been backed up from this device -- there's nothing
- // to do but return failure.
- if (token == 0) {
- if (DEBUG) Slog.w(TAG, "No data available for this package; not restoring");
- return -1;
- }
-
- String dirName;
- try {
- dirName = mRestoreTransport.transportDirName();
- } catch (Exception e) {
- // Transport went AWOL; fail.
- Slog.e(TAG, "Unable to get transport dir for restorePackage: " + e.getMessage());
- return -1;
- }
-
- // Stop the session timeout until we finalize the restore
- mBackupHandler.removeMessages(MSG_RESTORE_SESSION_TIMEOUT);
-
- // Ready to go: enqueue the restore request and claim success
- mWakelock.acquire();
- if (MORE_DEBUG) {
- Slog.d(TAG, "restorePackage() : " + packageName);
- }
- Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
- msg.obj = new RestoreParams(mRestoreTransport, dirName, observer, monitor,
- token, app);
- mBackupHandler.sendMessage(msg);
- } finally {
- Binder.restoreCallingIdentity(oldId);
- }
- return 0;
- }
-
- // Posted to the handler to tear down a restore session in a cleanly synchronized way
- class EndRestoreRunnable implements Runnable {
- BackupManagerService mBackupManager;
- ActiveRestoreSession mSession;
-
- EndRestoreRunnable(BackupManagerService manager, ActiveRestoreSession session) {
- mBackupManager = manager;
- mSession = session;
- }
-
- public void run() {
- // clean up the session's bookkeeping
- synchronized (mSession) {
- mSession.mRestoreTransport = null;
- mSession.mEnded = true;
- }
-
- // clean up the BackupManagerImpl side of the bookkeeping
- // and cancel any pending timeout message
- mBackupManager.clearRestoreSession(mSession);
- }
- }
-
- public synchronized void endRestoreSession() {
- if (DEBUG) Slog.d(TAG, "endRestoreSession");
-
- if (mTimedOut) {
- Slog.i(TAG, "Session already timed out");
- return;
- }
-
- if (mEnded) {
- throw new IllegalStateException("Restore session already ended");
- }
-
- mBackupHandler.post(new EndRestoreRunnable(BackupManagerService.this, this));
- }
- }
-
- @Override
- public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
- if (!DumpUtils.checkDumpAndUsageStatsPermission(mContext, TAG, pw)) return;
-
- long identityToken = Binder.clearCallingIdentity();
- try {
- if (args != null) {
- for (String arg : args) {
- if ("-h".equals(arg)) {
- pw.println("'dumpsys backup' optional arguments:");
- pw.println(" -h : this help text");
- pw.println(" a[gents] : dump information about defined backup agents");
- return;
- } else if ("agents".startsWith(arg)) {
- dumpAgents(pw);
- return;
- }
- }
- }
- dumpInternal(pw);
- } finally {
- Binder.restoreCallingIdentity(identityToken);
- }
- }
-
- private void dumpAgents(PrintWriter pw) {
- List<PackageInfo> agentPackages = allAgentPackages();
- pw.println("Defined backup agents:");
- for (PackageInfo pkg : agentPackages) {
- pw.print(" ");
- pw.print(pkg.packageName); pw.println(':');
- pw.print(" "); pw.println(pkg.applicationInfo.backupAgentName);
- }
- }
-
- private void dumpInternal(PrintWriter pw) {
- synchronized (mQueueLock) {
- pw.println("Backup Manager is " + (mEnabled ? "enabled" : "disabled")
- + " / " + (!mProvisioned ? "not " : "") + "provisioned / "
- + (this.mPendingInits.size() == 0 ? "not " : "") + "pending init");
- pw.println("Auto-restore is " + (mAutoRestore ? "enabled" : "disabled"));
- if (mBackupRunning) pw.println("Backup currently running");
- pw.println("Last backup pass started: " + mLastBackupPass
- + " (now = " + System.currentTimeMillis() + ')');
- pw.println(" next scheduled: " + KeyValueBackupJob.nextScheduled());
-
- pw.println("Transport whitelist:");
- for (ComponentName transport : mTransportManager.getTransportWhitelist()) {
- pw.print(" ");
- pw.println(transport.flattenToShortString());
- }
-
- pw.println("Available transports:");
- final String[] transports = listAllTransports();
- if (transports != null) {
- for (String t : listAllTransports()) {
- pw.println((t.equals(mTransportManager.getCurrentTransportName()) ? " * " : " ") + t);
- try {
- IBackupTransport transport = mTransportManager.getTransportBinder(t);
- File dir = new File(mBaseStateDir, transport.transportDirName());
- pw.println(" destination: " + transport.currentDestinationString());
- pw.println(" intent: " + transport.configurationIntent());
- for (File f : dir.listFiles()) {
- pw.println(" " + f.getName() + " - " + f.length() + " state bytes");
- }
- } catch (Exception e) {
- Slog.e(TAG, "Error in transport", e);
- pw.println(" Error: " + e);
- }
- }
- }
-
- pw.println("Pending init: " + mPendingInits.size());
- for (String s : mPendingInits) {
- pw.println(" " + s);
- }
-
- if (DEBUG_BACKUP_TRACE) {
- synchronized (mBackupTrace) {
- if (!mBackupTrace.isEmpty()) {
- pw.println("Most recent backup trace:");
- for (String s : mBackupTrace) {
- pw.println(" " + s);
- }
- }
- }
- }
-
- pw.print("Ancestral: "); pw.println(Long.toHexString(mAncestralToken));
- pw.print("Current: "); pw.println(Long.toHexString(mCurrentToken));
-
- int N = mBackupParticipants.size();
- pw.println("Participants:");
- for (int i=0; i<N; i++) {
- int uid = mBackupParticipants.keyAt(i);
- pw.print(" uid: ");
- pw.println(uid);
- HashSet<String> participants = mBackupParticipants.valueAt(i);
- for (String app: participants) {
- pw.println(" " + app);
- }
- }
-
- pw.println("Ancestral packages: "
- + (mAncestralPackages == null ? "none" : mAncestralPackages.size()));
- if (mAncestralPackages != null) {
- for (String pkg : mAncestralPackages) {
- pw.println(" " + pkg);
- }
- }
-
- pw.println("Ever backed up: " + mEverStoredApps.size());
- for (String pkg : mEverStoredApps) {
- pw.println(" " + pkg);
- }
-
- pw.println("Pending key/value backup: " + mPendingBackups.size());
- for (BackupRequest req : mPendingBackups.values()) {
- pw.println(" " + req);
- }
-
- pw.println("Full backup queue:" + mFullBackupQueue.size());
- for (FullBackupEntry entry : mFullBackupQueue) {
- pw.print(" "); pw.print(entry.lastBackup);
- pw.print(" : "); pw.println(entry.packageName);
- }
- }
- }
-
- private static void sendBackupOnUpdate(IBackupObserver observer, String packageName,
- BackupProgress progress) {
- if (observer != null) {
- try {
- observer.onUpdate(packageName, progress);
- } catch (RemoteException e) {
- if (DEBUG) {
- Slog.w(TAG, "Backup observer went away: onUpdate");
- }
- }
- }
- }
-
- private static void sendBackupOnPackageResult(IBackupObserver observer, String packageName,
- int status) {
- if (observer != null) {
- try {
- observer.onResult(packageName, status);
- } catch (RemoteException e) {
- if (DEBUG) {
- Slog.w(TAG, "Backup observer went away: onResult");
- }
- }
- }
- }
-
- private static void sendBackupFinished(IBackupObserver observer, int status) {
- if (observer != null) {
- try {
- observer.backupFinished(status);
- } catch (RemoteException e) {
- if (DEBUG) {
- Slog.w(TAG, "Backup observer went away: backupFinished");
- }
- }
- }
- }
-
- private Bundle putMonitoringExtra(Bundle extras, String key, String value) {
- if (extras == null) {
- extras = new Bundle();
- }
- extras.putString(key, value);
- return extras;
- }
-
- private Bundle putMonitoringExtra(Bundle extras, String key, int value) {
- if (extras == null) {
- extras = new Bundle();
- }
- extras.putInt(key, value);
- return extras;
- }
-
- private Bundle putMonitoringExtra(Bundle extras, String key, long value) {
- if (extras == null) {
- extras = new Bundle();
- }
- extras.putLong(key, value);
- return extras;
- }
-
-
- private Bundle putMonitoringExtra(Bundle extras, String key, boolean value) {
- if (extras == null) {
- extras = new Bundle();
- }
- extras.putBoolean(key, value);
- return extras;
- }
-
- private static IBackupManagerMonitor monitorEvent(IBackupManagerMonitor monitor, int id,
- PackageInfo pkg, int category, Bundle extras) {
- if (monitor != null) {
- try {
- Bundle bundle = new Bundle();
- bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_ID, id);
- bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_CATEGORY, category);
- if (pkg != null) {
- bundle.putString(EXTRA_LOG_EVENT_PACKAGE_NAME,
- pkg.packageName);
- bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_VERSION,
- pkg.versionCode);
- }
- if (extras != null) {
- bundle.putAll(extras);
- }
- monitor.onEvent(bundle);
- return monitor;
- } catch(RemoteException e) {
- if (DEBUG) {
- Slog.w(TAG, "backup manager monitor went away");
- }
- }
- }
- return null;
- }
-
- @Override
- public IBackupManager getBackupManagerBinder() {
- return mBackupManagerBinder;
- }
-
-}
diff --git a/services/backup/java/com/android/server/backup/Trampoline.java b/services/backup/java/com/android/server/backup/Trampoline.java
index 8c0329c..94a26275 100644
--- a/services/backup/java/com/android/server/backup/Trampoline.java
+++ b/services/backup/java/com/android/server/backup/Trampoline.java
@@ -38,7 +38,6 @@
import android.os.SystemProperties;
import android.os.Trace;
import android.os.UserHandle;
-import android.provider.Settings;
import android.util.Slog;
import com.android.internal.util.DumpUtils;
@@ -88,25 +87,10 @@
mSuppressFile.getParentFile().mkdirs();
}
- protected BackupManagerServiceInterface createService() {
- if (isRefactoredServiceEnabled()) {
- Slog.i(TAG, "Instantiating RefactoredBackupManagerService");
- return createRefactoredBackupManagerService();
- }
-
- Slog.i(TAG, "Instantiating BackupManagerService");
- return createBackupManagerService();
- }
-
protected boolean isBackupDisabled() {
return SystemProperties.getBoolean(BACKUP_DISABLE_PROPERTY, false);
}
- protected boolean isRefactoredServiceEnabled() {
- return Settings.Global.getInt(mContext.getContentResolver(),
- Settings.Global.BACKUP_REFACTORED_SERVICE_DISABLED, 0) == 0;
- }
-
protected int binderGetCallingUid() {
return Binder.getCallingUid();
}
@@ -120,10 +104,6 @@
return RefactoredBackupManagerService.create(mContext, this, mHandlerThread);
}
- protected BackupManagerServiceInterface createBackupManagerService() {
- return new BackupManagerService(mContext, this, mHandlerThread);
- }
-
// internal control API
public void initialize(final int whichUser) {
// Note that only the owner user is currently involved in backup/restore
@@ -137,7 +117,7 @@
synchronized (this) {
if (!mSuppressFile.exists()) {
- mService = createService();
+ mService = createRefactoredBackupManagerService();
} else {
Slog.i(TAG, "Backup inactive in user " + whichUser);
}
@@ -182,7 +162,7 @@
Slog.i(TAG, "Making backup "
+ (makeActive ? "" : "in") + "active in user " + userHandle);
if (makeActive) {
- mService = createService();
+ mService = createRefactoredBackupManagerService();
mSuppressFile.delete();
} else {
mService = null;
diff --git a/services/core/java/com/android/server/ServiceWatcher.java b/services/core/java/com/android/server/ServiceWatcher.java
index f20ca43..f4238f2 100644
--- a/services/core/java/com/android/server/ServiceWatcher.java
+++ b/services/core/java/com/android/server/ServiceWatcher.java
@@ -282,6 +282,7 @@
mBoundUserId = UserHandle.USER_NULL;
if (component != null) {
if (D) Log.d(mTag, "unbinding " + component);
+ mBoundService = null;
mContext.unbindService(this);
}
}
diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java
index d0ad4ac..0c6be32 100644
--- a/services/core/java/com/android/server/pm/PackageManagerService.java
+++ b/services/core/java/com/android/server/pm/PackageManagerService.java
@@ -15493,6 +15493,15 @@
return;
}
+ // check if the new package supports all of the abis which the old package supports
+ boolean oldPkgSupportMultiArch = oldPackage.applicationInfo.secondaryCpuAbi != null;
+ boolean newPkgSupportMultiArch = pkg.applicationInfo.secondaryCpuAbi != null;
+ if (isSystemApp(oldPackage) && oldPkgSupportMultiArch && !newPkgSupportMultiArch) {
+ res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
+ "Update to package " + pkgName + " doesn't support multi arch");
+ return;
+ }
+
// In case of rollback, remember per-user/profile install state
allUsers = sUserManager.getUserIds();
installedUsers = ps.queryInstalledUsers(allUsers, true);
diff --git a/services/core/java/com/android/server/power/batterysaver/BatterySaverController.java b/services/core/java/com/android/server/power/batterysaver/BatterySaverController.java
index 80bc935..1b19c33 100644
--- a/services/core/java/com/android/server/power/batterysaver/BatterySaverController.java
+++ b/services/core/java/com/android/server/power/batterysaver/BatterySaverController.java
@@ -16,12 +16,18 @@
package com.android.server.power.batterysaver;
import android.Manifest;
+import android.app.ActivityManager;
import android.app.ActivityManagerInternal;
+import android.app.Notification;
+import android.app.Notification.BigTextStyle;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.power.V1_0.PowerHint;
+import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
@@ -32,9 +38,11 @@
import android.os.UserHandle;
import android.util.ArrayMap;
import android.util.Slog;
-import android.widget.Toast;
+import com.android.internal.R;
import com.android.internal.annotations.GuardedBy;
+import com.android.internal.messages.nano.SystemMessageProto.SystemMessage;
+import com.android.internal.notification.SystemNotificationChannels;
import com.android.internal.util.ArrayUtils;
import com.android.internal.util.Preconditions;
import com.android.server.LocalServices;
@@ -61,6 +69,8 @@
private final BatterySaverPolicy mBatterySaverPolicy;
+ private static final String WARNING_LINK_URL = "http://goto.google.com/extreme-battery-saver";
+
@GuardedBy("mLock")
private final ArrayList<LowPowerModeListener> mListeners = new ArrayList<>();
@@ -230,9 +240,9 @@
if (sendBroadcast) {
if (enabled) {
// STOPSHIP Remove the toast.
- Toast.makeText(mContext,
- com.android.internal.R.string.battery_saver_warning,
- Toast.LENGTH_LONG).show();
+ postWarningNotification();
+ } else {
+ cancelWarningNotification();
}
if (DEBUG) {
@@ -265,4 +275,51 @@
}
}
}
+
+ private void postWarningNotification() {
+ final UserHandle foregroundUser = UserHandle.of(ActivityManager.getCurrentUser());
+
+ final PendingIntent pendingIntent = PendingIntent
+ .getActivityAsUser(mContext, 0,
+ new Intent(Intent.ACTION_VIEW, Uri.parse(WARNING_LINK_URL)),
+ PendingIntent.FLAG_CANCEL_CURRENT, null,
+ foregroundUser);
+
+ final CharSequence title = mContext.getString
+ (com.android.internal.R.string.battery_saver_warning_title);
+ final CharSequence text = mContext.getString
+ (com.android.internal.R.string.battery_saver_warning);
+
+ final Notification notification =
+ new Notification.Builder(mContext, SystemNotificationChannels.ALERTS)
+ .setSmallIcon(R.drawable.stat_notify_error)
+ .setTicker(title)
+ .setWhen(System.currentTimeMillis())
+ .setContentTitle(title)
+ .setContentText(text)
+ .setContentIntent(pendingIntent)
+ .setStyle(new BigTextStyle().bigText(text))
+ .build();
+
+ final NotificationManager nm = mContext.getSystemService(NotificationManager.class);
+
+ if (nm != null) {
+ nm.notifyAsUser(title.toString(),
+ SystemMessage.NOTE_BATTERY_SAVER_WARNING,
+ notification,
+ foregroundUser);
+ }
+ }
+
+ private void cancelWarningNotification() {
+ final UserHandle foregroundUser = UserHandle.of(ActivityManager.getCurrentUser());
+ final CharSequence title = mContext.getString
+ (com.android.internal.R.string.battery_saver_warning_title);
+
+ final NotificationManager nm = mContext.getSystemService(NotificationManager.class);
+ if (nm != null) {
+ nm.cancelAsUser(title.toString(), SystemMessage.NOTE_BATTERY_SAVER_WARNING,
+ foregroundUser);
+ }
+ }
}
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index c2ac905..9eab61c 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -50,6 +50,7 @@
import static android.view.WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY;
+import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING;
import static android.view.WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
import static android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER;
@@ -4331,15 +4332,6 @@
}
}
- boolean usesRelativeZOrdering() {
- if (!isChildWindow()) {
- return false;
- } else if (mAttrs.type == TYPE_APPLICATION_MEDIA_OVERLAY) {
- return true;
- } else {
- return false;
- }
- }
@Override
boolean shouldMagnify() {
@@ -4414,4 +4406,28 @@
public boolean isDimming() {
return mIsDimming;
}
+
+ // TODO(b/70040778): We should aim to eliminate the last user of TYPE_APPLICATION_MEDIA
+ // then we can drop all negative layering on the windowing side and simply inherit
+ // the default implementation here.
+ public void assignChildLayers(Transaction t) {
+ int layer = 1;
+ for (int i = 0; i < mChildren.size(); i++) {
+ final WindowState w = mChildren.get(i);
+
+ // APPLICATION_MEDIA_OVERLAY needs to go above APPLICATION_MEDIA
+ // while they both need to go below the main window. However the
+ // relative layering of multiple APPLICATION_MEDIA/OVERLAY has never
+ // been defined and so we can use static layers and leave it that way.
+ if (w.mAttrs.type == TYPE_APPLICATION_MEDIA) {
+ w.assignLayer(t, -2);
+ } else if (w.mAttrs.type == TYPE_APPLICATION_MEDIA_OVERLAY) {
+ w.assignLayer(t, -1);
+ } else {
+ w.assignLayer(t, layer);
+ }
+ w.assignChildLayers(t);
+ layer++;
+ }
+ }
}
diff --git a/services/core/java/com/android/server/wm/WindowStateAnimator.java b/services/core/java/com/android/server/wm/WindowStateAnimator.java
index 4b5661f..54c84ea 100644
--- a/services/core/java/com/android/server/wm/WindowStateAnimator.java
+++ b/services/core/java/com/android/server/wm/WindowStateAnimator.java
@@ -602,13 +602,6 @@
return mWin.getDisplayContent().getDisplay().getLayerStack();
}
- void updateLayerStackInTransaction() {
- if (mSurfaceController != null) {
- mSurfaceController.setLayerStackInTransaction(
- getLayerStack());
- }
- }
-
void resetDrawState() {
mDrawState = DRAW_PENDING;
@@ -727,16 +720,6 @@
+ width + "x" + height + "), layer=" + mAnimLayer + " HIDE", false);
}
- // Start a new transaction and apply position & offset.
-
- mService.openSurfaceTransaction();
- try {
- mSurfaceController.setPositionInTransaction(mTmpSize.left, mTmpSize.top, false);
- mSurfaceController.setLayerStackInTransaction(getLayerStack());
- } finally {
- mService.closeSurfaceTransaction("createSurfaceLocked");
- }
-
mLastHidden = true;
if (WindowManagerService.localLOGV) Slog.v(TAG, "Created surface " + this);
diff --git a/services/core/java/com/android/server/wm/WindowToken.java b/services/core/java/com/android/server/wm/WindowToken.java
index 62a2abb..c9d7b70 100644
--- a/services/core/java/com/android/server/wm/WindowToken.java
+++ b/services/core/java/com/android/server/wm/WindowToken.java
@@ -255,12 +255,6 @@
// up with goodToGo, so we don't move a window
// to another display before the window behind
// it is ready.
- SurfaceControl.openTransaction();
- for (int i = mChildren.size() - 1; i >= 0; --i) {
- final WindowState win = mChildren.get(i);
- win.mWinAnimator.updateLayerStackInTransaction();
- }
- SurfaceControl.closeTransaction();
super.onDisplayChanged(dc);
}
diff --git a/services/core/jni/com_android_server_am_BatteryStatsService.cpp b/services/core/jni/com_android_server_am_BatteryStatsService.cpp
index ae7d6da..39cc953 100644
--- a/services/core/jni/com_android_server_am_BatteryStatsService.cpp
+++ b/services/core/jni/com_android_server_am_BatteryStatsService.cpp
@@ -43,13 +43,14 @@
using android::hardware::Return;
using android::hardware::Void;
-using android::hardware::power::V1_0::IPower;
using android::hardware::power::V1_0::PowerStatePlatformSleepState;
using android::hardware::power::V1_0::PowerStateVoter;
using android::hardware::power::V1_0::Status;
using android::hardware::power::V1_1::PowerStateSubsystem;
using android::hardware::power::V1_1::PowerStateSubsystemSleepState;
using android::hardware::hidl_vec;
+using IPowerV1_1 = android::hardware::power::V1_1::IPower;
+using IPowerV1_0 = android::hardware::power::V1_0::IPower;
namespace android
{
@@ -59,9 +60,9 @@
static bool wakeup_init = false;
static sem_t wakeup_sem;
-extern sp<android::hardware::power::V1_0::IPower> gPowerHalV1_0;
-extern std::mutex gPowerHalMutex;
-extern bool getPowerHal();
+extern sp<IPowerV1_0> getPowerHalV1_0();
+extern sp<IPowerV1_1> getPowerHalV1_1();
+extern bool processPowerHalReturn(const Return<void> &ret, const char* functionName);
// Java methods used in getLowPowerStats
static jmethodID jgetAndUpdatePlatformState = NULL;
@@ -203,13 +204,13 @@
return;
}
- std::lock_guard<std::mutex> lock(gPowerHalMutex);
- if (!getPowerHal()) {
+ sp<IPowerV1_0> powerHalV1_0 = getPowerHalV1_0();
+ if (powerHalV1_0 == nullptr) {
ALOGE("Power Hal not loaded");
return;
}
- Return<void> ret = gPowerHalV1_0->getPlatformLowPowerStats(
+ Return<void> ret = powerHalV1_0->getPlatformLowPowerStats(
[&env, &jrpmStats](hidl_vec<PowerStatePlatformSleepState> states, Status status) {
if (status != Status::SUCCESS) return;
@@ -236,20 +237,17 @@
}
}
});
- if (!ret.isOk()) {
- ALOGE("getLowPowerStats() failed: power HAL service not available");
- gPowerHalV1_0 = nullptr;
+ if (!processPowerHalReturn(ret, "getPlatformLowPowerStats")) {
return;
}
- //Trying to cast to IPower 1.1, this will succeed only for devices supporting 1.1
- sp<android::hardware::power::V1_1::IPower> gPowerHal_1_1
- = android::hardware::power::V1_1::IPower::castFrom(gPowerHalV1_0);
- if (gPowerHal_1_1 == nullptr) {
- //This device does not support IPower@1.1, exiting gracefully
+ // Trying to get IPower 1.1, this will succeed only for devices supporting 1.1
+ sp<IPowerV1_1> powerHal_1_1 = getPowerHalV1_1();
+ if (powerHal_1_1 == nullptr) {
+ // This device does not support IPower@1.1, exiting gracefully
return;
}
- ret = gPowerHal_1_1->getSubsystemLowPowerStats(
+ ret = powerHal_1_1->getSubsystemLowPowerStats(
[&env, &jrpmStats](hidl_vec<PowerStateSubsystem> subsystems, Status status) {
if (status != Status::SUCCESS) return;
@@ -275,11 +273,7 @@
}
}
});
- if (!ret.isOk()) {
- ALOGE("getSubsystemLowPowerStats() failed: power HAL service not available");
- gPowerHalV1_0 = nullptr;
- }
- // gPowerHalMutex released here
+ processPowerHalReturn(ret, "getSubsystemLowPowerStats");
}
static jint getPlatformLowPowerStats(JNIEnv* env, jobject /* clazz */, jobject outBuf) {
@@ -294,13 +288,13 @@
}
{
- std::lock_guard<std::mutex> lock(gPowerHalMutex);
- if (!getPowerHal()) {
+ sp<IPowerV1_0> powerHalV1_0 = getPowerHalV1_0();
+ if (powerHalV1_0 == nullptr) {
ALOGE("Power Hal not loaded");
return -1;
}
- Return<void> ret = gPowerHalV1_0->getPlatformLowPowerStats(
+ Return<void> ret = powerHalV1_0->getPlatformLowPowerStats(
[&offset, &remaining, &total_added](hidl_vec<PowerStatePlatformSleepState> states,
Status status) {
if (status != Status::SUCCESS)
@@ -352,9 +346,7 @@
}
);
- if (!ret.isOk()) {
- ALOGE("getPlatformLowPowerStats() failed: power HAL service not available");
- gPowerHalV1_0 = nullptr;
+ if (!processPowerHalReturn(ret, "getPlatformLowPowerStats")) {
return -1;
}
}
@@ -369,8 +361,8 @@
int remaining = (int)env->GetDirectBufferCapacity(outBuf);
int total_added = -1;
- //This is a IPower 1.1 API
- sp<android::hardware::power::V1_1::IPower> gPowerHal_1_1 = nullptr;
+ // This is a IPower 1.1 API
+ sp<IPowerV1_1> powerHal_1_1 = nullptr;
if (outBuf == NULL) {
jniThrowException(env, "java/lang/NullPointerException", "null argument");
@@ -378,20 +370,14 @@
}
{
- std::lock_guard<std::mutex> lock(gPowerHalMutex);
- if (!getPowerHal()) {
- ALOGE("Power Hal not loaded");
- return -1;
- }
-
- //Trying to cast to 1.1, this will succeed only for devices supporting 1.1
- gPowerHal_1_1 = android::hardware::power::V1_1::IPower::castFrom(gPowerHalV1_0);
- if (gPowerHal_1_1 == nullptr) {
+ // Trying to get 1.1, this will succeed only for devices supporting 1.1
+ powerHal_1_1 = getPowerHalV1_1();
+ if (powerHal_1_1 == nullptr) {
//This device does not support IPower@1.1, exiting gracefully
return 0;
- }
+ }
- Return<void> ret = gPowerHal_1_1->getSubsystemLowPowerStats(
+ Return<void> ret = powerHal_1_1->getSubsystemLowPowerStats(
[&offset, &remaining, &total_added](hidl_vec<PowerStateSubsystem> subsystems,
Status status) {
@@ -452,9 +438,7 @@
}
);
- if (!ret.isOk()) {
- ALOGE("getSubsystemLowPowerStats() failed: power HAL service not available");
- gPowerHalV1_0 = nullptr;
+ if (!processPowerHalReturn(ret, "getSubsystemLowPowerStats")) {
return -1;
}
}
diff --git a/services/core/jni/com_android_server_power_PowerManagerService.cpp b/services/core/jni/com_android_server_power_PowerManagerService.cpp
index b6c3df7..b2d35d4 100644
--- a/services/core/jni/com_android_server_power_PowerManagerService.cpp
+++ b/services/core/jni/com_android_server_power_PowerManagerService.cpp
@@ -41,10 +41,11 @@
using android::hardware::Return;
using android::hardware::Void;
-using android::hardware::power::V1_1::IPower;
using android::hardware::power::V1_0::PowerHint;
using android::hardware::power::V1_0::Feature;
using android::String8;
+using IPowerV1_1 = android::hardware::power::V1_1::IPower;
+using IPowerV1_0 = android::hardware::power::V1_0::IPower;
namespace android {
@@ -57,10 +58,11 @@
// ----------------------------------------------------------------------------
static jobject gPowerManagerServiceObj;
-sp<android::hardware::power::V1_0::IPower> gPowerHalV1_0 = nullptr;
-sp<android::hardware::power::V1_1::IPower> gPowerHalV1_1 = nullptr;
-bool gPowerHalExists = true;
-std::mutex gPowerHalMutex;
+// Use getPowerHal* to retrieve a copy
+static sp<IPowerV1_0> gPowerHalV1_0_ = nullptr;
+static sp<IPowerV1_1> gPowerHalV1_1_ = nullptr;
+static bool gPowerHalExists = true;
+static std::mutex gPowerHalMutex;
static nsecs_t gLastEventTime[USER_ACTIVITY_EVENT_LAST + 1];
// Throttling interval for user activity calls.
@@ -80,26 +82,63 @@
// Check validity of current handle to the power HAL service, and call getService() if necessary.
// The caller must be holding gPowerHalMutex.
-bool getPowerHal() {
- if (gPowerHalExists && gPowerHalV1_0 == nullptr) {
- gPowerHalV1_0 = android::hardware::power::V1_0::IPower::getService();
- if (gPowerHalV1_0 != nullptr) {
- gPowerHalV1_1 = android::hardware::power::V1_1::IPower::castFrom(gPowerHalV1_0);
- ALOGI("Loaded power HAL service");
+static void connectPowerHalLocked() {
+ if (gPowerHalExists && gPowerHalV1_0_ == nullptr) {
+ gPowerHalV1_0_ = IPowerV1_0::getService();
+ if (gPowerHalV1_0_ != nullptr) {
+ ALOGI("Loaded power HAL 1.0 service");
+ // Try cast to powerHAL V1_1
+ gPowerHalV1_1_ = IPowerV1_1::castFrom(gPowerHalV1_0_);
+ if (gPowerHalV1_1_ == nullptr) {
+ } else {
+ ALOGI("Loaded power HAL 1.1 service");
+ }
} else {
ALOGI("Couldn't load power HAL service");
gPowerHalExists = false;
}
}
- return gPowerHalV1_0 != nullptr;
+}
+
+// Retrieve a copy of PowerHAL V1_0
+sp<IPowerV1_0> getPowerHalV1_0() {
+ std::lock_guard<std::mutex> lock(gPowerHalMutex);
+ connectPowerHalLocked();
+ return gPowerHalV1_0_;
+}
+
+// Retrieve a copy of PowerHAL V1_1
+sp<IPowerV1_1> getPowerHalV1_1() {
+ std::lock_guard<std::mutex> lock(gPowerHalMutex);
+ connectPowerHalLocked();
+ return gPowerHalV1_1_;
}
// Check if a call to a power HAL function failed; if so, log the failure and invalidate the
-// current handle to the power HAL service. The caller must be holding gPowerHalMutex.
-static void processReturn(const Return<void> &ret, const char* functionName) {
+// current handle to the power HAL service.
+bool processPowerHalReturn(const Return<void> &ret, const char* functionName) {
if (!ret.isOk()) {
ALOGE("%s() failed: power HAL service not available.", functionName);
- gPowerHalV1_0 = nullptr;
+ gPowerHalMutex.lock();
+ gPowerHalV1_0_ = nullptr;
+ gPowerHalV1_1_ = nullptr;
+ gPowerHalMutex.unlock();
+ }
+ return ret.isOk();
+}
+
+static void sendPowerHint(PowerHint hintId, uint32_t data) {
+ sp<IPowerV1_1> powerHalV1_1 = getPowerHalV1_1();
+ Return<void> ret;
+ if (powerHalV1_1 != nullptr) {
+ ret = powerHalV1_1->powerHintAsync(hintId, data);
+ processPowerHalReturn(ret, "powerHintAsync");
+ } else {
+ sp<IPowerV1_0> powerHalV1_0 = getPowerHalV1_0();
+ if (powerHalV1_0 != nullptr) {
+ ret = powerHalV1_0->powerHint(hintId, data);
+ processPowerHalReturn(ret, "powerHint");
+ }
}
}
@@ -119,20 +158,8 @@
}
gLastEventTime[eventType] = eventTime;
-
// Tell the power HAL when user activity occurs.
- gPowerHalMutex.lock();
- if (getPowerHal()) {
- Return<void> ret;
- if (gPowerHalV1_1 != nullptr) {
- ret = gPowerHalV1_1->powerHintAsync(PowerHint::INTERACTION, 0);
- } else {
- ret = gPowerHalV1_0->powerHint(PowerHint::INTERACTION, 0);
- }
- processReturn(ret, "powerHint");
- }
- gPowerHalMutex.unlock();
-
+ sendPowerHint(PowerHint::INTERACTION, 0);
}
JNIEnv* env = AndroidRuntime::getJNIEnv();
@@ -150,7 +177,7 @@
gPowerManagerServiceObj = env->NewGlobalRef(obj);
gPowerHalMutex.lock();
- getPowerHal();
+ connectPowerHalLocked();
gPowerHalMutex.unlock();
}
@@ -165,11 +192,11 @@
}
static void nativeSetInteractive(JNIEnv* /* env */, jclass /* clazz */, jboolean enable) {
- std::lock_guard<std::mutex> lock(gPowerHalMutex);
- if (getPowerHal()) {
+ sp<IPowerV1_0> powerHalV1_0 = getPowerHalV1_0();
+ if (powerHalV1_0 != nullptr) {
android::base::Timer t;
- Return<void> ret = gPowerHalV1_0->setInteractive(enable);
- processReturn(ret, "setInteractive");
+ Return<void> ret = powerHalV1_0->setInteractive(enable);
+ processPowerHalReturn(ret, "setInteractive");
if (t.duration() > 20ms) {
ALOGD("Excessive delay in setInteractive(%s) while turning screen %s",
enable ? "true" : "false", enable ? "on" : "off");
@@ -193,24 +220,15 @@
}
}
-static void nativeSendPowerHint(JNIEnv *env, jclass clazz, jint hintId, jint data) {
- std::lock_guard<std::mutex> lock(gPowerHalMutex);
- if (getPowerHal()) {
- Return<void> ret;
- if (gPowerHalV1_1 != nullptr) {
- ret = gPowerHalV1_1->powerHintAsync((PowerHint)hintId, data);
- } else {
- ret = gPowerHalV1_0->powerHint((PowerHint)hintId, data);
- }
- processReturn(ret, "powerHint");
- }
+static void nativeSendPowerHint(JNIEnv* /* env */, jclass /* clazz */, jint hintId, jint data) {
+ sendPowerHint(static_cast<PowerHint>(hintId), data);
}
-static void nativeSetFeature(JNIEnv *env, jclass clazz, jint featureId, jint data) {
- std::lock_guard<std::mutex> lock(gPowerHalMutex);
- if (getPowerHal()) {
- Return<void> ret = gPowerHalV1_0->setFeature((Feature)featureId, static_cast<bool>(data));
- processReturn(ret, "setFeature");
+static void nativeSetFeature(JNIEnv* /* env */, jclass /* clazz */, jint featureId, jint data) {
+ sp<IPowerV1_0> powerHalV1_0 = getPowerHalV1_0();
+ if (powerHalV1_0 != nullptr) {
+ Return<void> ret = powerHalV1_0->setFeature((Feature)featureId, static_cast<bool>(data));
+ processPowerHalReturn(ret, "setFeature");
}
}
diff --git a/services/tests/servicestests/src/com/android/server/backup/TrampolineTest.java b/services/tests/servicestests/src/com/android/server/backup/TrampolineTest.java
index ca93663..5786095 100644
--- a/services/tests/servicestests/src/com/android/server/backup/TrampolineTest.java
+++ b/services/tests/servicestests/src/com/android/server/backup/TrampolineTest.java
@@ -82,8 +82,7 @@
};
private final int NON_USER_SYSTEM = UserHandle.USER_SYSTEM + 1;
- @Mock private BackupManagerService mBackupManagerServiceMock;
- @Mock private RefactoredBackupManagerService mRefactoredBackupManagerServiceMock;
+ @Mock private RefactoredBackupManagerService mBackupManagerServiceMock;
@Mock private Context mContextMock;
@Mock private File mSuppressFileMock;
@Mock private File mSuppressFileParentMock;
@@ -102,12 +101,9 @@
public void setUp() {
MockitoAnnotations.initMocks(this);
- TrampolineTestable.sRefactoredBackupManagerServiceMock =
- mRefactoredBackupManagerServiceMock;
- TrampolineTestable.sBackupManagerServiceMock = mBackupManagerServiceMock;
+ TrampolineTestable.sRefactoredBackupManagerServiceMock = mBackupManagerServiceMock;
TrampolineTestable.sSuppressFile = mSuppressFileMock;
TrampolineTestable.sCallingUid = Process.SYSTEM_UID;
- TrampolineTestable.sRefactoredServiceEnabled = false;
TrampolineTestable.sBackupDisabled = false;
when(mSuppressFileMock.getParentFile()).thenReturn(mSuppressFileParentMock);
@@ -163,20 +159,6 @@
}
@Test
- public void createService_refactoredServiceEnabled() {
- TrampolineTestable.sRefactoredServiceEnabled = true;
-
- assertEquals(mRefactoredBackupManagerServiceMock, mTrampoline.createService());
- }
-
- @Test
- public void createService_refactoredServiceDisabled() {
- TrampolineTestable.sRefactoredServiceEnabled = false;
-
- assertEquals(mBackupManagerServiceMock, mTrampoline.createService());
- }
-
- @Test
public void setBackupServiceActive_callerSystemUid_serviceCreated() {
TrampolineTestable.sCallingUid = Process.SYSTEM_UID;
@@ -879,10 +861,8 @@
private static class TrampolineTestable extends Trampoline {
static boolean sBackupDisabled = false;
- static boolean sRefactoredServiceEnabled = false;
static File sSuppressFile = null;
static int sCallingUid = -1;
- static BackupManagerService sBackupManagerServiceMock = null;
static RefactoredBackupManagerService sRefactoredBackupManagerServiceMock = null;
private int mCreateServiceCallsCount = 0;
@@ -891,12 +871,6 @@
}
@Override
- protected BackupManagerServiceInterface createService() {
- mCreateServiceCallsCount++;
- return super.createService();
- }
-
- @Override
public boolean isBackupDisabled() {
return sBackupDisabled;
}
@@ -912,20 +886,11 @@
}
@Override
- protected boolean isRefactoredServiceEnabled() {
- return sRefactoredServiceEnabled;
- }
-
- @Override
protected BackupManagerServiceInterface createRefactoredBackupManagerService() {
+ mCreateServiceCallsCount++;
return sRefactoredBackupManagerServiceMock;
}
- @Override
- protected BackupManagerServiceInterface createBackupManagerService() {
- return sBackupManagerServiceMock;
- }
-
int getCreateServiceCallsCount() {
return mCreateServiceCallsCount;
}
diff --git a/services/tests/servicestests/src/com/android/server/wm/ZOrderingTests.java b/services/tests/servicestests/src/com/android/server/wm/ZOrderingTests.java
index 04f5e5e..e5cbdba 100644
--- a/services/tests/servicestests/src/com/android/server/wm/ZOrderingTests.java
+++ b/services/tests/servicestests/src/com/android/server/wm/ZOrderingTests.java
@@ -39,6 +39,7 @@
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
+import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY;
import static android.view.WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY;
@@ -343,4 +344,22 @@
assertWindowLayerGreaterThan(mTransaction, statusBarPanel, mStatusBarWindow);
assertWindowLayerGreaterThan(mTransaction, statusBarSubPanel, statusBarPanel);
}
+
+ @Test
+ public void testAssignWindowLayers_ForNegativelyZOrderedSubtype() throws Exception {
+ // TODO(b/70040778): We should aim to eliminate the last user of TYPE_APPLICATION_MEDIA
+ // then we can drop all negative layering on the windowing side.
+
+ final WindowState anyWindow =
+ createWindow(null, TYPE_BASE_APPLICATION, mDisplayContent, "anyWindow");
+ final WindowState child = createWindow(anyWindow, TYPE_APPLICATION_MEDIA, mDisplayContent,
+ "TypeApplicationMediaChild");
+ final WindowState mediaOverlayChild = createWindow(anyWindow, TYPE_APPLICATION_MEDIA_OVERLAY,
+ mDisplayContent, "TypeApplicationMediaOverlayChild");
+
+ mDisplayContent.assignChildLayers(mTransaction);
+
+ assertWindowLayerGreaterThan(mTransaction, anyWindow, mediaOverlayChild);
+ assertWindowLayerGreaterThan(mTransaction, mediaOverlayChild, child);
+ }
}
diff --git a/telephony/java/android/telephony/MbmsDownloadSession.java b/telephony/java/android/telephony/MbmsDownloadSession.java
index f392570..a554c69 100644
--- a/telephony/java/android/telephony/MbmsDownloadSession.java
+++ b/telephony/java/android/telephony/MbmsDownloadSession.java
@@ -347,6 +347,7 @@
@Override
public void onServiceDisconnected(ComponentName name) {
+ Log.w(LOG_TAG, "bindAndInitialize: Remote service disconnected");
sIsInitialized.set(false);
mService.set(null);
}
@@ -385,6 +386,7 @@
} catch (RemoteException e) {
Log.w(LOG_TAG, "Remote process died");
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
}
}
@@ -438,6 +440,7 @@
}
} catch (RemoteException e) {
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
return;
}
@@ -521,6 +524,7 @@
downloadService.download(request);
} catch (RemoteException e) {
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
}
}
@@ -542,6 +546,7 @@
return downloadService.listPendingDownloads(mSubscriptionId);
} catch (RemoteException e) {
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
return Collections.emptyList();
}
@@ -583,6 +588,7 @@
}
} catch (RemoteException e) {
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
return;
}
@@ -622,6 +628,7 @@
}
} catch (RemoteException e) {
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
}
} finally {
@@ -658,6 +665,7 @@
}
} catch (RemoteException e) {
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
return;
}
@@ -686,6 +694,7 @@
return downloadService.getDownloadStatus(downloadRequest, fileInfo);
} catch (RemoteException e) {
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
return STATUS_UNKNOWN;
}
@@ -727,6 +736,7 @@
}
} catch (RemoteException e) {
mService.set(null);
+ sIsInitialized.set(false);
sendErrorToApp(MbmsErrors.ERROR_MIDDLEWARE_LOST, null);
}
}
diff --git a/telephony/java/android/telephony/euicc/EuiccManager.java b/telephony/java/android/telephony/euicc/EuiccManager.java
index a13af5f..2507cfee 100644
--- a/telephony/java/android/telephony/euicc/EuiccManager.java
+++ b/telephony/java/android/telephony/euicc/EuiccManager.java
@@ -63,7 +63,7 @@
* embedded SIM.
*
* <p>The activity will immediately finish with {@link android.app.Activity#RESULT_CANCELED} if
- * {@link #isEnabled} is false or if the device is already provisioned.
+ * {@link #isEnabled} is false.
*
* TODO(b/35851809): Make this a SystemApi.
*/
diff --git a/tools/aapt2/LoadedApk.cpp b/tools/aapt2/LoadedApk.cpp
index 5981401..33b5a8b 100644
--- a/tools/aapt2/LoadedApk.cpp
+++ b/tools/aapt2/LoadedApk.cpp
@@ -43,13 +43,16 @@
return {};
}
- if (apk->FindFile("resources.arsc") != nullptr) {
- return LoadBinaryApkFromFileCollection(source, std::move(apk), diag);
- } else if (apk->FindFile("resources.pb") != nullptr) {
- return LoadProtoApkFromFileCollection(source, std::move(apk), diag);
+ ApkFormat apkFormat = DetermineApkFormat(apk.get());
+ switch (apkFormat) {
+ case ApkFormat::kBinary:
+ return LoadBinaryApkFromFileCollection(source, std::move(apk), diag);
+ case ApkFormat::kProto:
+ return LoadProtoApkFromFileCollection(source, std::move(apk), diag);
+ default:
+ diag->Error(DiagMessage(path) << "could not identify format of APK");
+ return {};
}
- diag->Error(DiagMessage(path) << "no resource table found");
- return {};
}
std::unique_ptr<LoadedApk> LoadedApk::LoadProtoApkFromFileCollection(
@@ -243,4 +246,41 @@
return true;
}
+ApkFormat LoadedApk::DetermineApkFormat(io::IFileCollection* apk) {
+ if (apk->FindFile("resources.arsc") != nullptr) {
+ return ApkFormat::kBinary;
+ } else if (apk->FindFile("resources.pb") != nullptr) {
+ return ApkFormat::kProto;
+ } else {
+ // If the resource table is not present, attempt to read the manifest.
+ io::IFile* manifest_file = apk->FindFile(kAndroidManifestPath);
+ if (manifest_file == nullptr) {
+ return ApkFormat::kUnknown;
+ }
+
+ // First try in proto format.
+ std::unique_ptr<io::InputStream> manifest_in = manifest_file->OpenInputStream();
+ if (manifest_in != nullptr) {
+ pb::XmlNode pb_node;
+ io::ZeroCopyInputAdaptor manifest_adaptor(manifest_in.get());
+ if (pb_node.ParseFromZeroCopyStream(&manifest_adaptor)) {
+ return ApkFormat::kProto;
+ }
+ }
+
+ // If it didn't work, try in binary format.
+ std::unique_ptr<io::IData> manifest_data = manifest_file->OpenAsData();
+ if (manifest_data != nullptr) {
+ std::string error;
+ std::unique_ptr<xml::XmlResource> manifest =
+ xml::Inflate(manifest_data->data(), manifest_data->size(), &error);
+ if (manifest != nullptr) {
+ return ApkFormat::kBinary;
+ }
+ }
+
+ return ApkFormat::kUnknown;
+ }
+}
+
} // namespace aapt
diff --git a/tools/aapt2/LoadedApk.h b/tools/aapt2/LoadedApk.h
index ef97de3..6d2257f 100644
--- a/tools/aapt2/LoadedApk.h
+++ b/tools/aapt2/LoadedApk.h
@@ -33,6 +33,12 @@
constexpr static const char kProtoResourceTablePath[] = "resources.pb";
constexpr static const char kAndroidManifestPath[] = "AndroidManifest.xml";
+enum ApkFormat {
+ kUnknown,
+ kBinary,
+ kProto,
+};
+
// Info about an APK loaded in memory.
class LoadedApk {
public:
@@ -104,6 +110,8 @@
std::unique_ptr<io::IFileCollection> apk_;
std::unique_ptr<ResourceTable> table_;
std::unique_ptr<xml::XmlResource> manifest_;
+
+ static ApkFormat DetermineApkFormat(io::IFileCollection* apk);
};
} // namespace aapt
diff --git a/tools/incident_section_gen/main.cpp b/tools/incident_section_gen/main.cpp
index 674bee1..7650795 100644
--- a/tools/incident_section_gen/main.cpp
+++ b/tools/incident_section_gen/main.cpp
@@ -59,24 +59,31 @@
*
* #include "section_list.h"
* ...
- * Privacy WindowState_state { 1, 9, NULL, LOCAL, NULL }; // first two integers are values for field id and proto type.
- * Privacy WindowState_child_windows { 3, 11, NULL, DEFAULT, NULL }; // reserved for WindowState_LIST
- * Privacy* WindowState_MSG_[] = {
+ * Privacy WindowState__state { 1, 9, NULL, LOCAL, NULL }; // first two integers are values for field id and proto type.
+ * Privacy WindowState__child_windows { 3, 11, NULL, UNSET, NULL }; // reserved for WindowState_LIST
+ * Privacy* WindowState__MSG__UNSET[] = {
* &WindowState_state,
* // display id is default, nothing is generated.
* &WindowState_child_windows,
* NULL // terminator of the array
* };
- * Privacy WindowState_my_window { 1, 11, WindowState_my_window_LIST, DEFAULT, NULL };
+ * Privacy WindowState__my_window { 1, 11, WindowState__MSG__UNSET, UNSET, NULL };
*
* createList() {
* ...
- * WindowState_child_windows.children = WindowState_my_window_LIST; // point to its own definition after the list is defined.
+ * WindowState_child_windows.children = WindowState__MSG_UNSET; // point to its own definition after the list is defined.
* ...
* }
*
* const Privacy** PRIVACY_POLICY_LIST = createList();
* const int PRIVACY_POLICY_COUNT = 1;
+ *
+ * Privacy Value Inheritance rules:
+ * 1. Both field and message can be tagged with DESTINATION: LOCAL(L), EXPLICIT(E), AUTOMATIC(A).
+ * 2. Primitives inherits containing message's tag unless defined explicitly.
+ * 3. Containing message's tag doesn't apply to message fields, even when unset (in this case, uses its default message tag).
+ * 4. Message field tag overrides its default message tag.
+ * 5. UNSET tag defaults to EXPLICIT.
*/
// The assignments will be called when constructs PRIVACY_POLICY_LIST, has to be global variable
@@ -164,14 +171,13 @@
return result;
}
-static string getFieldName(const FieldDescriptor* field) {
- return replaceAll(field->full_name(), '.', "__");
+static inline void printPrivacy(const string& name, const FieldDescriptor* field, const string& children,
+ const Destination dest, const string& patterns, const string& comments = "") {
+ printf("Privacy %s = { %d, %d, %s, %d, %s };%s\n", name.c_str(), field->number(), field->type(),
+ children.c_str(), dest, patterns.c_str(), comments.c_str());
}
-static string getMessageTypeName(const Descriptor* descriptor) {
- return replaceAll(descriptor->full_name(), '.', "_") + "_MSG_";
-}
-
+// Get Custom Options ================================================================================
static inline SectionFlags getSectionFlags(const FieldDescriptor* field) {
return field->options().GetExtension(section);
}
@@ -180,24 +186,64 @@
return field->options().GetExtension(privacy);
}
-static inline bool isDefaultField(const FieldDescriptor* field) {
- return getPrivacyFlags(field).dest() == PrivacyFlags::default_instance().dest();
+static inline PrivacyFlags getPrivacyFlags(const Descriptor* descriptor) {
+ return descriptor->options().GetExtension(msg_privacy);
}
-static bool isDefaultMessageImpl(const Descriptor* descriptor, set<string>* parents) {
- int N = descriptor->field_count();
+// Get Destinations ===================================================================================
+static inline Destination getMessageDest(const Descriptor* descriptor, const Destination overridden) {
+ return overridden != DEST_UNSET ? overridden : getPrivacyFlags(descriptor).dest();
+}
+
+// Returns field's own dest, when it is a message field, uses its message default tag if unset.
+static inline Destination getFieldDest(const FieldDescriptor* field) {
+ Destination fieldDest = getPrivacyFlags(field).dest();
+ return field->type() != FieldDescriptor::TYPE_MESSAGE ? fieldDest :
+ getMessageDest(field->message_type(), fieldDest);
+}
+
+// Get Names ===========================================================================================
+static inline string getFieldName(const FieldDescriptor* field) {
+ // replace . with double underscores to avoid name conflicts since fields use snake naming convention
+ return replaceAll(field->full_name(), '.', "__");
+}
+
+
+static inline string getMessageName(const Descriptor* descriptor, const Destination overridden) {
+ // replace . with one underscore since messages use camel naming convention
+ return replaceAll(descriptor->full_name(), '.', "_") + "__MSG__" +
+ to_string(getMessageDest(descriptor, overridden));
+}
+
+// IsDefault ============================================================================================
+// Returns true if a field is default. Default is defined as this field has same dest as its containing message.
+// For message fields, it only looks at its field tag and own default mesaage tag, doesn't recursively go deeper.
+static inline bool isDefaultField(const FieldDescriptor* field, const Destination containerDest) {
+ Destination fieldDest = getFieldDest(field);
+ if (field->type() != FieldDescriptor::TYPE_MESSAGE) {
+ return fieldDest == containerDest || (fieldDest == DEST_UNSET);
+ } else {
+ return fieldDest == containerDest ||
+ (containerDest == DEST_UNSET && fieldDest == DEST_EXPLICIT) ||
+ (containerDest == DEST_EXPLICIT && fieldDest == DEST_UNSET);
+ }
+}
+
+static bool isDefaultMessageImpl(const Descriptor* descriptor, const Destination dest, set<string>* parents) {
+ const int N = descriptor->field_count();
+ const Destination messageDest = getMessageDest(descriptor, dest);
parents->insert(descriptor->full_name());
for (int i=0; i<N; ++i) {
const FieldDescriptor* field = descriptor->field(i);
- // look at if the current field is default or not, return false immediately
- if (!isDefaultField(field)) return false;
-
+ const Destination fieldDest = getFieldDest(field);
+ // If current field is not default, return false immediately
+ if (!isDefaultField(field, messageDest)) return false;
switch (field->type()) {
case FieldDescriptor::TYPE_MESSAGE:
// if self recursion, don't go deep.
if (parents->find(field->message_type()->full_name()) != parents->end()) break;
// if is a default message, just continue
- if (isDefaultMessageImpl(field->message_type(), parents)) break;
+ if (isDefaultMessageImpl(field->message_type(), fieldDest, parents)) break;
// sub message is not default, so this message is always not default
return false;
case FieldDescriptor::TYPE_STRING:
@@ -210,106 +256,118 @@
return true;
}
-static bool isDefaultMessage(const Descriptor* descriptor) {
+// Recursively look at if this message is default, meaning all its fields and sub-messages
+// can be described by the same dest.
+static bool isDefaultMessage(const Descriptor* descriptor, const Destination dest) {
set<string> parents;
- return isDefaultMessageImpl(descriptor, &parents);
+ return isDefaultMessageImpl(descriptor, dest, &parents);
}
-// This function is called for looking at privacy tags for a message type and recursively its sub-messages
-// It prints out each fields's privacy tags and a List of Privacy of the message itself (don't print default values)
-// Returns false if the descriptor doesn't have any non default privacy flags set, including its submessages
-static bool generatePrivacyFlags(const Descriptor* descriptor, map<string, bool> &msgNames, set<string>* parents) {
- bool hasDefaultFlags[descriptor->field_count()];
+// ===============================================================================================================
+static bool numberInOrder(const FieldDescriptor* f1, const FieldDescriptor* f2) {
+ return f1->number() < f2->number();
+}
- string messageTypeName = getMessageTypeName(descriptor);
- // if the message is already defined, skip it.
- if (msgNames.find(messageTypeName) != msgNames.end()) {
- bool hasDefault = msgNames[messageTypeName];
- return !hasDefault; // don't generate if it has default privacy.
+// field numbers are possibly out of order, sort them here.
+static vector<const FieldDescriptor*> sortFields(const Descriptor* descriptor) {
+ vector<const FieldDescriptor*> fields;
+ fields.reserve(descriptor->field_count());
+ for (int i=0; i<descriptor->field_count(); i++) {
+ fields.push_back(descriptor->field(i));
+ }
+ std::sort(fields.begin(), fields.end(), numberInOrder);
+ return fields;
+}
+
+// This function looks for privacy tags of a message type and recursively its sub-messages.
+// It generates Privacy objects for each non-default fields including non-default sub-messages.
+// And if the message has Privacy objects generated, it returns a list of them.
+// Returns false if the descriptor doesn't have any non default privacy flags set, including its submessages
+static bool generatePrivacyFlags(const Descriptor* descriptor, const Destination overridden,
+ map<string, bool> &variableNames, set<string>* parents) {
+ const string messageName = getMessageName(descriptor, overridden);
+ const Destination messageDest = getMessageDest(descriptor, overridden);
+
+ if (variableNames.find(messageName) != variableNames.end()) {
+ bool hasDefault = variableNames[messageName];
+ return !hasDefault; // if has default, then don't generate privacy flags.
}
// insert the message type name so sub-message will figure out if self-recursion occurs
- parents->insert(messageTypeName);
+ parents->insert(messageName);
- // iterate though its field and generate sub flags first
- for (int i=0; i<descriptor->field_count(); i++) {
- hasDefaultFlags[i] = true; // set default to true
-
- const FieldDescriptor* field = descriptor->field(i);
+ // sort fields based on number, iterate though them and generate sub flags first
+ vector<const FieldDescriptor*> fieldsInOrder = sortFields(descriptor);
+ bool hasDefaultFlags[fieldsInOrder.size()];
+ for (size_t i=0; i<fieldsInOrder.size(); i++) {
+ const FieldDescriptor* field = fieldsInOrder[i];
const string fieldName = getFieldName(field);
- // check if the same field name is already defined.
- if (msgNames.find(fieldName) != msgNames.end()) {
- hasDefaultFlags[i] = msgNames[fieldName];
- continue;
- };
+ const Destination fieldDest = getFieldDest(field);
- PrivacyFlags p = getPrivacyFlags(field);
+ if (variableNames.find(fieldName) != variableNames.end()) {
+ hasDefaultFlags[i] = variableNames[fieldName];
+ continue;
+ }
+ hasDefaultFlags[i] = isDefaultField(field, messageDest);
+
string fieldMessageName;
+ PrivacyFlags p = getPrivacyFlags(field);
switch (field->type()) {
case FieldDescriptor::TYPE_MESSAGE:
- fieldMessageName = getMessageTypeName(field->message_type());
+ fieldMessageName = getMessageName(field->message_type(), fieldDest);
if (parents->find(fieldMessageName) != parents->end()) { // Self-Recursion proto definition
- if (isDefaultField(field)) {
- hasDefaultFlags[i] = isDefaultMessage(field->message_type());
- } else {
- hasDefaultFlags[i] = false;
+ if (hasDefaultFlags[i]) {
+ hasDefaultFlags[i] = isDefaultMessage(field->message_type(), fieldDest);
}
if (!hasDefaultFlags[i]) {
- printf("Privacy %s = { %d, %d, NULL, %d, NULL }; // self recursion field of %s\n",
- fieldName.c_str(), field->number(), field->type(), p.dest(), fieldMessageName.c_str());
+ printPrivacy(fieldName, field, "NULL", fieldDest, "NULL",
+ " // self recursion field of " + fieldMessageName);
// generate the assignment and used to construct createList function later on.
gSelfRecursionAssignments.push_back(fieldName + ".children = " + fieldMessageName);
}
- break;
- } else if (generatePrivacyFlags(field->message_type(), msgNames, parents)) {
- printf("Privacy %s = { %d, %d, %s, %d, NULL };\n", fieldName.c_str(), field->number(),
- field->type(), fieldMessageName.c_str(), p.dest());
- } else if (isDefaultField(field)) {
- // don't create a new privacy if the value is default.
- break;
- } else {
- printf("Privacy %s = { %d, %d, NULL, %d, NULL };\n", fieldName.c_str(), field->number(),
- field->type(), p.dest());
+ } else if (generatePrivacyFlags(field->message_type(), p.dest(), variableNames, parents)) {
+ if (variableNames.find(fieldName) == variableNames.end()) {
+ printPrivacy(fieldName, field, fieldMessageName, fieldDest, "NULL");
+ }
+ hasDefaultFlags[i] = false;
+ } else if (!hasDefaultFlags[i]) {
+ printPrivacy(fieldName, field, "NULL", fieldDest, "NULL");
}
- hasDefaultFlags[i] = false;
break;
case FieldDescriptor::TYPE_STRING:
- if (isDefaultField(field) && p.patterns_size() == 0) break;
-
- printf("const char* %s_patterns[] = {\n", fieldName.c_str());
- for (int i=0; i<p.patterns_size(); i++) {
- // the generated string need to escape backslash as well, need to dup it here
- printf(" \"%s\",\n", replaceAll(p.patterns(i), '\\', "\\\\").c_str());
+ if (p.patterns_size() != 0) { // if patterns are specified
+ if (hasDefaultFlags[i]) break;
+ printf("const char* %s_patterns[] = {\n", fieldName.c_str());
+ for (int j=0; j<p.patterns_size(); j++) {
+ // generated string needs to escape backslash too, duplicate it to allow escape again.
+ printf(" \"%s\",\n", replaceAll(p.patterns(j), '\\', "\\\\").c_str());
+ }
+ printf(" NULL };\n");
+ printPrivacy(fieldName, field, "NULL", fieldDest, fieldName + "_patterns");
+ break;
}
- printf(" NULL };\n");
- printf("Privacy %s = { %d, %d, NULL, %d, %s_patterns };\n", fieldName.c_str(), field->number(),
- field->type(), p.dest(), fieldName.c_str());
- hasDefaultFlags[i] = false;
- break;
+ // else treat string field as primitive field and goes to default
default:
- if (isDefaultField(field)) break;
- printf("Privacy %s = { %d, %d, NULL, %d, NULL };\n", fieldName.c_str(), field->number(),
- field->type(), p.dest());
- hasDefaultFlags[i] = false;
+ if (!hasDefaultFlags[i]) printPrivacy(fieldName, field, "NULL", fieldDest, "NULL");
}
- // add the field name to message map, true means it has default flags
- msgNames[fieldName] = hasDefaultFlags[i];
+ // Don't generate a variable twice
+ if (!hasDefaultFlags[i]) variableNames[fieldName] = false;
}
bool allDefaults = true;
- for (int i=0; i<descriptor->field_count(); i++) {
+ for (size_t i=0; i<fieldsInOrder.size(); i++) {
allDefaults &= hasDefaultFlags[i];
}
- parents->erase(messageTypeName); // erase the message type name when exit the message.
- msgNames[messageTypeName] = allDefaults; // store the privacy tags of the message here to avoid overhead.
+ parents->erase(messageName); // erase the message type name when exit the message.
+ variableNames[messageName] = allDefaults; // store the privacy tags of the message here to avoid overhead.
if (allDefaults) return false;
emptyline();
int policyCount = 0;
- printf("Privacy* %s[] = {\n", messageTypeName.c_str());
- for (int i=0; i<descriptor->field_count(); i++) {
- const FieldDescriptor* field = descriptor->field(i);
+ printf("Privacy* %s[] = {\n", messageName.c_str());
+ for (size_t i=0; i<fieldsInOrder.size(); i++) {
+ const FieldDescriptor* field = fieldsInOrder[i];
if (hasDefaultFlags[i]) continue;
printf(" &%s,\n", getFieldName(field).c_str());
policyCount++;
@@ -359,29 +417,30 @@
// generates PRIVACY_POLICY_LIST
printf("// Generate PRIVACY_POLICY_LIST.\n\n");
- map<string, bool> messageNames;
+ map<string, bool> variableNames;
set<string> parents;
- bool skip[descriptor->field_count()];
+ vector<const FieldDescriptor*> fieldsInOrder = sortFields(descriptor);
+ bool skip[fieldsInOrder.size()];
+ const Destination incidentDest = getPrivacyFlags(descriptor).dest();
- for (int i=0; i<descriptor->field_count(); i++) {
- const FieldDescriptor* field = descriptor->field(i);
+ for (size_t i=0; i<fieldsInOrder.size(); i++) {
+ const FieldDescriptor* field = fieldsInOrder[i];
const string fieldName = getFieldName(field);
- PrivacyFlags p = getPrivacyFlags(field);
+ const Destination fieldDest = getFieldDest(field);
+ const string fieldMessageName = getMessageName(field->message_type(), fieldDest);
skip[i] = true;
if (field->type() != FieldDescriptor::TYPE_MESSAGE) {
continue;
}
- // generate privacy flags for each field.
- if (generatePrivacyFlags(field->message_type(), messageNames, &parents)) {
- printf("Privacy %s { %d, %d, %s, %d, NULL };\n", fieldName.c_str(), field->number(),
- field->type(), getMessageTypeName(field->message_type()).c_str(), p.dest());
- } else if (isDefaultField(field)) {
+ // generate privacy flags for each section.
+ if (generatePrivacyFlags(field->message_type(), fieldDest, variableNames, &parents)) {
+ printPrivacy(fieldName, field, fieldMessageName, fieldDest, "NULL");
+ } else if (isDefaultField(field, incidentDest)) {
continue; // don't create a new privacy if the value is default.
} else {
- printf("Privacy %s { %d, %d, NULL, %d, NULL };\n", fieldName.c_str(), field->number(),
- field->type(), p.dest());
+ printPrivacy(fieldName, field, "NULL", fieldDest, "NULL");
}
skip[i] = false;
}
@@ -391,16 +450,16 @@
int policyCount = 0;
if (gSelfRecursionAssignments.empty()) {
printf("Privacy* privacyArray[] = {\n");
- for (int i=0; i<descriptor->field_count(); i++) {
+ for (size_t i=0; i<fieldsInOrder.size(); i++) {
if (skip[i]) continue;
- printf(" &%s,\n", getFieldName(descriptor->field(i)).c_str());
+ printf(" &%s,\n", getFieldName(fieldsInOrder[i]).c_str());
policyCount++;
}
printf("};\n\n");
printf("const Privacy** PRIVACY_POLICY_LIST = const_cast<const Privacy**>(privacyArray);\n\n");
printf("const int PRIVACY_POLICY_COUNT = %d;\n", policyCount);
} else {
- for (int i=0; i<descriptor->field_count(); i++) {
+ for (size_t i=0; i<fieldsInOrder.size(); i++) {
if (!skip[i]) policyCount++;
}
@@ -410,9 +469,9 @@
}
printf(" Privacy** privacyArray = (Privacy**)malloc(%d * sizeof(Privacy**));\n", policyCount);
policyCount = 0; // reset
- for (int i=0; i<descriptor->field_count(); i++) {
+ for (size_t i=0; i<fieldsInOrder.size(); i++) {
if (skip[i]) continue;
- printf(" privacyArray[%d] = &%s;\n", policyCount++, getFieldName(descriptor->field(i)).c_str());
+ printf(" privacyArray[%d] = &%s;\n", policyCount++, getFieldName(fieldsInOrder[i]).c_str());
}
printf(" return const_cast<const Privacy**>(privacyArray);\n");
printf("}\n\n");