Merge "Revert "nativebrige: log code_cache access errors to stderr as well""
diff --git a/adb/Android.mk b/adb/Android.mk
index 9c8ab6d..d629223 100644
--- a/adb/Android.mk
+++ b/adb/Android.mk
@@ -349,8 +349,6 @@
libcutils \
libbase \
libcrypto_static \
- libminijail \
- libminijail_generated \
- libcap
+ libminijail
include $(BUILD_EXECUTABLE)
diff --git a/adb/adb.cpp b/adb/adb.cpp
index c03d7db..3005652 100644
--- a/adb/adb.cpp
+++ b/adb/adb.cpp
@@ -35,6 +35,7 @@
#include <android-base/logging.h>
#include <android-base/macros.h>
+#include <android-base/parsenetaddress.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
@@ -857,8 +858,7 @@
#if ADB_HOST
SendOkay(reply_fd);
#endif
- SendProtocolString(reply_fd, listeners);
- return 1;
+ return SendProtocolString(reply_fd, listeners);
}
if (!strcmp(service, "killforward-all")) {
@@ -1038,7 +1038,7 @@
std::string host;
int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
std::string error;
- if (!parse_host_and_port(address, &serial, &host, &port, &error)) {
+ if (!android::base::ParseNetAddress(address, &host, &port, &serial, &error)) {
return SendFail(reply_fd, android::base::StringPrintf("couldn't parse '%s': %s",
address.c_str(), error.c_str()));
}
diff --git a/adb/adb.h b/adb/adb.h
index 9020fc3..59644d4 100644
--- a/adb/adb.h
+++ b/adb/adb.h
@@ -142,10 +142,10 @@
void print_packet(const char *label, apacket *p);
-
-
-void fatal(const char *fmt, ...) __attribute__((noreturn));
-void fatal_errno(const char *fmt, ...) __attribute__((noreturn));
+// These use the system (v)fprintf, not the adb prefixed ones defined in sysdeps.h, so they
+// shouldn't be tagged with ADB_FORMAT_ARCHETYPE.
+void fatal(const char* fmt, ...) __attribute__((noreturn, format(__printf__, 1, 2)));
+void fatal_errno(const char* fmt, ...) __attribute__((noreturn, format(__printf__, 1, 2)));
void handle_packet(apacket *p, atransport *t);
diff --git a/adb/adb_client.cpp b/adb/adb_client.cpp
index cb5e488..bbc4dc7 100644
--- a/adb/adb_client.cpp
+++ b/adb/adb_client.cpp
@@ -124,7 +124,7 @@
int _adb_connect(const std::string& service, std::string* error) {
D("_adb_connect: %s", service.c_str());
- if (service.empty() || service.size() > 1024) {
+ if (service.empty() || service.size() > MAX_PAYLOAD_V1) {
*error = android::base::StringPrintf("bad service name length (%zd)",
service.size());
return -1;
diff --git a/adb/adb_io.cpp b/adb/adb_io.cpp
index 176b7bd..ae16834 100644
--- a/adb/adb_io.cpp
+++ b/adb/adb_io.cpp
@@ -22,14 +22,16 @@
#include <android-base/stringprintf.h>
+#include "adb.h"
#include "adb_trace.h"
#include "adb_utils.h"
#include "sysdeps.h"
bool SendProtocolString(int fd, const std::string& s) {
- int length = s.size();
- if (length > 0xffff) {
- length = 0xffff;
+ unsigned int length = s.size();
+ if (length > MAX_PAYLOAD_V1 - 4) {
+ errno = EMSGSIZE;
+ return false;
}
// The cost of sending two strings outweighs the cost of formatting.
diff --git a/adb/adb_utils.cpp b/adb/adb_utils.cpp
index b132118..474d1b4 100644
--- a/adb/adb_utils.cpp
+++ b/adb/adb_utils.cpp
@@ -208,59 +208,6 @@
return line;
}
-bool parse_host_and_port(const std::string& address,
- std::string* canonical_address,
- std::string* host, int* port,
- std::string* error) {
- host->clear();
-
- bool ipv6 = true;
- bool saw_port = false;
- size_t colons = std::count(address.begin(), address.end(), ':');
- size_t dots = std::count(address.begin(), address.end(), '.');
- std::string port_str;
- if (address[0] == '[') {
- // [::1]:123
- if (address.rfind("]:") == std::string::npos) {
- *error = android::base::StringPrintf("bad IPv6 address '%s'", address.c_str());
- return false;
- }
- *host = address.substr(1, (address.find("]:") - 1));
- port_str = address.substr(address.rfind("]:") + 2);
- saw_port = true;
- } else if (dots == 0 && colons >= 2 && colons <= 7) {
- // ::1
- *host = address;
- } else if (colons <= 1) {
- // 1.2.3.4 or some.accidental.domain.com
- ipv6 = false;
- std::vector<std::string> pieces = android::base::Split(address, ":");
- *host = pieces[0];
- if (pieces.size() > 1) {
- port_str = pieces[1];
- saw_port = true;
- }
- }
-
- if (host->empty()) {
- *error = android::base::StringPrintf("no host in '%s'", address.c_str());
- return false;
- }
-
- if (saw_port) {
- if (sscanf(port_str.c_str(), "%d", port) != 1 || *port <= 0 || *port > 65535) {
- *error = android::base::StringPrintf("bad port number '%s' in '%s'",
- port_str.c_str(), address.c_str());
- return false;
- }
- }
-
- *canonical_address = android::base::StringPrintf(ipv6 ? "[%s]:%d" : "%s:%d", host->c_str(), *port);
- LOG(DEBUG) << "parsed " << address << " as " << *host << " and " << *port
- << " (" << *canonical_address << ")";
- return true;
-}
-
std::string perror_str(const char* msg) {
return android::base::StringPrintf("%s: %s", msg, strerror(errno));
}
diff --git a/adb/adb_utils.h b/adb/adb_utils.h
index 388d7dd..f1149b3 100644
--- a/adb/adb_utils.h
+++ b/adb/adb_utils.h
@@ -35,17 +35,6 @@
std::string dump_hex(const void* ptr, size_t byte_count);
-// Parses 'address' into 'host' and 'port'.
-// If no port is given, takes the default from *port.
-// 'canonical_address' then becomes "host:port" or "[host]:port" as appropriate.
-// Note that no real checking is done that 'host' or 'port' is valid; that's
-// left to getaddrinfo(3).
-// Returns false on failure and sets *error to an appropriate message.
-bool parse_host_and_port(const std::string& address,
- std::string* canonical_address,
- std::string* host, int* port,
- std::string* error);
-
std::string perror_str(const char* msg);
bool set_file_block_mode(int fd, bool block);
diff --git a/adb/adb_utils_test.cpp b/adb/adb_utils_test.cpp
index 4508bca..794dce6 100644
--- a/adb/adb_utils_test.cpp
+++ b/adb/adb_utils_test.cpp
@@ -111,88 +111,6 @@
EXPECT_EQ("/system/bin", adb_dirname("/system/bin/sh/"));
}
-TEST(adb_utils, parse_host_and_port) {
- std::string canonical_address;
- std::string host;
- int port;
- std::string error;
-
- // Name, default port.
- port = 123;
- ASSERT_TRUE(parse_host_and_port("www.google.com", &canonical_address, &host, &port, &error));
- ASSERT_EQ("www.google.com:123", canonical_address);
- ASSERT_EQ("www.google.com", host);
- ASSERT_EQ(123, port);
-
- // Name, explicit port.
- ASSERT_TRUE(parse_host_and_port("www.google.com:666", &canonical_address, &host, &port, &error));
- ASSERT_EQ("www.google.com:666", canonical_address);
- ASSERT_EQ("www.google.com", host);
- ASSERT_EQ(666, port);
-
- // IPv4, default port.
- port = 123;
- ASSERT_TRUE(parse_host_and_port("1.2.3.4", &canonical_address, &host, &port, &error));
- ASSERT_EQ("1.2.3.4:123", canonical_address);
- ASSERT_EQ("1.2.3.4", host);
- ASSERT_EQ(123, port);
-
- // IPv4, explicit port.
- ASSERT_TRUE(parse_host_and_port("1.2.3.4:666", &canonical_address, &host, &port, &error));
- ASSERT_EQ("1.2.3.4:666", canonical_address);
- ASSERT_EQ("1.2.3.4", host);
- ASSERT_EQ(666, port);
-
- // Simple IPv6, default port.
- port = 123;
- ASSERT_TRUE(parse_host_and_port("::1", &canonical_address, &host, &port, &error));
- ASSERT_EQ("[::1]:123", canonical_address);
- ASSERT_EQ("::1", host);
- ASSERT_EQ(123, port);
-
- // Simple IPv6, explicit port.
- ASSERT_TRUE(parse_host_and_port("[::1]:666", &canonical_address, &host, &port, &error));
- ASSERT_EQ("[::1]:666", canonical_address);
- ASSERT_EQ("::1", host);
- ASSERT_EQ(666, port);
-
- // Hairy IPv6, default port.
- port = 123;
- ASSERT_TRUE(parse_host_and_port("fe80::200:5aee:feaa:20a2", &canonical_address, &host, &port, &error));
- ASSERT_EQ("[fe80::200:5aee:feaa:20a2]:123", canonical_address);
- ASSERT_EQ("fe80::200:5aee:feaa:20a2", host);
- ASSERT_EQ(123, port);
-
- // Simple IPv6, explicit port.
- ASSERT_TRUE(parse_host_and_port("[fe80::200:5aee:feaa:20a2]:666", &canonical_address, &host, &port, &error));
- ASSERT_EQ("[fe80::200:5aee:feaa:20a2]:666", canonical_address);
- ASSERT_EQ("fe80::200:5aee:feaa:20a2", host);
- ASSERT_EQ(666, port);
-
- // Invalid IPv4.
- EXPECT_FALSE(parse_host_and_port("1.2.3.4:", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("1.2.3.4::", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("1.2.3.4:hello", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port(":123", &canonical_address, &host, &port, &error));
-
- // Invalid IPv6.
- EXPECT_FALSE(parse_host_and_port(":1", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("::::::::1", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("[::1", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("[::1]", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("[::1]:", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("[::1]::", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("[::1]:hello", &canonical_address, &host, &port, &error));
-
- // Invalid ports.
- EXPECT_FALSE(parse_host_and_port("[::1]:-1", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("[::1]:0", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("[::1]:65536", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("1.2.3.4:-1", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("1.2.3.4:0", &canonical_address, &host, &port, &error));
- EXPECT_FALSE(parse_host_and_port("1.2.3.4:65536", &canonical_address, &host, &port, &error));
-}
-
void test_mkdirs(const std::string basepath) {
EXPECT_TRUE(mkdirs(basepath));
EXPECT_NE(-1, adb_creat(basepath.c_str(), 0600));
diff --git a/adb/commandline.cpp b/adb/commandline.cpp
index a025ed7..f886698 100644
--- a/adb/commandline.cpp
+++ b/adb/commandline.cpp
@@ -443,13 +443,32 @@
return android::base::StringPrintf("%s:%s", prefix, command);
}
-// Returns the FeatureSet for the indicated transport.
-static FeatureSet GetFeatureSet(TransportType transport_type, const char* serial) {
+namespace {
+
+enum class ErrorAction {
+ kPrintToStderr,
+ kDoNotPrint
+};
+
+} // namespace
+
+// Fills |feature_set| using the target indicated by |transport_type| and |serial|. Returns false
+// and clears |feature_set| on failure. |error_action| selects whether to also print error messages
+// on failure.
+static bool GetFeatureSet(TransportType transport_type, const char* serial, FeatureSet* feature_set,
+ ErrorAction error_action) {
std::string result, error;
+
if (adb_query(format_host_command("features", transport_type, serial), &result, &error)) {
- return StringToFeatureSet(result);
+ *feature_set = StringToFeatureSet(result);
+ return true;
}
- return FeatureSet();
+
+ if (error_action == ErrorAction::kPrintToStderr) {
+ fprintf(stderr, "error: %s\n", error.c_str());
+ }
+ feature_set->clear();
+ return false;
}
static void send_window_size_change(int fd, std::unique_ptr<ShellProtocol>& shell) {
@@ -695,7 +714,10 @@
static int adb_shell(int argc, const char** argv,
TransportType transport_type, const char* serial) {
- FeatureSet features = GetFeatureSet(transport_type, serial);
+ FeatureSet features;
+ if (!GetFeatureSet(transport_type, serial, &features, ErrorAction::kPrintToStderr)) {
+ return 1;
+ }
bool use_shell_protocol = CanUseFeature(features, kFeatureShell2);
if (!use_shell_protocol) {
@@ -1065,23 +1087,33 @@
static int send_shell_command(TransportType transport_type, const char* serial,
const std::string& command,
bool disable_shell_protocol) {
- // Only use shell protocol if it's supported and the caller doesn't want
- // to explicitly disable it.
- bool use_shell_protocol = false;
- if (!disable_shell_protocol) {
- FeatureSet features = GetFeatureSet(transport_type, serial);
- use_shell_protocol = CanUseFeature(features, kFeatureShell2);
- }
-
- std::string service_string = ShellServiceString(use_shell_protocol, "", command);
-
int fd;
+ bool use_shell_protocol = false;
+
while (true) {
- std::string error;
- fd = adb_connect(service_string, &error);
- if (fd >= 0) {
- break;
+ bool attempt_connection = true;
+
+ // Use shell protocol if it's supported and the caller doesn't explicitly disable it.
+ if (!disable_shell_protocol) {
+ FeatureSet features;
+ if (GetFeatureSet(transport_type, serial, &features, ErrorAction::kDoNotPrint)) {
+ use_shell_protocol = CanUseFeature(features, kFeatureShell2);
+ } else {
+ // Device was unreachable.
+ attempt_connection = false;
+ }
}
+
+ if (attempt_connection) {
+ std::string error;
+ std::string service_string = ShellServiceString(use_shell_protocol, "", command);
+
+ fd = adb_connect(service_string, &error);
+ if (fd >= 0) {
+ break;
+ }
+ }
+
fprintf(stderr,"- waiting for device -\n");
adb_sleep_ms(1000);
wait_for_device("wait-for-device", transport_type, serial);
@@ -1698,7 +1730,11 @@
}
else if (!strcmp(argv[0], "install")) {
if (argc < 2) return usage();
- FeatureSet features = GetFeatureSet(transport_type, serial);
+ FeatureSet features;
+ if (!GetFeatureSet(transport_type, serial, &features, ErrorAction::kPrintToStderr)) {
+ return 1;
+ }
+
if (CanUseFeature(features, kFeatureCmd)) {
return install_app(transport_type, serial, argc, argv);
}
@@ -1710,7 +1746,11 @@
}
else if (!strcmp(argv[0], "uninstall")) {
if (argc < 2) return usage();
- FeatureSet features = GetFeatureSet(transport_type, serial);
+ FeatureSet features;
+ if (!GetFeatureSet(transport_type, serial, &features, ErrorAction::kPrintToStderr)) {
+ return 1;
+ }
+
if (CanUseFeature(features, kFeatureCmd)) {
return uninstall_app(transport_type, serial, argc, argv);
}
@@ -1809,7 +1849,11 @@
}
else if (!strcmp(argv[0], "features")) {
// Only list the features common to both the adb client and the device.
- FeatureSet features = GetFeatureSet(transport_type, serial);
+ FeatureSet features;
+ if (!GetFeatureSet(transport_type, serial, &features, ErrorAction::kPrintToStderr)) {
+ return 1;
+ }
+
for (const std::string& name : features) {
if (CanUseFeature(features, name)) {
printf("%s\n", name.c_str());
diff --git a/adb/fdevent.cpp b/adb/fdevent.cpp
index 25e8376..386f221 100644
--- a/adb/fdevent.cpp
+++ b/adb/fdevent.cpp
@@ -306,12 +306,14 @@
auto it = g_poll_node_map.find(subproc_fd);
if (it == g_poll_node_map.end()) {
D("subproc_fd %d cleared from fd_table", subproc_fd);
+ adb_close(subproc_fd);
return;
}
fdevent* subproc_fde = it->second.fde;
if(subproc_fde->fd != subproc_fd) {
// Already reallocated?
- D("subproc_fd(%d) != subproc_fde->fd(%d)", subproc_fd, subproc_fde->fd);
+ LOG(FATAL) << "subproc_fd(" << subproc_fd << ") != subproc_fde->fd(" << subproc_fde->fd
+ << ")";
return;
}
diff --git a/adb/line_printer.cpp b/adb/line_printer.cpp
index e8fe6c9..4ec8979 100644
--- a/adb/line_printer.cpp
+++ b/adb/line_printer.cpp
@@ -67,7 +67,7 @@
void LinePrinter::Print(string to_print, LineType type) {
if (!smart_terminal_) {
- Out(to_print);
+ Out(to_print + "\n");
return;
}
diff --git a/adb/services.cpp b/adb/services.cpp
index cd33e7b..9cbf787 100644
--- a/adb/services.cpp
+++ b/adb/services.cpp
@@ -32,6 +32,7 @@
#endif
#include <android-base/file.h>
+#include <android-base/parsenetaddress.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <cutils/sockets.h>
@@ -396,7 +397,7 @@
std::string serial;
std::string host;
int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
- if (!parse_host_and_port(address, &serial, &host, &port, response)) {
+ if (!android::base::ParseNetAddress(address, &host, &port, &serial, response)) {
return;
}
diff --git a/adb/shell_service.cpp b/adb/shell_service.cpp
index 366ed07..e092dc4 100644
--- a/adb/shell_service.cpp
+++ b/adb/shell_service.cpp
@@ -183,7 +183,6 @@
~Subprocess();
const std::string& command() const { return command_; }
- bool is_interactive() const { return command_.empty(); }
int local_socket_fd() const { return local_socket_sfd_.fd(); }
@@ -233,6 +232,7 @@
}
Subprocess::~Subprocess() {
+ WaitForExit();
}
bool Subprocess::ForkAndExec() {
@@ -331,7 +331,7 @@
parent_error_sfd.Reset();
close_on_exec(child_error_sfd.fd());
- if (is_interactive()) {
+ if (command_.empty()) {
execle(_PATH_BSHELL, _PATH_BSHELL, "-", nullptr, cenv.data());
} else {
execle(_PATH_BSHELL, _PATH_BSHELL, "-c", command_.c_str(), nullptr, cenv.data());
@@ -408,20 +408,6 @@
exit(-1);
}
- if (!is_interactive()) {
- termios tattr;
- if (tcgetattr(child_fd, &tattr) == -1) {
- WriteFdExactly(error_sfd->fd(), "tcgetattr failed");
- exit(-1);
- }
-
- cfmakeraw(&tattr);
- if (tcsetattr(child_fd, TCSADRAIN, &tattr) == -1) {
- WriteFdExactly(error_sfd->fd(), "tcsetattr failed");
- exit(-1);
- }
- }
-
return child_fd;
}
@@ -432,7 +418,6 @@
"shell srvc %d", subprocess->local_socket_fd()));
subprocess->PassDataStreams();
- subprocess->WaitForExit();
D("deleting Subprocess for PID %d", subprocess->pid());
delete subprocess;
diff --git a/adb/sockets.cpp b/adb/sockets.cpp
index eb0ce85..d8e4e93 100644
--- a/adb/sockets.cpp
+++ b/adb/sockets.cpp
@@ -698,17 +698,17 @@
p = s->pkt_first;
}
- /* don't bother if we can't decode the length */
+ /* don't bother if we can't decode the length */
if(p->len < 4) return 0;
len = unhex(p->data, 4);
- if((len < 1) || (len > 1024)) {
+ if ((len < 1) || (len > MAX_PAYLOAD_V1)) {
D("SS(%d): bad size (%d)", s->id, len);
goto fail;
}
D("SS(%d): len is %d", s->id, len );
- /* can't do anything until we have the full header */
+ /* can't do anything until we have the full header */
if((len + 4) > p->len) {
D("SS(%d): waiting for %d more bytes", s->id, len+4 - p->len);
return 0;
diff --git a/adb/sysdeps_win32.cpp b/adb/sysdeps_win32.cpp
index 0a2a8f6..c3889b6 100644
--- a/adb/sysdeps_win32.cpp
+++ b/adb/sysdeps_win32.cpp
@@ -88,7 +88,10 @@
_fh_socket_hook
};
-#define assert(cond) do { if (!(cond)) fatal( "assertion failed '%s' on %s:%ld\n", #cond, __FILE__, __LINE__ ); } while (0)
+#define assert(cond) \
+ do { \
+ if (!(cond)) fatal("assertion failed '%s' on %s:%d\n", #cond, __FILE__, __LINE__); \
+ } while (0)
std::string SystemErrorCodeToString(const DWORD error_code) {
const int kErrorMessageBufferSize = 256;
@@ -1589,7 +1592,7 @@
/**************************************************************************/
/**************************************************************************/
-#define FATAL(x...) fatal(__FUNCTION__, x)
+#define FATAL(fmt, ...) fatal("%s: " fmt, __FUNCTION__, ##__VA_ARGS__)
#if DEBUG
static void dump_fde(fdevent *fde, const char *info)
diff --git a/adb/sysdeps_win32_test.cpp b/adb/sysdeps_win32_test.cpp
index 81923cb..1d40281 100755
--- a/adb/sysdeps_win32_test.cpp
+++ b/adb/sysdeps_win32_test.cpp
@@ -66,7 +66,7 @@
const char* path_val = adb_getenv("PATH");
EXPECT_NE(nullptr, path_val);
if (path_val != nullptr) {
- EXPECT_GT(strlen(path_val), 0);
+ EXPECT_GT(strlen(path_val), 0U);
}
}
diff --git a/base/Android.mk b/base/Android.mk
index cba70d4..18f8686 100644
--- a/base/Android.mk
+++ b/base/Android.mk
@@ -19,6 +19,7 @@
libbase_src_files := \
file.cpp \
logging.cpp \
+ parsenetaddress.cpp \
stringprintf.cpp \
strings.cpp \
test_utils.cpp \
@@ -30,6 +31,7 @@
file_test.cpp \
logging_test.cpp \
parseint_test.cpp \
+ parsenetaddress_test.cpp \
stringprintf_test.cpp \
strings_test.cpp \
test_main.cpp \
diff --git a/base/include/android-base/parsenetaddress.h b/base/include/android-base/parsenetaddress.h
new file mode 100644
index 0000000..2de5ac9
--- /dev/null
+++ b/base/include/android-base/parsenetaddress.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#ifndef BASE_PARSENETADDRESS_H
+#define BASE_PARSENETADDRESS_H
+
+#include <string>
+
+namespace android {
+namespace base {
+
+// Parses |address| into |host| and |port|.
+//
+// If |address| doesn't contain a port number, the default value is taken from
+// |port|. If |canonical_address| is non-null it will be set to "host:port" or
+// "[host]:port" as appropriate.
+//
+// On failure, returns false and fills |error|.
+bool ParseNetAddress(const std::string& address, std::string* host, int* port,
+ std::string* canonical_address, std::string* error);
+
+} // namespace base
+} // namespace android
+
+#endif // BASE_PARSENETADDRESS_H
diff --git a/base/parsenetaddress.cpp b/base/parsenetaddress.cpp
new file mode 100644
index 0000000..dd80f6d
--- /dev/null
+++ b/base/parsenetaddress.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#include "android-base/parsenetaddress.h"
+
+#include <algorithm>
+
+#include "android-base/stringprintf.h"
+#include "android-base/strings.h"
+
+namespace android {
+namespace base {
+
+bool ParseNetAddress(const std::string& address, std::string* host, int* port,
+ std::string* canonical_address, std::string* error) {
+ host->clear();
+
+ bool ipv6 = true;
+ bool saw_port = false;
+ size_t colons = std::count(address.begin(), address.end(), ':');
+ size_t dots = std::count(address.begin(), address.end(), '.');
+ std::string port_str;
+ if (address[0] == '[') {
+ // [::1]:123
+ if (address.rfind("]:") == std::string::npos) {
+ *error = StringPrintf("bad IPv6 address '%s'", address.c_str());
+ return false;
+ }
+ *host = address.substr(1, (address.find("]:") - 1));
+ port_str = address.substr(address.rfind("]:") + 2);
+ saw_port = true;
+ } else if (dots == 0 && colons >= 2 && colons <= 7) {
+ // ::1
+ *host = address;
+ } else if (colons <= 1) {
+ // 1.2.3.4 or some.accidental.domain.com
+ ipv6 = false;
+ std::vector<std::string> pieces = Split(address, ":");
+ *host = pieces[0];
+ if (pieces.size() > 1) {
+ port_str = pieces[1];
+ saw_port = true;
+ }
+ }
+
+ if (host->empty()) {
+ *error = StringPrintf("no host in '%s'", address.c_str());
+ return false;
+ }
+
+ if (saw_port) {
+ if (sscanf(port_str.c_str(), "%d", port) != 1 || *port <= 0 ||
+ *port > 65535) {
+ *error = StringPrintf("bad port number '%s' in '%s'", port_str.c_str(),
+ address.c_str());
+ return false;
+ }
+ }
+
+ if (canonical_address != nullptr) {
+ *canonical_address =
+ StringPrintf(ipv6 ? "[%s]:%d" : "%s:%d", host->c_str(), *port);
+ }
+
+ return true;
+}
+
+} // namespace base
+} // namespace android
diff --git a/base/parsenetaddress_test.cpp b/base/parsenetaddress_test.cpp
new file mode 100644
index 0000000..a3bfac8
--- /dev/null
+++ b/base/parsenetaddress_test.cpp
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#include "android-base/parsenetaddress.h"
+
+#include <gtest/gtest.h>
+
+using android::base::ParseNetAddress;
+
+TEST(ParseNetAddressTest, TestUrl) {
+ std::string canonical, host, error;
+ int port = 123;
+
+ EXPECT_TRUE(
+ ParseNetAddress("www.google.com", &host, &port, &canonical, &error));
+ EXPECT_EQ("www.google.com:123", canonical);
+ EXPECT_EQ("www.google.com", host);
+ EXPECT_EQ(123, port);
+
+ EXPECT_TRUE(
+ ParseNetAddress("www.google.com:666", &host, &port, &canonical, &error));
+ EXPECT_EQ("www.google.com:666", canonical);
+ EXPECT_EQ("www.google.com", host);
+ EXPECT_EQ(666, port);
+}
+
+TEST(ParseNetAddressTest, TestIpv4) {
+ std::string canonical, host, error;
+ int port = 123;
+
+ EXPECT_TRUE(ParseNetAddress("1.2.3.4", &host, &port, &canonical, &error));
+ EXPECT_EQ("1.2.3.4:123", canonical);
+ EXPECT_EQ("1.2.3.4", host);
+ EXPECT_EQ(123, port);
+
+ EXPECT_TRUE(ParseNetAddress("1.2.3.4:666", &host, &port, &canonical, &error));
+ EXPECT_EQ("1.2.3.4:666", canonical);
+ EXPECT_EQ("1.2.3.4", host);
+ EXPECT_EQ(666, port);
+}
+
+TEST(ParseNetAddressTest, TestIpv6) {
+ std::string canonical, host, error;
+ int port = 123;
+
+ EXPECT_TRUE(ParseNetAddress("::1", &host, &port, &canonical, &error));
+ EXPECT_EQ("[::1]:123", canonical);
+ EXPECT_EQ("::1", host);
+ EXPECT_EQ(123, port);
+
+ EXPECT_TRUE(ParseNetAddress("fe80::200:5aee:feaa:20a2", &host, &port,
+ &canonical, &error));
+ EXPECT_EQ("[fe80::200:5aee:feaa:20a2]:123", canonical);
+ EXPECT_EQ("fe80::200:5aee:feaa:20a2", host);
+ EXPECT_EQ(123, port);
+
+ EXPECT_TRUE(ParseNetAddress("[::1]:666", &host, &port, &canonical, &error));
+ EXPECT_EQ("[::1]:666", canonical);
+ EXPECT_EQ("::1", host);
+ EXPECT_EQ(666, port);
+
+ EXPECT_TRUE(ParseNetAddress("[fe80::200:5aee:feaa:20a2]:666", &host, &port,
+ &canonical, &error));
+ EXPECT_EQ("[fe80::200:5aee:feaa:20a2]:666", canonical);
+ EXPECT_EQ("fe80::200:5aee:feaa:20a2", host);
+ EXPECT_EQ(666, port);
+}
+
+TEST(ParseNetAddressTest, TestInvalidAddress) {
+ std::string canonical, host;
+ int port;
+
+ std::string failure_cases[] = {
+ // Invalid IPv4.
+ "1.2.3.4:",
+ "1.2.3.4::",
+ ":123",
+
+ // Invalid IPv6.
+ ":1",
+ "::::::::1",
+ "[::1",
+ "[::1]",
+ "[::1]:",
+ "[::1]::",
+
+ // Invalid port.
+ "1.2.3.4:-1",
+ "1.2.3.4:0",
+ "1.2.3.4:65536"
+ "1.2.3.4:hello",
+ "[::1]:-1",
+ "[::1]:0",
+ "[::1]:65536",
+ "[::1]:hello",
+ };
+
+ for (const auto& address : failure_cases) {
+ // Failure should give some non-empty error string.
+ std::string error;
+ EXPECT_FALSE(ParseNetAddress(address, &host, &port, &canonical, &error));
+ EXPECT_NE("", error);
+ }
+}
+
+// Null canonical address argument.
+TEST(ParseNetAddressTest, TestNullCanonicalAddress) {
+ std::string host, error;
+ int port = 42;
+
+ EXPECT_TRUE(ParseNetAddress("www.google.com", &host, &port, nullptr, &error));
+ EXPECT_TRUE(ParseNetAddress("1.2.3.4", &host, &port, nullptr, &error));
+ EXPECT_TRUE(ParseNetAddress("::1", &host, &port, nullptr, &error));
+}
diff --git a/base/utf8_test.cpp b/base/utf8_test.cpp
index dde7490..ae8fc8c 100755
--- a/base/utf8_test.cpp
+++ b/base/utf8_test.cpp
@@ -44,7 +44,7 @@
// specific replacement character that UTF8ToWide() may replace the invalid
// UTF-8 characters with because we want to allow that to change if the
// implementation changes.
- EXPECT_EQ(0, wide.find(L"before"));
+ EXPECT_EQ(0U, wide.find(L"before"));
const wchar_t after_wide[] = L"after";
EXPECT_EQ(wide.length() - (arraysize(after_wide) - 1), wide.find(after_wide));
}
diff --git a/bootstat/Android.mk b/bootstat/Android.mk
new file mode 100644
index 0000000..bbb903d
--- /dev/null
+++ b/bootstat/Android.mk
@@ -0,0 +1,150 @@
+#
+# Copyright (C) 2016 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+bootstat_c_includes := external/gtest/include
+
+bootstat_lib_src_files := \
+ boot_event_record_store.cpp \
+ event_log_list_builder.cpp
+
+bootstat_src_files := \
+ bootstat.cpp
+
+bootstat_test_src_files := \
+ boot_event_record_store_test.cpp \
+ event_log_list_builder_test.cpp \
+ testrunner.cpp
+
+bootstat_shared_libs := \
+ libbase \
+ liblog
+
+bootstat_cflags := \
+ -Wall \
+ -Wextra \
+ -Werror
+
+bootstat_cppflags := \
+ -Wno-non-virtual-dtor
+
+bootstat_debug_cflags := \
+ $(bootstat_cflags) \
+ -UNDEBUG
+
+# 524291 corresponds to sysui_histogram, from
+# frameworks/base/core/java/com/android/internal/logging/EventLogTags.logtags
+bootstat_cflags += -DHISTOGRAM_LOG_TAG=524291
+
+
+# bootstat static library
+# -----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libbootstat
+LOCAL_CFLAGS := $(bootstat_cflags)
+LOCAL_CPPFLAGS := $(bootstat_cppflags)
+LOCAL_C_INCLUDES := $(bootstat_c_includes)
+LOCAL_SHARED_LIBRARIES := $(bootstat_shared_libs)
+LOCAL_SRC_FILES := $(bootstat_lib_src_files)
+# Clang is required because of C++14
+LOCAL_CLANG := true
+
+include $(BUILD_STATIC_LIBRARY)
+
+# bootstat static library, debug
+# -----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libbootstat_debug
+LOCAL_CFLAGS := $(bootstat_cflags)
+LOCAL_CPPFLAGS := $(bootstat_debug_cppflags)
+LOCAL_C_INCLUDES := $(bootstat_c_includes)
+LOCAL_SHARED_LIBRARIES := $(bootstat_shared_libs)
+LOCAL_SRC_FILES := $(bootstat_lib_src_files)
+# Clang is required because of C++14
+LOCAL_CLANG := true
+
+include $(BUILD_STATIC_LIBRARY)
+
+# bootstat host static library, debug
+# -----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libbootstat_host_debug
+LOCAL_CFLAGS := $(bootstat_debug_cflags)
+LOCAL_CPPFLAGS := $(bootstat_cppflags)
+LOCAL_C_INCLUDES := $(bootstat_c_includes)
+LOCAL_SHARED_LIBRARIES := $(bootstat_shared_libs)
+LOCAL_SRC_FILES := $(bootstat_lib_src_files)
+# Clang is required because of C++14
+LOCAL_CLANG := true
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+# bootstat binary
+# -----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := bootstat
+LOCAL_CFLAGS := $(bootstat_cflags)
+LOCAL_CPPFLAGS := $(bootstat_cppflags)
+LOCAL_C_INCLUDES := $(bootstat_c_includes)
+LOCAL_SHARED_LIBRARIES := $(bootstat_shared_libs)
+LOCAL_STATIC_LIBRARIES := libbootstat
+LOCAL_INIT_RC := bootstat.rc
+LOCAL_SRC_FILES := $(bootstat_src_files)
+# Clang is required because of C++14
+LOCAL_CLANG := true
+
+include $(BUILD_EXECUTABLE)
+
+# Native tests
+# -----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := bootstat_tests
+LOCAL_CFLAGS := $(bootstat_tests_cflags)
+LOCAL_CPPFLAGS := $(bootstat_cppflags)
+LOCAL_SHARED_LIBRARIES := $(bootstat_shared_libs)
+LOCAL_STATIC_LIBRARIES := libbootstat_debug libgmock
+LOCAL_SRC_FILES := $(bootstat_test_src_files)
+# Clang is required because of C++14
+LOCAL_CLANG := true
+
+include $(BUILD_NATIVE_TEST)
+
+# Host native tests
+# -----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := bootstat_tests
+LOCAL_CFLAGS := $(bootstat_tests_cflags)
+LOCAL_CPPFLAGS := $(bootstat_cppflags)
+LOCAL_SHARED_LIBRARIES := $(bootstat_shared_libs)
+LOCAL_STATIC_LIBRARIES := libbootstat_host_debug libgmock_host
+LOCAL_SRC_FILES := $(bootstat_test_src_files)
+# Clang is required because of C++14
+LOCAL_CLANG := true
+
+include $(BUILD_HOST_NATIVE_TEST)
diff --git a/bootstat/README.md b/bootstat/README.md
new file mode 100644
index 0000000..1b4bf7f
--- /dev/null
+++ b/bootstat/README.md
@@ -0,0 +1,48 @@
+# bootstat #
+
+The bootstat command records boot events (e.g., `firmware_loaded`,
+`boot_complete`) and the relative time at which these events occurred. The
+command also aggregates boot event metrics locally and logs the metrics for
+analysis.
+
+ Usage: bootstat [options]
+ options include:
+ -d Dump the boot event records to the console.
+ -h Show this help.
+ -l Log all metrics to logstorage.
+ -r Record the relative time of a named boot event.
+
+## Relative time ##
+
+The timestamp recorded by bootstat is the uptime of the system, i.e., the
+number of seconds since the system booted.
+
+## Recording boot events ##
+
+To record the relative time of an event during the boot phase, call `bootstat`
+with the `-r` option and the name of the boot event.
+
+ $ bootstat -r boot_complete
+
+The relative time at which the command runs is recorded along with the name of
+the boot event to be persisted.
+
+## Logging boot events ##
+
+To log the persisted boot events, call `bootstat` with the `-l` option.
+
+ $ bootstat -l
+
+bootstat logs all boot events recorded using the `-r` option to the EventLog
+using the Tron histogram. These logs may be uploaded by interested parties
+for aggregation and analysis of boot time across different devices and
+versions.
+
+## Printing boot events ##
+
+To print the set of persisted boot events, call `bootstat` with the `-p` option.
+
+ $ bootstat -p
+ Boot events:
+ ------------
+ boot_complete 71
\ No newline at end of file
diff --git a/bootstat/boot_event_record_store.cpp b/bootstat/boot_event_record_store.cpp
new file mode 100644
index 0000000..1bdcf2b
--- /dev/null
+++ b/bootstat/boot_event_record_store.cpp
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#include "boot_event_record_store.h"
+
+#include <dirent.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <utime.h>
+#include <cstdlib>
+#include <utility>
+#include <android-base/file.h>
+#include <android-base/logging.h>
+
+namespace {
+
+const char BOOTSTAT_DATA_DIR[] = "/data/misc/bootstat/";
+
+// Given a boot even record file at |path|, extracts the event's relative time
+// from the record into |uptime|.
+bool ParseRecordEventTime(const std::string& path, int32_t* uptime) {
+ DCHECK_NE(static_cast<int32_t*>(nullptr), uptime);
+
+ struct stat file_stat;
+ if (stat(path.c_str(), &file_stat) == -1) {
+ PLOG(ERROR) << "Failed to read " << path;
+ return false;
+ }
+
+ *uptime = file_stat.st_mtime;
+ return true;
+}
+
+} // namespace
+
+BootEventRecordStore::BootEventRecordStore() {
+ SetStorePath(BOOTSTAT_DATA_DIR);
+}
+
+void BootEventRecordStore::AddBootEvent(const std::string& name) {
+ std::string uptime_str;
+ if (!android::base::ReadFileToString("/proc/uptime", &uptime_str)) {
+ LOG(ERROR) << "Failed to read /proc/uptime";
+ }
+
+ std::string record_path = GetBootEventPath(name);
+ if (creat(record_path.c_str(), S_IRUSR | S_IWUSR) == -1) {
+ PLOG(ERROR) << "Failed to create " << record_path;
+ }
+
+ struct stat file_stat;
+ if (stat(record_path.c_str(), &file_stat) == -1) {
+ PLOG(ERROR) << "Failed to read " << record_path;
+ }
+
+ // Cast intentionally rounds down.
+ time_t uptime = static_cast<time_t>(strtod(uptime_str.c_str(), NULL));
+ struct utimbuf times = {file_stat.st_atime, uptime};
+ if (utime(record_path.c_str(), ×) == -1) {
+ PLOG(ERROR) << "Failed to set mtime for " << record_path;
+ }
+}
+
+std::vector<BootEventRecordStore::BootEventRecord> BootEventRecordStore::
+ GetAllBootEvents() const {
+ std::vector<BootEventRecord> events;
+
+ std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(store_path_.c_str()), closedir);
+
+ // This case could happen due to external manipulation of the filesystem,
+ // so crash out if the record store doesn't exist.
+ CHECK_NE(static_cast<DIR*>(nullptr), dir.get());
+
+ struct dirent* entry;
+ while ((entry = readdir(dir.get())) != NULL) {
+ // Only parse regular files.
+ if (entry->d_type != DT_REG) {
+ continue;
+ }
+
+ const std::string event = entry->d_name;
+ const std::string record_path = GetBootEventPath(event);
+ int32_t uptime;
+ if (!ParseRecordEventTime(record_path, &uptime)) {
+ LOG(ERROR) << "Failed to parse boot time record: " << record_path;
+ continue;
+ }
+
+ events.push_back(std::make_pair(event, uptime));
+ }
+
+ return events;
+}
+
+void BootEventRecordStore::SetStorePath(const std::string& path) {
+ DCHECK_EQ('/', path.back());
+ store_path_ = path;
+}
+
+std::string BootEventRecordStore::GetBootEventPath(
+ const std::string& event) const {
+ DCHECK_EQ('/', store_path_.back());
+ return store_path_ + event;
+}
diff --git a/bootstat/boot_event_record_store.h b/bootstat/boot_event_record_store.h
new file mode 100644
index 0000000..77978ef
--- /dev/null
+++ b/bootstat/boot_event_record_store.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#ifndef BOOT_EVENT_RECORD_STORE_H_
+#define BOOT_EVENT_RECORD_STORE_H_
+
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+#include <android-base/macros.h>
+#include <gtest/gtest_prod.h>
+
+// BootEventRecordStore manages the persistence of boot events to the record
+// store and the retrieval of all boot event records from the store.
+class BootEventRecordStore {
+ public:
+ // A BootEventRecord consists of the event name and the timestamp the event
+ // occurred.
+ typedef std::pair<std::string, int32_t> BootEventRecord;
+
+ BootEventRecordStore();
+
+ // Persists the boot event named |name| in the record store.
+ void AddBootEvent(const std::string& name);
+
+ // Returns a list of all of the boot events persisted in the record store.
+ std::vector<BootEventRecord> GetAllBootEvents() const;
+
+ private:
+ // The tests call SetStorePath to override the default store location with a
+ // more test-friendly path.
+ FRIEND_TEST(BootEventRecordStoreTest, AddSingleBootEvent);
+ FRIEND_TEST(BootEventRecordStoreTest, AddMultipleBootEvents);
+
+ // Sets the filesystem path of the record store.
+ void SetStorePath(const std::string& path);
+
+ // Constructs the full path of the given boot |event|.
+ std::string GetBootEventPath(const std::string& event) const;
+
+ // The filesystem path of the record store.
+ std::string store_path_;
+
+ DISALLOW_COPY_AND_ASSIGN(BootEventRecordStore);
+};
+
+#endif // BOOT_EVENT_RECORD_STORE_H_
\ No newline at end of file
diff --git a/bootstat/boot_event_record_store_test.cpp b/bootstat/boot_event_record_store_test.cpp
new file mode 100644
index 0000000..384f84d
--- /dev/null
+++ b/bootstat/boot_event_record_store_test.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#include "boot_event_record_store.h"
+
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <cstdint>
+#include <cstdlib>
+#include <android-base/file.h>
+#include <android-base/test_utils.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+using testing::UnorderedElementsAreArray;
+
+namespace {
+
+// Returns true if the time difference between |a| and |b| is no larger
+// than 10 seconds. This allow for a relatively large fuzz when comparing
+// two timestamps taken back-to-back.
+bool FuzzUptimeEquals(int32_t a, int32_t b) {
+ const int32_t FUZZ_SECONDS = 10;
+ return (abs(a - b) <= FUZZ_SECONDS);
+}
+
+// Returns the uptime as read from /proc/uptime, rounded down to an integer.
+int32_t ReadUptime() {
+ std::string uptime_str;
+ if (!android::base::ReadFileToString("/proc/uptime", &uptime_str)) {
+ return -1;
+ }
+
+ // Cast to int to round down.
+ return static_cast<int32_t>(strtod(uptime_str.c_str(), NULL));
+}
+
+// Recursively deletes the directory at |path|.
+void DeleteDirectory(const std::string& path) {
+ typedef std::unique_ptr<DIR, decltype(&closedir)> ScopedDIR;
+ ScopedDIR dir(opendir(path.c_str()), closedir);
+ ASSERT_NE(nullptr, dir.get());
+
+ struct dirent* entry;
+ while ((entry = readdir(dir.get())) != NULL) {
+ const std::string entry_name(entry->d_name);
+ if (entry_name == "." || entry_name == "..") {
+ continue;
+ }
+
+ const std::string entry_path = path + "/" + entry_name;
+ if (entry->d_type == DT_DIR) {
+ DeleteDirectory(entry_path);
+ } else {
+ unlink(entry_path.c_str());
+ }
+ }
+
+ rmdir(path.c_str());
+}
+
+class BootEventRecordStoreTest : public ::testing::Test {
+ public:
+ BootEventRecordStoreTest() {
+ store_path_ = std::string(store_dir_.path) + "/";
+ }
+
+ const std::string& GetStorePathForTesting() const {
+ return store_path_;
+ }
+
+ private:
+ void TearDown() {
+ // This removes the record store temporary directory even though
+ // TemporaryDir should already take care of it, but this method cleans up
+ // the test files added to the directory which prevent TemporaryDir from
+ // being able to remove the directory.
+ DeleteDirectory(store_path_);
+ }
+
+ // A scoped temporary directory. Using this abstraction provides creation of
+ // the directory and the path to the directory, which is stored in
+ // |store_path_|.
+ TemporaryDir store_dir_;
+
+ // The path to the temporary directory used by the BootEventRecordStore to
+ // persist records. The directory is created and destroyed for each test.
+ std::string store_path_;
+
+ DISALLOW_COPY_AND_ASSIGN(BootEventRecordStoreTest);
+};
+
+} // namespace
+
+TEST_F(BootEventRecordStoreTest, AddSingleBootEvent) {
+ BootEventRecordStore store;
+ store.SetStorePath(GetStorePathForTesting());
+
+ int32_t uptime = ReadUptime();
+ ASSERT_NE(-1, uptime);
+
+ store.AddBootEvent("cenozoic");
+
+ auto events = store.GetAllBootEvents();
+ ASSERT_EQ(1U, events.size());
+ EXPECT_EQ("cenozoic", events[0].first);
+ EXPECT_TRUE(FuzzUptimeEquals(uptime, events[0].second));
+}
+
+TEST_F(BootEventRecordStoreTest, AddMultipleBootEvents) {
+ BootEventRecordStore store;
+ store.SetStorePath(GetStorePathForTesting());
+
+ int32_t uptime = ReadUptime();
+ ASSERT_NE(-1, uptime);
+
+ store.AddBootEvent("cretaceous");
+ store.AddBootEvent("jurassic");
+ store.AddBootEvent("triassic");
+
+ const std::string EXPECTED_NAMES[] = {
+ "cretaceous",
+ "jurassic",
+ "triassic",
+ };
+
+ auto events = store.GetAllBootEvents();
+ ASSERT_EQ(3U, events.size());
+
+ std::vector<std::string> names;
+ std::vector<int32_t> timestamps;
+ for (auto i = events.begin(); i != events.end(); ++i) {
+ names.push_back(i->first);
+ timestamps.push_back(i->second);
+ }
+
+ EXPECT_THAT(names, UnorderedElementsAreArray(EXPECTED_NAMES));
+
+ for (auto i = timestamps.cbegin(); i != timestamps.cend(); ++i) {
+ EXPECT_TRUE(FuzzUptimeEquals(uptime, *i));
+ }
+}
diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
new file mode 100644
index 0000000..a83f8ad
--- /dev/null
+++ b/bootstat/bootstat.cpp
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+// The bootstat command provides options to persist boot events with the current
+// timestamp, dump the persisted events, and log all events to EventLog to be
+// uploaded to Android log storage via Tron.
+
+//#define LOG_TAG "bootstat"
+
+#include <unistd.h>
+#include <cstddef>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <android-base/logging.h>
+#include <log/log.h>
+#include "boot_event_record_store.h"
+#include "event_log_list_builder.h"
+
+namespace {
+
+// Builds an EventLog buffer named |event| containing |data| and writes
+// the log into the Tron histogram logs.
+void LogBootEvent(const std::string& event, int32_t data) {
+ LOG(INFO) << "Logging boot time: " << event << " " << data;
+
+ EventLogListBuilder log_builder;
+ log_builder.Append(event);
+ log_builder.Append(data);
+
+ std::unique_ptr<uint8_t[]> log;
+ size_t size;
+ log_builder.Release(&log, &size);
+
+ android_bWriteLog(HISTOGRAM_LOG_TAG, log.get(), size);
+}
+
+// Scans the boot event record store for record files and logs each boot event
+// via EventLog.
+void LogBootEvents() {
+ BootEventRecordStore boot_event_store;
+
+ auto events = boot_event_store.GetAllBootEvents();
+ for (auto i = events.cbegin(); i != events.cend(); ++i) {
+ LogBootEvent(i->first, i->second);
+ }
+}
+
+void PrintBootEvents() {
+ printf("Boot events:\n");
+ printf("------------\n");
+
+ BootEventRecordStore boot_event_store;
+ auto events = boot_event_store.GetAllBootEvents();
+ for (auto i = events.cbegin(); i != events.cend(); ++i) {
+ printf("%s\t%d\n", i->first.c_str(), i->second);
+ }
+}
+
+void ShowHelp(const char *cmd) {
+ fprintf(stderr, "Usage: %s [options]\n", cmd);
+ fprintf(stderr,
+ "options include:\n"
+ " -d Dump the boot event records to the console.\n"
+ " -h Show this help.\n"
+ " -l Log all metrics to logstorage.\n"
+ " -r Record the timestamp of a named boot event.\n");
+}
+
+// Constructs a readable, printable string from the givencommand line
+// arguments.
+std::string GetCommandLine(int argc, char **argv) {
+ std::string cmd;
+ for (int i = 0; i < argc; ++i) {
+ cmd += argv[i];
+ cmd += " ";
+ }
+
+ return cmd;
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+ android::base::InitLogging(argv);
+
+ const std::string cmd_line = GetCommandLine(argc, argv);
+ LOG(INFO) << "Service started: " << cmd_line;
+
+ int opt = 0;
+ while ((opt = getopt(argc, argv, "hlpr:")) != -1) {
+ switch (opt) {
+ case 'h': {
+ ShowHelp(argv[0]);
+ break;
+ }
+
+ case 'l': {
+ LogBootEvents();
+ break;
+ }
+
+ case 'p': {
+ PrintBootEvents();
+ break;
+ }
+
+ case 'r': {
+ // |optarg| is an external variable set by getopt representing
+ // the option argument.
+ const char* event = optarg;
+
+ BootEventRecordStore boot_event_store;
+ boot_event_store.AddBootEvent(event);
+ break;
+ }
+
+ default: {
+ DCHECK_EQ(opt, '?');
+
+ // |optopt| is an external variable set by getopt representing
+ // the value of the invalid option.
+ LOG(ERROR) << "Invalid option: " << optopt;
+ ShowHelp(argv[0]);
+ return EXIT_FAILURE;
+ }
+ }
+ }
+
+ return 0;
+}
diff --git a/bootstat/bootstat.rc b/bootstat/bootstat.rc
new file mode 100644
index 0000000..2c37dd2
--- /dev/null
+++ b/bootstat/bootstat.rc
@@ -0,0 +1,14 @@
+# This file is the LOCAL_INIT_RC file for the bootstat command.
+
+on post-fs-data
+ mkdir /data/misc/bootstat 0700 root root
+
+# This marker, boot animation stopped, is considered the point at which the
+# the user may interact with the device, so it is a good proxy for the boot
+# complete signal.
+on property:init.svc.bootanim=stopped
+ # Record boot_complete timing event.
+ exec - root root -- /system/bin/bootstat -r boot_complete
+
+ # Log all boot events.
+ exec - root root -- /system/bin/bootstat -l
diff --git a/bootstat/event_log_list_builder.cpp b/bootstat/event_log_list_builder.cpp
new file mode 100644
index 0000000..241e3d5
--- /dev/null
+++ b/bootstat/event_log_list_builder.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#include "event_log_list_builder.h"
+
+#include <cinttypes>
+#include <memory>
+#include <string>
+#include <android-base/logging.h>
+#include <log/log.h>
+
+namespace {
+
+const size_t MAX_EVENT_PAYLOAD_SIZE = 512 - 1; // Leave room for final '\n'.
+const size_t EVENT_TYPE_SIZE = 1; // Size in bytes of the event type marker.
+
+} // namespace
+
+EventLogListBuilder::EventLogListBuilder()
+ : payload_count_(0),
+ payload_size_(0),
+ payload_(std::make_unique<uint8_t[]>(MAX_EVENT_PAYLOAD_SIZE)) {
+ memset(payload_.get(), 0, MAX_EVENT_PAYLOAD_SIZE);
+
+ // Set up the top-level EventLog data type.
+ AppendByte(EVENT_TYPE_LIST);
+
+ // Skip over the byte prepresenting the number of items in the list. This
+ // value is set in Release().
+ payload_size_++;
+}
+
+bool EventLogListBuilder::Append(int value) {
+ DCHECK_NE(static_cast<uint8_t*>(nullptr), payload_.get());
+
+ if (!IsSpaceAvailable(sizeof(value) + EVENT_TYPE_SIZE)) {
+ return false;
+ }
+
+ AppendByte(EVENT_TYPE_INT);
+ AppendData(&value, sizeof(value));
+
+ payload_count_++;
+ return true;
+}
+
+bool EventLogListBuilder::Append(const std::string& value) {
+ DCHECK_NE(static_cast<uint8_t*>(nullptr), payload_.get());
+
+ int len = value.length();
+ if (!IsSpaceAvailable(sizeof(len) + len)) {
+ return false;
+ }
+
+ AppendByte(EVENT_TYPE_STRING);
+ AppendData(&len, sizeof(len));
+ AppendData(value.c_str(), len);
+
+ payload_count_++;
+ return true;
+}
+
+void EventLogListBuilder::Release(std::unique_ptr<uint8_t[]>* log,
+ size_t* size) {
+ // Finalize the log payload.
+ payload_[1] = payload_count_;
+
+ // Return the log payload.
+ *size = payload_size_;
+ *log = std::move(payload_);
+}
+
+void EventLogListBuilder::AppendData(const void* data, size_t size) {
+ DCHECK_LT(payload_size_ + size, MAX_EVENT_PAYLOAD_SIZE);
+ memcpy(&payload_[payload_size_], data, size);
+ payload_size_ += size;
+}
+
+void EventLogListBuilder::AppendByte(uint8_t byte) {
+ DCHECK_LT(payload_size_ + sizeof(byte), MAX_EVENT_PAYLOAD_SIZE);
+ payload_[payload_size_++] = byte;
+}
+
+bool EventLogListBuilder::IsSpaceAvailable(size_t value_size) {
+ size_t space_needed = value_size + EVENT_TYPE_SIZE;
+ if (payload_size_ + space_needed > MAX_EVENT_PAYLOAD_SIZE) {
+ size_t remaining = MAX_EVENT_PAYLOAD_SIZE - payload_size_;
+ LOG(WARNING) << "Not enough space for value. remain=" <<
+ remaining << "; needed=" << space_needed;
+ return false;
+ }
+
+ return true;
+}
diff --git a/bootstat/event_log_list_builder.h b/bootstat/event_log_list_builder.h
new file mode 100644
index 0000000..4e29b01
--- /dev/null
+++ b/bootstat/event_log_list_builder.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#ifndef EVENT_LOG_LIST_BUILDER_H_
+#define EVENT_LOG_LIST_BUILDER_H_
+
+#include <cstdint>
+#include <memory>
+
+#include <android-base/macros.h>
+
+// EventLogListBuilder provides a mechanism to build an EventLog list
+// consisting of int and string EventLog values.
+//
+// NOTE: This class does not provide the ability to append an embedded list,
+// i.e., a list containing a list.
+class EventLogListBuilder {
+ public:
+ EventLogListBuilder();
+
+ // Append a single value of a specified type.
+ bool Append(int value);
+ bool Append(const std::string& value);
+
+ // Finalizes construction of the EventLog list and releases the data
+ // to the caller. Caller takes ownership of the payload. No further calls
+ // to append* may be made once the payload is acquired by the caller.
+ void Release(std::unique_ptr<uint8_t[]>* log, size_t* size);
+
+ private:
+ // Appends |data| of the given |size| to the payload.
+ void AppendData(const void* data, size_t size);
+
+ // Appends a single byte to the payload.
+ void AppendByte(uint8_t byte);
+
+ // Returns true iff the remaining capacity in |payload_| is large enough to
+ // accommodate |value_size| bytes. The space required to log the event type
+ // is included in the internal calculation so must not be passed in to
+ // |value_size|.
+ bool IsSpaceAvailable(size_t value_size);
+
+ // The number of items in the EventLog list.
+ size_t payload_count_;
+
+ // The size of the data stored in |payload_|. Used to track where to insert
+ // new data.
+ size_t payload_size_;
+
+ // The payload constructed by calls to log*. The payload may only contain
+ // MAX_EVENT_PAYLOAD (512) bytes.
+ std::unique_ptr<uint8_t[]> payload_;
+
+ DISALLOW_COPY_AND_ASSIGN(EventLogListBuilder);
+};
+
+ #endif // EVENT_LOG_LIST_BUILDER_H_
diff --git a/bootstat/event_log_list_builder_test.cpp b/bootstat/event_log_list_builder_test.cpp
new file mode 100644
index 0000000..affb4bf
--- /dev/null
+++ b/bootstat/event_log_list_builder_test.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#include "event_log_list_builder.h"
+
+#include <inttypes.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <log/log.h>
+
+using testing::ElementsAreArray;
+
+TEST(EventLogListBuilder, Empty) {
+ EventLogListBuilder builder;
+
+ const uint8_t EXPECTED_LOG[] = {
+ EVENT_TYPE_LIST,
+ 0, // Number of items in the list.
+ };
+
+ std::unique_ptr<uint8_t[]> log;
+ size_t size;
+ builder.Release(&log, &size);
+ EXPECT_EQ(2U, size);
+
+ uint8_t* log_data = log.get();
+ EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size),
+ ElementsAreArray(EXPECTED_LOG));
+}
+
+TEST(EventLogListBuilder, SingleInt) {
+ EventLogListBuilder builder;
+
+ const uint8_t EXPECTED_LOG[] = {
+ EVENT_TYPE_LIST,
+ 1, // Number of items in the list.
+ EVENT_TYPE_INT,
+ 42, 0, 0, 0, // 4 byte integer value.
+ };
+
+ builder.Append(42);
+
+ std::unique_ptr<uint8_t[]> log;
+ size_t size;
+ builder.Release(&log, &size);
+ EXPECT_EQ(7U, size);
+
+ uint8_t* log_data = log.get();
+ EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size),
+ ElementsAreArray(EXPECTED_LOG));
+}
+
+TEST(EventLogListBuilder, SingleString) {
+ EventLogListBuilder builder;
+
+ const uint8_t EXPECTED_LOG[] = {
+ EVENT_TYPE_LIST,
+ 1, // Number of items in the list.
+ EVENT_TYPE_STRING,
+ 5, 0, 0, 0, // 4 byte length of the string.
+ 'D', 'r', 'o', 'i', 'd',
+ };
+
+ builder.Append("Droid");
+
+ std::unique_ptr<uint8_t[]> log;
+ size_t size;
+ builder.Release(&log, &size);
+ EXPECT_EQ(12U, size);
+
+ uint8_t* log_data = log.get();
+ EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size),
+ ElementsAreArray(EXPECTED_LOG));
+}
+
+TEST(EventLogListBuilder, IntThenString) {
+ EventLogListBuilder builder;
+
+ const uint8_t EXPECTED_LOG[] = {
+ EVENT_TYPE_LIST,
+ 2, // Number of items in the list.
+ EVENT_TYPE_INT,
+ 42, 0, 0, 0, // 4 byte integer value.
+ EVENT_TYPE_STRING,
+ 5, 0, 0, 0, // 4 byte length of the string.
+ 'D', 'r', 'o', 'i', 'd',
+ };
+
+ builder.Append(42);
+ builder.Append("Droid");
+
+ std::unique_ptr<uint8_t[]> log;
+ size_t size;
+ builder.Release(&log, &size);
+ EXPECT_EQ(17U, size);
+
+ uint8_t* log_data = log.get();
+ EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size),
+ ElementsAreArray(EXPECTED_LOG));
+}
diff --git a/bootstat/testrunner.cpp b/bootstat/testrunner.cpp
new file mode 100644
index 0000000..79b61d1
--- /dev/null
+++ b/bootstat/testrunner.cpp
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#include <android-base/logging.h>
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+ ::testing::InitGoogleTest(&argc, argv);
+ android::base::InitLogging(argv, android::base::StderrLogger);
+ return RUN_ALL_TESTS();
+}
diff --git a/crash_reporter/Android.mk b/crash_reporter/Android.mk
index bc023b0..fa564b2 100644
--- a/crash_reporter/Android.mk
+++ b/crash_reporter/Android.mk
@@ -19,7 +19,6 @@
crash_reporter_src := crash_collector.cc \
kernel_collector.cc \
kernel_warning_collector.cc \
- udev_collector.cc \
unclean_shutdown_collector.cc \
user_collector.cc
@@ -29,7 +28,6 @@
crash_reporter_logs_test.cc \
kernel_collector_test.cc \
testrunner.cc \
- udev_collector_test.cc \
unclean_shutdown_collector_test.cc \
user_collector_test.cc
@@ -137,6 +135,9 @@
include $(CLEAR_VARS)
LOCAL_MODULE := crash_reporter_tests
LOCAL_CPP_EXTENSION := $(crash_reporter_cpp_extension)
+ifdef BRILLO
+LOCAL_MODULE_TAGS := debug
+endif
LOCAL_SHARED_LIBRARIES := libchrome \
libbrillo \
libcutils \
diff --git a/crash_reporter/README.md b/crash_reporter/README.md
new file mode 100644
index 0000000..9ac0a86
--- /dev/null
+++ b/crash_reporter/README.md
@@ -0,0 +1,61 @@
+# crash_reporter
+
+`crash_reporter` is a deamon running on the device that saves the call stack of
+crashing programs. It makes use of the
+[Breakpad](https://chromium.googlesource.com/breakpad/breakpad/) library.
+
+During a build, Breakpad symbol files are generated for all binaries. They are
+packaged into a zip file when running `m dist`, so that a developer can upload
+them to the crash server.
+
+On a device, if the user has opted in to metrics and crash reporting, a
+Breakpad minidump is generated when an executable crashes, which is then
+uploaded to the crash server.
+
+On the crash server, it compares the minidump's signature to the symbol files
+that the developer has uploaded, and extracts and symbolizes the stack trace
+from the minidump.
+
+## SELinux policies
+
+In order to correctly generate a minidump, `crash_reporter` needs to be given
+the proper SELinux permissions for accessing the domain of the crashing
+executable. By default, `crash_reporter` has only been given access to a select
+number of system domains, such as `metricsd`, `weave`, and `update_engine`. If
+a developer wants their executable's crashes to be caught by `crash_reporter`,
+they will have to set their SELinux policies in their .te file to allow
+`crash_reporter` access to their domain. This can be done through a simple
+[macro](https://android.googlesource.com/device/generic/brillo/+/master/sepolicy/te_macros):
+
+ allow_crash_reporter(domain_name)
+
+Replace *domain_name* with whatever domain is assigned to the executable in
+the `file_contexts` file.
+
+## Configuration
+
+`crash_reporter` has a few different configuration options that have to be set.
+
+- Crashes are only handled and uploaded if analytics reporting is enabled,
+ either via the weave call to set `_metrics.enableAnalyticsReporting` or by
+ manually creating the file `/data/misc/metrics/enabled` (for testing only).
+- The `BRILLO_CRASH_SERVER` make variable should be set in the `product.mk`
+ file to the URL of the crash server. For Brillo builds, it is set
+ automatically through the product configuration. Setting this variable will
+ populate the `/etc/os-release.d/crash_server` file on the device, which is
+ read by `crash_sender`.
+- The `BRILLO_PRODUCT_ID` make variable should be set in the `product.mk` file
+ to the product's ID. For Brillo builds, it is set automatically through the
+ product configuration. Setting this variable will populate the
+ `/etc/os-release.d/product_id`, which is read by `crash_sender`.
+
+## Uploading crash reports in *eng* builds
+
+By default, crash reports are only uploaded to the server for production
+*user* and *userdebug* images. In *eng* builds, with crash reporting enabled
+the device will generate minidumps for any crashing executables but will not
+send them to the crash server. If a developer does want to force an upload,
+they can do so by issuing the command `SECONDS_SEND_SPREAD=5 FORCE_OFFICIAL=1
+crash_sender` from an ADB shell. This will send the report to the server, with
+the *image_type* field set to *force-official* so that these reports can be
+differentiated from normal reports.
diff --git a/crash_reporter/crash_collector_test.cc b/crash_reporter/crash_collector_test.cc
index b55c324..11c8c0d 100644
--- a/crash_reporter/crash_collector_test.cc
+++ b/crash_reporter/crash_collector_test.cc
@@ -20,6 +20,7 @@
#include <utility>
#include <base/files/file_util.h>
+#include <base/files/scoped_temp_dir.h>
#include <base/strings/string_util.h>
#include <base/strings/stringprintf.h>
#include <brillo/syslog_logging.h>
@@ -52,20 +53,17 @@
EXPECT_CALL(collector_, SetUpDBus()).WillRepeatedly(Return());
collector_.Initialize(CountCrash, IsMetrics);
- test_dir_ = FilePath("test");
- base::CreateDirectory(test_dir_);
+ EXPECT_TRUE(test_dir_.CreateUniqueTempDir());
brillo::ClearLog();
}
- void TearDown() {
- base::DeleteFile(test_dir_, true);
- }
-
bool CheckHasCapacity();
protected:
CrashCollectorMock collector_;
- FilePath test_dir_;
+
+ // Temporary directory used for tests.
+ base::ScopedTempDir test_dir_;
};
TEST_F(CrashCollectorTest, Initialize) {
@@ -74,7 +72,7 @@
}
TEST_F(CrashCollectorTest, WriteNewFile) {
- FilePath test_file = test_dir_.Append("test_new");
+ FilePath test_file = test_dir_.path().Append("test_new");
const char kBuffer[] = "buffer";
EXPECT_EQ(strlen(kBuffer),
collector_.WriteNewFile(test_file,
@@ -122,8 +120,10 @@
bool CrashCollectorTest::CheckHasCapacity() {
- static const char kFullMessage[] = "Crash directory test already full";
- bool has_capacity = collector_.CheckHasCapacity(test_dir_);
+ const char* kFullMessage =
+ StringPrintf("Crash directory %s already full",
+ test_dir_.path().value().c_str()).c_str();
+ bool has_capacity = collector_.CheckHasCapacity(test_dir_.path());
bool has_message = FindLog(kFullMessage);
EXPECT_EQ(has_message, !has_capacity);
return has_capacity;
@@ -132,19 +132,22 @@
TEST_F(CrashCollectorTest, CheckHasCapacityUsual) {
// Test kMaxCrashDirectorySize - 1 non-meta files can be added.
for (int i = 0; i < CrashCollector::kMaxCrashDirectorySize - 1; ++i) {
- base::WriteFile(test_dir_.Append(StringPrintf("file%d.core", i)), "", 0);
+ base::WriteFile(test_dir_.path().Append(StringPrintf("file%d.core", i)),
+ "", 0);
EXPECT_TRUE(CheckHasCapacity());
}
// Test an additional kMaxCrashDirectorySize - 1 meta files fit.
for (int i = 0; i < CrashCollector::kMaxCrashDirectorySize - 1; ++i) {
- base::WriteFile(test_dir_.Append(StringPrintf("file%d.meta", i)), "", 0);
+ base::WriteFile(test_dir_.path().Append(StringPrintf("file%d.meta", i)),
+ "", 0);
EXPECT_TRUE(CheckHasCapacity());
}
// Test an additional kMaxCrashDirectorySize meta files don't fit.
for (int i = 0; i < CrashCollector::kMaxCrashDirectorySize; ++i) {
- base::WriteFile(test_dir_.Append(StringPrintf("overage%d.meta", i)), "", 0);
+ base::WriteFile(test_dir_.path().Append(StringPrintf("overage%d.meta", i)),
+ "", 0);
EXPECT_FALSE(CheckHasCapacity());
}
}
@@ -152,50 +155,52 @@
TEST_F(CrashCollectorTest, CheckHasCapacityCorrectBasename) {
// Test kMaxCrashDirectorySize - 1 files can be added.
for (int i = 0; i < CrashCollector::kMaxCrashDirectorySize - 1; ++i) {
- base::WriteFile(test_dir_.Append(StringPrintf("file.%d.core", i)), "", 0);
+ base::WriteFile(test_dir_.path().Append(StringPrintf("file.%d.core", i)),
+ "", 0);
EXPECT_TRUE(CheckHasCapacity());
}
- base::WriteFile(test_dir_.Append("file.last.core"), "", 0);
+ base::WriteFile(test_dir_.path().Append("file.last.core"), "", 0);
EXPECT_FALSE(CheckHasCapacity());
}
TEST_F(CrashCollectorTest, CheckHasCapacityStrangeNames) {
// Test many files with different extensions and same base fit.
for (int i = 0; i < 5 * CrashCollector::kMaxCrashDirectorySize; ++i) {
- base::WriteFile(test_dir_.Append(StringPrintf("a.%d", i)), "", 0);
+ base::WriteFile(test_dir_.path().Append(StringPrintf("a.%d", i)), "", 0);
EXPECT_TRUE(CheckHasCapacity());
}
// Test dot files are treated as individual files.
for (int i = 0; i < CrashCollector::kMaxCrashDirectorySize - 2; ++i) {
- base::WriteFile(test_dir_.Append(StringPrintf(".file%d", i)), "", 0);
+ base::WriteFile(test_dir_.path().Append(StringPrintf(".file%d", i)), "", 0);
EXPECT_TRUE(CheckHasCapacity());
}
- base::WriteFile(test_dir_.Append("normal.meta"), "", 0);
+ base::WriteFile(test_dir_.path().Append("normal.meta"), "", 0);
EXPECT_FALSE(CheckHasCapacity());
}
TEST_F(CrashCollectorTest, MetaData) {
const char kMetaFileBasename[] = "generated.meta";
- FilePath meta_file = test_dir_.Append(kMetaFileBasename);
- FilePath payload_file = test_dir_.Append("payload-file");
+ FilePath meta_file = test_dir_.path().Append(kMetaFileBasename);
+ FilePath payload_file = test_dir_.path().Append("payload-file");
std::string contents;
const char kPayload[] = "foo";
ASSERT_TRUE(base::WriteFile(payload_file, kPayload, strlen(kPayload)));
collector_.AddCrashMetaData("foo", "bar");
collector_.WriteCrashMetaData(meta_file, "kernel", payload_file.value());
EXPECT_TRUE(base::ReadFileToString(meta_file, &contents));
- const char kExpectedMeta[] =
- "foo=bar\n"
- "exec_name=kernel\n"
- "payload=test/payload-file\n"
- "payload_size=3\n"
- "done=1\n";
+ const std::string kExpectedMeta =
+ StringPrintf("foo=bar\n"
+ "exec_name=kernel\n"
+ "payload=%s\n"
+ "payload_size=3\n"
+ "done=1\n",
+ test_dir_.path().Append("payload-file").value().c_str());
EXPECT_EQ(kExpectedMeta, contents);
// Test target of symlink is not overwritten.
- payload_file = test_dir_.Append("payload2-file");
+ payload_file = test_dir_.path().Append("payload2-file");
ASSERT_TRUE(base::WriteFile(payload_file, kPayload, strlen(kPayload)));
- FilePath meta_symlink_path = test_dir_.Append("symlink.meta");
+ FilePath meta_symlink_path = test_dir_.path().Append("symlink.meta");
ASSERT_EQ(0,
symlink(kMetaFileBasename,
meta_symlink_path.value().c_str()));
@@ -221,8 +226,8 @@
}
TEST_F(CrashCollectorTest, GetLogContents) {
- FilePath config_file = test_dir_.Append("crash_config");
- FilePath output_file = test_dir_.Append("crash_log");
+ FilePath config_file = test_dir_.path().Append("crash_config");
+ FilePath output_file = test_dir_.path().Append("crash_log");
const char kConfigContents[] =
"foobar=echo hello there | \\\n sed -e \"s/there/world/\"";
ASSERT_TRUE(
diff --git a/crash_reporter/crash_reporter.cc b/crash_reporter/crash_reporter.cc
index 26ffa38..b69492a 100644
--- a/crash_reporter/crash_reporter.cc
+++ b/crash_reporter/crash_reporter.cc
@@ -35,10 +35,13 @@
#include "kernel_collector.h"
#include "kernel_warning_collector.h"
-#include "udev_collector.h"
#include "unclean_shutdown_collector.h"
#include "user_collector.h"
+#if !defined(__ANDROID__)
+#include "udev_collector.h"
+#endif
+
static const char kCrashCounterHistogram[] = "Logging.CrashCounter";
static const char kKernelCrashDetected[] = "/var/run/kernel-crash-detected";
static const char kUncleanShutdownDetected[] =
@@ -176,6 +179,7 @@
return 0;
}
+#if !defined(__ANDROID__)
static int HandleUdevCrash(UdevCollector *udev_collector,
const std::string& udev_event) {
// Handle a crash indicated by a udev event.
@@ -189,6 +193,7 @@
return 1;
return 0;
}
+#endif
static int HandleKernelWarning(KernelWarningCollector
*kernel_warning_collector) {
@@ -249,7 +254,11 @@
DEFINE_bool(crash_test, false, "Crash test");
DEFINE_string(user, "", "User crash info (pid:signal:exec_name)");
DEFINE_bool(unclean_check, true, "Check for unclean shutdown");
+
+#if !defined(__ANDROID__)
DEFINE_string(udev, "", "Udev event description (type:device:subsystem)");
+#endif
+
DEFINE_bool(kernel_warning, false, "Report collected kernel warning");
DEFINE_string(pid, "", "PID of crashing process");
DEFINE_string(uid, "", "UID of crashing process");
@@ -279,8 +288,11 @@
UncleanShutdownCollector unclean_shutdown_collector;
unclean_shutdown_collector.Initialize(CountUncleanShutdown,
IsFeedbackAllowed);
+
+#if !defined(__ANDROID__)
UdevCollector udev_collector;
udev_collector.Initialize(CountUdevCrash, IsFeedbackAllowed);
+#endif
KernelWarningCollector kernel_warning_collector;
kernel_warning_collector.Initialize(CountUdevCrash, IsFeedbackAllowed);
@@ -304,9 +316,11 @@
FLAGS_generate_kernel_signature);
}
+#if !defined(__ANDROID__)
if (!FLAGS_udev.empty()) {
return HandleUdevCrash(&udev_collector, FLAGS_udev);
}
+#endif
if (FLAGS_kernel_warning) {
return HandleKernelWarning(&kernel_warning_collector);
diff --git a/crash_reporter/kernel_collector.cc b/crash_reporter/kernel_collector.cc
index 12b00b9..cb3a315 100644
--- a/crash_reporter/kernel_collector.cc
+++ b/crash_reporter/kernel_collector.cc
@@ -68,8 +68,8 @@
" RIP \\[<.*>\\] ([^\\+ ]+).*", // X86_64 uses RIP for the program counter
};
-COMPILE_ASSERT(arraysize(kPCRegex) == KernelCollector::kArchCount,
- missing_arch_pc_regexp);
+static_assert(arraysize(kPCRegex) == KernelCollector::kArchCount,
+ "Missing Arch PC regexp");
} // namespace
diff --git a/crash_reporter/list_proxies.cc b/crash_reporter/list_proxies.cc
index d445557..3374b5f 100644
--- a/crash_reporter/list_proxies.cc
+++ b/crash_reporter/list_proxies.cc
@@ -75,13 +75,12 @@
// Start by finding the first space (if any).
std::string::iterator space;
for (space = token.begin(); space != token.end(); ++space) {
- if (IsAsciiWhitespace(*space)) {
+ if (base::IsAsciiWhitespace(*space)) {
break;
}
}
- std::string scheme = std::string(token.begin(), space);
- base::StringToLowerASCII(&scheme);
+ std::string scheme = base::ToLowerASCII(std::string(token.begin(), space));
// Chrome uses "socks" to mean socks4 and "proxy" to mean http.
if (scheme == "socks")
scheme += "4";
@@ -183,7 +182,7 @@
timeout_callback_.Cancel();
proxies_ = ParseProxyString(proxy_info);
LOG(INFO) << "Found proxies via browser signal: "
- << JoinString(proxies_, 'x');
+ << base::JoinString(proxies_, "x");
Quit();
}
diff --git a/crash_reporter/unclean_shutdown_collector_test.cc b/crash_reporter/unclean_shutdown_collector_test.cc
index 3bdeca1..56d2704 100644
--- a/crash_reporter/unclean_shutdown_collector_test.cc
+++ b/crash_reporter/unclean_shutdown_collector_test.cc
@@ -19,6 +19,7 @@
#include <unistd.h>
#include <base/files/file_util.h>
+#include <base/files/scoped_temp_dir.h>
#include <base/strings/string_util.h>
#include <brillo/syslog_logging.h>
#include <gmock/gmock.h>
@@ -32,10 +33,6 @@
int s_crashes = 0;
bool s_metrics = true;
-const char kTestDirectory[] = "test";
-const char kTestSuspended[] = "test/suspended";
-const char kTestUnclean[] = "test/unclean";
-
void CountCrash() {
++s_crashes;
}
@@ -59,12 +56,17 @@
collector_.Initialize(CountCrash,
IsMetrics);
- rmdir(kTestDirectory);
- test_unclean_ = FilePath(kTestUnclean);
- collector_.unclean_shutdown_file_ = kTestUnclean;
+
+ EXPECT_TRUE(test_dir_.CreateUniqueTempDir());
+
+ test_directory_ = test_dir_.path().Append("test");
+ test_unclean_ = test_dir_.path().Append("test/unclean");
+
+ collector_.unclean_shutdown_file_ = test_unclean_.value().c_str();
base::DeleteFile(test_unclean_, true);
// Set up an alternate power manager state file as well
- collector_.powerd_suspended_file_ = FilePath(kTestSuspended);
+ collector_.powerd_suspended_file_ =
+ test_dir_.path().Append("test/suspended");
brillo::ClearLog();
}
@@ -75,6 +77,10 @@
}
UncleanShutdownCollectorMock collector_;
+
+ // Temporary directory used for tests.
+ base::ScopedTempDir test_dir_;
+ FilePath test_directory_;
FilePath test_unclean_;
};
@@ -84,7 +90,7 @@
}
TEST_F(UncleanShutdownCollectorTest, EnableWithParent) {
- mkdir(kTestDirectory, 0777);
+ mkdir(test_directory_.value().c_str(), 0777);
ASSERT_TRUE(collector_.Enable());
ASSERT_TRUE(base::PathExists(test_unclean_));
}
@@ -133,15 +139,15 @@
}
TEST_F(UncleanShutdownCollectorTest, CantDisable) {
- mkdir(kTestDirectory, 0700);
- if (mkdir(kTestUnclean, 0700)) {
+ mkdir(test_directory_.value().c_str(), 0700);
+ if (mkdir(test_unclean_.value().c_str(), 0700)) {
ASSERT_EQ(EEXIST, errno)
- << "Error while creating directory '" << kTestUnclean
+ << "Error while creating directory '" << test_unclean_.value()
<< "': " << strerror(errno);
}
ASSERT_EQ(0, base::WriteFile(test_unclean_.Append("foo"), "", 0))
<< "Error while creating empty file '"
<< test_unclean_.Append("foo").value() << "': " << strerror(errno);
ASSERT_FALSE(collector_.Disable());
- rmdir(kTestUnclean);
+ rmdir(test_unclean_.value().c_str());
}
diff --git a/crash_reporter/user_collector.cc b/crash_reporter/user_collector.cc
index 6714f52..98d7448 100644
--- a/crash_reporter/user_collector.cc
+++ b/crash_reporter/user_collector.cc
@@ -151,8 +151,8 @@
return false;
}
std::string id_substring = id_line.substr(strlen(prefix), std::string::npos);
- std::vector<std::string> ids;
- base::SplitString(id_substring, '\t', &ids);
+ std::vector<std::string> ids = base::SplitString(
+ id_substring, "\t", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
if (ids.size() != kIdMax || kind < 0 || kind >= kIdMax) {
return false;
}
@@ -313,8 +313,8 @@
uid_t uid;
if (base::ReadFileToString(process_path.Append("status"), &status)) {
- std::vector<std::string> status_lines;
- base::SplitString(status, '\n', &status_lines);
+ std::vector<std::string> status_lines = base::SplitString(
+ status, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
std::string process_state;
if (!GetStateFromStatus(status_lines, &process_state)) {
diff --git a/crash_reporter/user_collector_test.cc b/crash_reporter/user_collector_test.cc
index 638ea34..d9c9a5b 100644
--- a/crash_reporter/user_collector_test.cc
+++ b/crash_reporter/user_collector_test.cc
@@ -65,8 +65,10 @@
false,
false,
"");
- base::DeleteFile(FilePath("test"), true);
- mkdir("test", 0777);
+
+ EXPECT_TRUE(test_dir_.CreateUniqueTempDir());
+
+ mkdir(test_dir_.path().Append("test").value().c_str(), 0777);
pid_ = getpid();
brillo::ClearLog();
}
@@ -80,13 +82,13 @@
}
std::vector<std::string> SplitLines(const std::string &lines) const {
- std::vector<std::string> result;
- base::SplitString(lines, '\n', &result);
- return result;
+ return base::SplitString(lines, "\n", base::TRIM_WHITESPACE,
+ base::SPLIT_WANT_ALL);
}
UserCollectorMock collector_;
pid_t pid_;
+ base::ScopedTempDir test_dir_;
};
TEST_F(UserCollectorTest, ParseCrashAttributes) {
@@ -173,14 +175,15 @@
&result));
ASSERT_TRUE(FindLog(
"Readlink failed on /does_not_exist with 2"));
- std::string long_link;
+ std::string long_link = test_dir_.path().value();
for (int i = 0; i < 50; ++i)
long_link += "0123456789";
long_link += "/gold";
for (size_t len = 1; len <= long_link.size(); ++len) {
std::string this_link;
- static const char kLink[] = "test/this_link";
+ static const char* kLink =
+ test_dir_.path().Append("test/this_link").value().c_str();
this_link.assign(long_link.c_str(), len);
ASSERT_EQ(len, this_link.size());
unlink(kLink);
@@ -341,13 +344,13 @@
}
TEST_F(UserCollectorTest, CopyOffProcFilesBadPid) {
- FilePath container_path("test/container");
+ FilePath container_path(test_dir_.path().Append("test/container"));
ASSERT_FALSE(collector_.CopyOffProcFiles(0, container_path));
EXPECT_TRUE(FindLog("Path /proc/0 does not exist"));
}
TEST_F(UserCollectorTest, CopyOffProcFilesOK) {
- FilePath container_path("test/container");
+ FilePath container_path(test_dir_.path().Append("test/container"));
ASSERT_TRUE(collector_.CopyOffProcFiles(pid_, container_path));
EXPECT_FALSE(FindLog("Could not copy"));
static struct {
@@ -371,9 +374,7 @@
}
TEST_F(UserCollectorTest, ValidateProcFiles) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath container_dir = temp_dir.path();
+ FilePath container_dir = test_dir_.path();
// maps file not exists (i.e. GetFileSize fails)
EXPECT_FALSE(collector_.ValidateProcFiles(container_dir));
@@ -392,9 +393,7 @@
}
TEST_F(UserCollectorTest, ValidateCoreFile) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath container_dir = temp_dir.path();
+ FilePath container_dir = test_dir_.path();
FilePath core_file = container_dir.Append("core");
// Core file does not exist
diff --git a/debuggerd/backtrace.cpp b/debuggerd/backtrace.cpp
index b46f8f4..b6916e5 100644
--- a/debuggerd/backtrace.cpp
+++ b/debuggerd/backtrace.cpp
@@ -67,8 +67,7 @@
_LOG(log, logtype::BACKTRACE, "\n----- end %d -----\n", pid);
}
-static void dump_thread(
- log_t* log, pid_t tid, bool attached, bool* detach_failed, int* total_sleep_time_usec) {
+static void dump_thread(log_t* log, BacktraceMap* map, pid_t pid, pid_t tid) {
char path[PATH_MAX];
char threadnamebuf[1024];
char* threadname = NULL;
@@ -88,56 +87,25 @@
_LOG(log, logtype::BACKTRACE, "\n\"%s\" sysTid=%d\n", threadname ? threadname : "<unknown>", tid);
- if (!attached && ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) {
- _LOG(log, logtype::BACKTRACE, "Could not attach to thread: %s\n", strerror(errno));
- return;
- }
-
- if (!attached && wait_for_sigstop(tid, total_sleep_time_usec, detach_failed) == -1) {
- return;
- }
-
- std::unique_ptr<Backtrace> backtrace(Backtrace::Create(tid, BACKTRACE_CURRENT_THREAD));
+ std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, tid, map));
if (backtrace->Unwind(0)) {
dump_backtrace_to_log(backtrace.get(), log, " ");
} else {
ALOGE("Unwind failed: tid = %d", tid);
}
-
- if (!attached && ptrace(PTRACE_DETACH, tid, 0, 0) != 0) {
- ALOGE("ptrace detach from %d failed: %s\n", tid, strerror(errno));
- *detach_failed = true;
- }
}
-void dump_backtrace(int fd, int amfd, pid_t pid, pid_t tid, bool* detach_failed,
- int* total_sleep_time_usec) {
+void dump_backtrace(int fd, int amfd, BacktraceMap* map, pid_t pid, pid_t tid,
+ const std::set<pid_t>& siblings) {
log_t log;
log.tfd = fd;
log.amfd = amfd;
dump_process_header(&log, pid);
- dump_thread(&log, tid, true, detach_failed, total_sleep_time_usec);
+ dump_thread(&log, map, pid, tid);
- char task_path[64];
- snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
- DIR* d = opendir(task_path);
- if (d != NULL) {
- struct dirent* de = NULL;
- while ((de = readdir(d)) != NULL) {
- if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
- continue;
- }
-
- char* end;
- pid_t new_tid = strtoul(de->d_name, &end, 10);
- if (*end || new_tid == tid) {
- continue;
- }
-
- dump_thread(&log, new_tid, false, detach_failed, total_sleep_time_usec);
- }
- closedir(d);
+ for (pid_t sibling : siblings) {
+ dump_thread(&log, map, pid, sibling);
}
dump_process_footer(&log, pid);
diff --git a/debuggerd/backtrace.h b/debuggerd/backtrace.h
index da14cd4..98c433b 100644
--- a/debuggerd/backtrace.h
+++ b/debuggerd/backtrace.h
@@ -19,14 +19,17 @@
#include <sys/types.h>
+#include <set>
+
#include "utility.h"
class Backtrace;
+class BacktraceMap;
// Dumps a backtrace using a format similar to what Dalvik uses so that the result
// can be intermixed in a bug report.
-void dump_backtrace(int fd, int amfd, pid_t pid, pid_t tid, bool* detach_failed,
- int* total_sleep_time_usec);
+void dump_backtrace(int fd, int amfd, BacktraceMap* map, pid_t pid, pid_t tid,
+ const std::set<pid_t>& siblings);
/* Dumps the backtrace in the backtrace data structure to the log. */
void dump_backtrace_to_log(Backtrace* backtrace, log_t* log, const char* prefix);
diff --git a/debuggerd/debuggerd.cpp b/debuggerd/debuggerd.cpp
index 58b629b..8efbacc 100644
--- a/debuggerd/debuggerd.cpp
+++ b/debuggerd/debuggerd.cpp
@@ -14,14 +14,14 @@
* limitations under the License.
*/
-#include <stdio.h>
-#include <errno.h>
-#include <signal.h>
-#include <pthread.h>
-#include <stdarg.h>
-#include <fcntl.h>
-#include <sys/types.h>
#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/types.h>
#include <time.h>
#include <elf.h>
@@ -31,6 +31,8 @@
#include <sys/stat.h>
#include <sys/wait.h>
+#include <set>
+
#include <selinux/android.h>
#include <log/logger.h>
@@ -71,7 +73,7 @@
"* Process %d has been suspended while crashing.\n"
"* To attach gdbserver and start gdb, run this on the host:\n"
"*\n"
- "* gdbclient %d\n"
+ "* gdbclient.py -p %d\n"
"*\n"
"* Wait for gdb to start, then press the VOLUME DOWN key\n"
"* to let the process continue crashing.\n"
@@ -79,16 +81,13 @@
request.pid, request.tid);
// Wait for VOLUME DOWN.
- if (init_getevent() == 0) {
- while (true) {
- input_event e;
- if (get_event(&e, -1) == 0) {
- if (e.type == EV_KEY && e.code == KEY_VOLUMEDOWN && e.value == 0) {
- break;
- }
+ while (true) {
+ input_event e;
+ if (get_event(&e, -1) == 0) {
+ if (e.type == EV_KEY && e.code == KEY_VOLUMEDOWN && e.value == 0) {
+ break;
}
}
- uninit_getevent();
}
ALOGI("debuggerd resuming process %d", request.pid);
@@ -335,6 +334,180 @@
}
#endif
+static void ptrace_siblings(pid_t pid, pid_t main_tid, std::set<pid_t>& tids) {
+ char task_path[64];
+
+ snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
+
+ std::unique_ptr<DIR, int (*)(DIR*)> d(opendir(task_path), closedir);
+
+ // Bail early if the task directory cannot be opened.
+ if (!d) {
+ ALOGE("debuggerd: failed to open /proc/%d/task: %s", pid, strerror(errno));
+ return;
+ }
+
+ struct dirent* de;
+ while ((de = readdir(d.get())) != NULL) {
+ // Ignore "." and "..".
+ if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
+ continue;
+ }
+
+ char* end;
+ pid_t tid = strtoul(de->d_name, &end, 10);
+ if (*end) {
+ continue;
+ }
+
+ if (tid == main_tid) {
+ continue;
+ }
+
+ if (ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) {
+ ALOGE("debuggerd: ptrace attach to %d failed: %s", tid, strerror(errno));
+ continue;
+ }
+
+ tids.insert(tid);
+ }
+}
+
+static bool perform_dump(const debugger_request_t& request, int fd, int tombstone_fd,
+ BacktraceMap* backtrace_map, const std::set<pid_t>& siblings) {
+ if (TEMP_FAILURE_RETRY(write(fd, "\0", 1)) != 1) {
+ ALOGE("debuggerd: failed to respond to client: %s\n", strerror(errno));
+ return false;
+ }
+
+ int total_sleep_time_usec = 0;
+ while (true) {
+ int signal = wait_for_signal(request.tid, &total_sleep_time_usec);
+ switch (signal) {
+ case -1:
+ ALOGE("debuggerd: timed out waiting for signal");
+ return false;
+
+ case SIGSTOP:
+ if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
+ ALOGV("debuggerd: stopped -- dumping to tombstone");
+ engrave_tombstone(tombstone_fd, backtrace_map, request.pid, request.tid, siblings, signal,
+ request.original_si_code, request.abort_msg_address);
+ } else if (request.action == DEBUGGER_ACTION_DUMP_BACKTRACE) {
+ ALOGV("debuggerd: stopped -- dumping to fd");
+ dump_backtrace(fd, -1, backtrace_map, request.pid, request.tid, siblings);
+ } else {
+ ALOGV("debuggerd: stopped -- continuing");
+ if (ptrace(PTRACE_CONT, request.tid, 0, 0) != 0) {
+ ALOGE("debuggerd: ptrace continue failed: %s", strerror(errno));
+ return false;
+ }
+ continue; // loop again
+ }
+ break;
+
+ case SIGABRT:
+ case SIGBUS:
+ case SIGFPE:
+ case SIGILL:
+ case SIGSEGV:
+#ifdef SIGSTKFLT
+ case SIGSTKFLT:
+#endif
+ case SIGTRAP:
+ ALOGV("stopped -- fatal signal\n");
+ // Send a SIGSTOP to the process to make all of
+ // the non-signaled threads stop moving. Without
+ // this we get a lot of "ptrace detach failed:
+ // No such process".
+ kill(request.pid, SIGSTOP);
+ engrave_tombstone(tombstone_fd, backtrace_map, request.pid, request.tid, siblings, signal,
+ request.original_si_code, request.abort_msg_address);
+ break;
+
+ default:
+ ALOGE("debuggerd: process stopped due to unexpected signal %d\n", signal);
+ break;
+ }
+ break;
+ }
+
+ return true;
+}
+
+static bool drop_privileges() {
+ if (setresgid(AID_DEBUGGERD, AID_DEBUGGERD, AID_DEBUGGERD) != 0) {
+ ALOGE("debuggerd: failed to setresgid");
+ return false;
+ }
+
+ if (setresuid(AID_DEBUGGERD, AID_DEBUGGERD, AID_DEBUGGERD) != 0) {
+ ALOGE("debuggerd: failed to setresuid");
+ return false;
+ }
+
+ return true;
+}
+
+static bool fork_signal_sender(int* in_fd, int* out_fd, pid_t* sender_pid, pid_t target_pid) {
+ int input_pipe[2];
+ int output_pipe[2];
+ if (pipe(input_pipe) != 0) {
+ ALOGE("debuggerd: failed to create input pipe for signal sender: %s", strerror(errno));
+ return false;
+ }
+
+ if (pipe(output_pipe) != 0) {
+ close(input_pipe[0]);
+ close(input_pipe[1]);
+ ALOGE("debuggerd: failed to create output pipe for signal sender: %s", strerror(errno));
+ return false;
+ }
+
+ pid_t fork_pid = fork();
+ if (fork_pid == -1) {
+ ALOGE("debuggerd: failed to initialize signal sender: fork failed: %s", strerror(errno));
+ return false;
+ } else if (fork_pid == 0) {
+ close(input_pipe[1]);
+ close(output_pipe[0]);
+ auto wait = [=]() {
+ char buf[1];
+ if (TEMP_FAILURE_RETRY(read(input_pipe[0], buf, 1)) != 1) {
+ ALOGE("debuggerd: signal sender failed to read from pipe");
+ exit(1);
+ }
+ };
+ auto notify_done = [=]() {
+ if (TEMP_FAILURE_RETRY(write(output_pipe[1], "", 1)) != 1) {
+ ALOGE("debuggerd: signal sender failed to write to pipe");
+ exit(1);
+ }
+ };
+
+ wait();
+ if (kill(target_pid, SIGSTOP) != 0) {
+ ALOGE("debuggerd: failed to stop target '%d': %s", target_pid, strerror(errno));
+ }
+ notify_done();
+
+ wait();
+ if (kill(target_pid, SIGCONT) != 0) {
+ ALOGE("debuggerd: failed to resume target '%d': %s", target_pid, strerror(errno));
+ }
+ notify_done();
+
+ exit(0);
+ } else {
+ close(input_pipe[0]);
+ close(output_pipe[1]);
+ *in_fd = input_pipe[1];
+ *out_fd = output_pipe[0];
+ *sender_pid = fork_pid;
+ return true;
+ }
+}
+
static void handle_request(int fd) {
ALOGV("handle_request(%d)\n", fd);
@@ -405,117 +578,88 @@
// ensure that it can run as soon as we call PTRACE_CONT below.
// See details in bionic/libc/linker/debugger.c, in function
// debugger_signal_handler().
- if (ptrace(PTRACE_ATTACH, request.tid, 0, 0)) {
- ALOGE("debuggerd: ptrace attach failed: %s\n", strerror(errno));
+
+ // Attach to the target process.
+ if (ptrace(PTRACE_ATTACH, request.tid, 0, 0) != 0) {
+ ALOGE("debuggerd: ptrace attach failed: %s", strerror(errno));
exit(1);
}
+ // Don't attach to the sibling threads if we want to attach gdb.
+ // Supposedly, it makes the process less reliable.
+ bool attach_gdb = should_attach_gdb(&request);
+ int signal_in_fd = -1;
+ int signal_out_fd = -1;
+ pid_t signal_pid = 0;
+ if (attach_gdb) {
+ // Open all of the input devices we need to listen for VOLUMEDOWN before dropping privileges.
+ if (init_getevent() != 0) {
+ ALOGE("debuggerd: failed to initialize input device, not waiting for gdb");
+ attach_gdb = false;
+ }
+
+ // Fork a process that stays root, and listens on a pipe to pause and resume the target.
+ if (!fork_signal_sender(&signal_in_fd, &signal_out_fd, &signal_pid, request.pid)) {
+ attach_gdb = false;
+ }
+ }
+
+ auto notify_signal_sender = [=]() {
+ char buf[1];
+ if (TEMP_FAILURE_RETRY(write(signal_in_fd, "", 1)) != 1) {
+ ALOGE("debuggerd: failed to notify signal process: %s", strerror(errno));
+ } else if (TEMP_FAILURE_RETRY(read(signal_out_fd, buf, 1)) != 1) {
+ ALOGE("debuggerd: failed to read response from signal process: %s", strerror(errno));
+ }
+ };
+
+ std::set<pid_t> siblings;
+ if (!attach_gdb) {
+ ptrace_siblings(request.pid, request.tid, siblings);
+ }
+
// Generate the backtrace map before dropping privileges.
std::unique_ptr<BacktraceMap> backtrace_map(BacktraceMap::Create(request.pid));
+ bool succeeded = false;
+
// Now that we've done everything that requires privileges, we can drop them.
- if (setresgid(AID_DEBUGGERD, AID_DEBUGGERD, AID_DEBUGGERD) != 0) {
- ALOGE("debuggerd: failed to setresgid");
- exit(1);
- }
-
- if (setresuid(AID_DEBUGGERD, AID_DEBUGGERD, AID_DEBUGGERD) != 0) {
- ALOGE("debuggerd: failed to setresuid");
- exit(1);
- }
-
- bool detach_failed = false;
- bool tid_unresponsive = false;
- bool attach_gdb = should_attach_gdb(&request);
- if (TEMP_FAILURE_RETRY(write(fd, "\0", 1)) != 1) {
- ALOGE("debuggerd: failed to respond to client: %s\n", strerror(errno));
- exit(1);
- }
-
- int total_sleep_time_usec = 0;
- while (true) {
- int signal = wait_for_sigstop(request.tid, &total_sleep_time_usec, &detach_failed);
- if (signal == -1) {
- tid_unresponsive = true;
- break;
- }
-
- switch (signal) {
- case SIGSTOP:
- if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
- ALOGV("stopped -- dumping to tombstone\n");
- engrave_tombstone(tombstone_fd, backtrace_map.get(), request.pid, request.tid, signal,
- request.original_si_code, request.abort_msg_address, true,
- &detach_failed, &total_sleep_time_usec);
- } else if (request.action == DEBUGGER_ACTION_DUMP_BACKTRACE) {
- ALOGV("stopped -- dumping to fd\n");
- dump_backtrace(fd, -1, request.pid, request.tid, &detach_failed, &total_sleep_time_usec);
- } else {
- ALOGV("stopped -- continuing\n");
- status = ptrace(PTRACE_CONT, request.tid, 0, 0);
- if (status) {
- ALOGE("debuggerd: ptrace continue failed: %s\n", strerror(errno));
- }
- continue; // loop again
+ if (drop_privileges()) {
+ succeeded = perform_dump(request, fd, tombstone_fd, backtrace_map.get(), siblings);
+ if (succeeded) {
+ if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
+ if (!tombstone_path.empty()) {
+ write(fd, tombstone_path.c_str(), tombstone_path.length());
}
- break;
-
- case SIGABRT:
- case SIGBUS:
- case SIGFPE:
- case SIGILL:
- case SIGSEGV:
-#ifdef SIGSTKFLT
- case SIGSTKFLT:
-#endif
- case SIGTRAP:
- ALOGV("stopped -- fatal signal\n");
- // Send a SIGSTOP to the process to make all of
- // the non-signaled threads stop moving. Without
- // this we get a lot of "ptrace detach failed:
- // No such process".
- kill(request.pid, SIGSTOP);
- // don't dump sibling threads when attaching to GDB because it
- // makes the process less reliable, apparently...
- engrave_tombstone(tombstone_fd, backtrace_map.get(), request.pid, request.tid, signal,
- request.original_si_code, request.abort_msg_address, !attach_gdb,
- &detach_failed, &total_sleep_time_usec);
- break;
-
- default:
- ALOGE("debuggerd: process stopped due to unexpected signal %d\n", signal);
- break;
+ }
}
- break;
- }
- if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
- if (!tombstone_path.empty()) {
- write(fd, tombstone_path.c_str(), tombstone_path.length());
- }
- }
-
- if (!tid_unresponsive) {
- ALOGV("detaching");
if (attach_gdb) {
- // stop the process so we can debug
- kill(request.pid, SIGSTOP);
- }
- if (ptrace(PTRACE_DETACH, request.tid, 0, 0)) {
- ALOGE("debuggerd: ptrace detach from %d failed: %s", request.tid, strerror(errno));
- detach_failed = true;
- } else if (attach_gdb) {
- // if debug.db.uid is set, its value indicates if we should wait
- // for user action for the crashing process.
- // in this case, we log a message and turn the debug LED on
- // waiting for a gdb connection (for instance)
- wait_for_user_action(request);
+ // Tell the signal process to send SIGSTOP to the target.
+ notify_signal_sender();
}
}
- // Resume the stopped process so it can crash in peace, and exit.
- kill(request.pid, SIGCONT);
- exit(0);
+ if (ptrace(PTRACE_DETACH, request.tid, 0, 0) != 0) {
+ ALOGE("debuggerd: ptrace detach from %d failed: %s", request.tid, strerror(errno));
+ }
+
+ for (pid_t sibling : siblings) {
+ ptrace(PTRACE_DETACH, sibling, 0, 0);
+ }
+
+ // Wait for gdb, if requested.
+ if (attach_gdb && succeeded) {
+ wait_for_user_action(request);
+
+ // Tell the signal process to send SIGCONT to the target.
+ notify_signal_sender();
+
+ uninit_getevent();
+ waitpid(signal_pid, nullptr, 0);
+ }
+
+ exit(!succeeded);
}
static int do_server() {
diff --git a/debuggerd/tombstone.cpp b/debuggerd/tombstone.cpp
index b2f203d..dda6677 100644
--- a/debuggerd/tombstone.cpp
+++ b/debuggerd/tombstone.cpp
@@ -328,6 +328,33 @@
return addr_str;
}
+static void dump_abort_message(Backtrace* backtrace, log_t* log, uintptr_t address) {
+ if (address == 0) {
+ return;
+ }
+
+ address += sizeof(size_t); // Skip the buffer length.
+
+ char msg[512];
+ memset(msg, 0, sizeof(msg));
+ char* p = &msg[0];
+ while (p < &msg[sizeof(msg)]) {
+ word_t data;
+ size_t len = sizeof(word_t);
+ if (!backtrace->ReadWord(address, &data)) {
+ break;
+ }
+ address += sizeof(word_t);
+
+ while (len > 0 && (*p++ = (data >> (sizeof(word_t) - len) * 8) & 0xff) != 0) {
+ len--;
+ }
+ }
+ msg[sizeof(msg) - 1] = '\0';
+
+ _LOG(log, logtype::HEADER, "Abort message: '%s'\n", msg);
+}
+
static void dump_all_maps(Backtrace* backtrace, BacktraceMap* map, log_t* log, pid_t tid) {
bool print_fault_address_marker = false;
uintptr_t addr = 0;
@@ -416,67 +443,37 @@
}
}
-// Return true if some thread is not detached cleanly
-static bool dump_sibling_thread_report(
- log_t* log, pid_t pid, pid_t tid, int* total_sleep_time_usec, BacktraceMap* map) {
- char task_path[64];
-
- snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
-
- DIR* d = opendir(task_path);
- // Bail early if the task directory cannot be opened
- if (d == NULL) {
- ALOGE("Cannot open /proc/%d/task\n", pid);
- return false;
- }
-
- bool detach_failed = false;
- struct dirent* de;
- while ((de = readdir(d)) != NULL) {
- // Ignore "." and ".."
- if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
- continue;
- }
-
- // The main thread at fault has been handled individually
- char* end;
- pid_t new_tid = strtoul(de->d_name, &end, 10);
- if (*end || new_tid == tid) {
- continue;
- }
-
- // Skip this thread if cannot ptrace it
- if (ptrace(PTRACE_ATTACH, new_tid, 0, 0) < 0) {
- ALOGE("ptrace attach to %d failed: %s\n", new_tid, strerror(errno));
- continue;
- }
-
- if (wait_for_sigstop(new_tid, total_sleep_time_usec, &detach_failed) == -1) {
- continue;
- }
-
- log->current_tid = new_tid;
+static void dump_thread(log_t* log, pid_t pid, pid_t tid, BacktraceMap* map, int signal,
+ int si_code, uintptr_t abort_msg_address, bool primary_thread) {
+ log->current_tid = tid;
+ if (!primary_thread) {
_LOG(log, logtype::THREAD, "--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n");
- dump_thread_info(log, pid, new_tid);
+ }
+ dump_thread_info(log, pid, tid);
- dump_registers(log, new_tid);
- std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, new_tid, map));
- if (backtrace->Unwind(0)) {
- dump_backtrace_and_stack(backtrace.get(), log);
- } else {
- ALOGE("Unwind of sibling failed: pid = %d, tid = %d", pid, new_tid);
- }
+ if (signal) {
+ dump_signal_info(log, tid, signal, si_code);
+ }
- log->current_tid = log->crashed_tid;
+ std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, tid, map));
+ if (primary_thread) {
+ dump_abort_message(backtrace.get(), log, abort_msg_address);
+ }
+ dump_registers(log, tid);
+ if (backtrace->Unwind(0)) {
+ dump_backtrace_and_stack(backtrace.get(), log);
+ } else {
+ ALOGE("Unwind failed: pid = %d, tid = %d", pid, tid);
+ }
- if (ptrace(PTRACE_DETACH, new_tid, 0, 0) != 0) {
- ALOGE("ptrace detach from %d failed: %s\n", new_tid, strerror(errno));
- detach_failed = true;
+ if (primary_thread) {
+ dump_memory_and_code(log, backtrace.get());
+ if (map) {
+ dump_all_maps(backtrace.get(), map, log, tid);
}
}
- closedir(d);
- return detach_failed;
+ log->current_tid = log->crashed_tid;
}
// Reads the contents of the specified log device, filters out the entries
@@ -605,36 +602,10 @@
dump_log_file(log, pid, "main", tail);
}
-static void dump_abort_message(Backtrace* backtrace, log_t* log, uintptr_t address) {
- if (address == 0) {
- return;
- }
-
- address += sizeof(size_t); // Skip the buffer length.
-
- char msg[512];
- memset(msg, 0, sizeof(msg));
- char* p = &msg[0];
- while (p < &msg[sizeof(msg)]) {
- word_t data;
- size_t len = sizeof(word_t);
- if (!backtrace->ReadWord(address, &data)) {
- break;
- }
- address += sizeof(word_t);
-
- while (len > 0 && (*p++ = (data >> (sizeof(word_t) - len) * 8) & 0xff) != 0)
- len--;
- }
- msg[sizeof(msg) - 1] = '\0';
-
- _LOG(log, logtype::HEADER, "Abort message: '%s'\n", msg);
-}
-
// Dumps all information about the specified pid to the tombstone.
-static bool dump_crash(log_t* log, BacktraceMap* map, pid_t pid, pid_t tid, int signal, int si_code,
- uintptr_t abort_msg_address, bool dump_sibling_threads,
- int* total_sleep_time_usec) {
+static void dump_crash(log_t* log, BacktraceMap* map, pid_t pid, pid_t tid,
+ const std::set<pid_t>& siblings, int signal, int si_code,
+ uintptr_t abort_msg_address) {
// don't copy log messages to tombstone unless this is a dev device
char value[PROPERTY_VALUE_MAX];
property_get("ro.debuggable", value, "0");
@@ -653,32 +624,15 @@
_LOG(log, logtype::HEADER,
"*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
dump_header_info(log);
- dump_thread_info(log, pid, tid);
-
- if (signal) {
- dump_signal_info(log, tid, signal, si_code);
- }
-
- std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, tid, map));
- dump_abort_message(backtrace.get(), log, abort_msg_address);
- dump_registers(log, tid);
- if (backtrace->Unwind(0)) {
- dump_backtrace_and_stack(backtrace.get(), log);
- } else {
- ALOGE("Unwind failed: pid = %d, tid = %d", pid, tid);
- }
- dump_memory_and_code(log, backtrace.get());
- if (map) {
- dump_all_maps(backtrace.get(), map, log, tid);
- }
-
+ dump_thread(log, pid, tid, map, signal, si_code, abort_msg_address, true);
if (want_logs) {
dump_logs(log, pid, 5);
}
- bool detach_failed = false;
- if (dump_sibling_threads) {
- detach_failed = dump_sibling_thread_report(log, pid, tid, total_sleep_time_usec, map);
+ if (!siblings.empty()) {
+ for (pid_t sibling : siblings) {
+ dump_thread(log, pid, sibling, map, 0, 0, 0, false);
+ }
}
if (want_logs) {
@@ -694,7 +648,7 @@
TEMP_FAILURE_RETRY( read(log->amfd, &eodMarker, 1) );
}
- return detach_failed;
+ return;
}
// open_tombstone - find an available tombstone slot, if any, of the
@@ -780,16 +734,15 @@
return amfd;
}
-void engrave_tombstone(int tombstone_fd, BacktraceMap* map, pid_t pid, pid_t tid, int signal,
- int original_si_code, uintptr_t abort_msg_address, bool dump_sibling_threads,
- bool* detach_failed, int* total_sleep_time_usec) {
+void engrave_tombstone(int tombstone_fd, BacktraceMap* map, pid_t pid, pid_t tid,
+ const std::set<pid_t>& siblings, int signal, int original_si_code,
+ uintptr_t abort_msg_address) {
log_t log;
log.current_tid = tid;
log.crashed_tid = tid;
if (tombstone_fd < 0) {
ALOGE("debuggerd: skipping tombstone write, nothing to do.\n");
- *detach_failed = false;
return;
}
@@ -798,8 +751,7 @@
// being closed.
int amfd = activity_manager_connect();
log.amfd = amfd;
- *detach_failed = dump_crash(&log, map, pid, tid, signal, original_si_code, abort_msg_address,
- dump_sibling_threads, total_sleep_time_usec);
+ dump_crash(&log, map, pid, tid, siblings, signal, original_si_code, abort_msg_address);
// This file descriptor can be -1, any error is ignored.
close(amfd);
diff --git a/debuggerd/tombstone.h b/debuggerd/tombstone.h
index 5f2d239..2b8b8be 100644
--- a/debuggerd/tombstone.h
+++ b/debuggerd/tombstone.h
@@ -20,6 +20,7 @@
#include <stdbool.h>
#include <stddef.h>
#include <sys/types.h>
+#include <set>
#include <string>
class BacktraceMap;
@@ -30,10 +31,9 @@
*/
int open_tombstone(std::string* path);
-/* Creates a tombstone file and writes the crash dump to it.
- * Returns the path of the tombstone, which must be freed using free(). */
-void engrave_tombstone(int tombstone_fd, BacktraceMap* map, pid_t pid, pid_t tid, int signal,
- int original_si_code, uintptr_t abort_msg_address, bool dump_sibling_threads,
- bool* detach_failed, int* total_sleep_time_usec);
+/* Creates a tombstone file and writes the crash dump to it. */
+void engrave_tombstone(int tombstone_fd, BacktraceMap* map, pid_t pid, pid_t tid,
+ const std::set<pid_t>& siblings, int signal, int original_si_code,
+ uintptr_t abort_msg_address);
#endif // _DEBUGGERD_TOMBSTONE_H
diff --git a/debuggerd/utility.cpp b/debuggerd/utility.cpp
index ce214f9..cd252ce 100644
--- a/debuggerd/utility.cpp
+++ b/debuggerd/utility.cpp
@@ -30,8 +30,8 @@
#include <backtrace/Backtrace.h>
#include <log/log.h>
-const int SLEEP_TIME_USEC = 50000; // 0.05 seconds
-const int MAX_TOTAL_SLEEP_USEC = 10000000; // 10 seconds
+constexpr int SLEEP_TIME_USEC = 50000; // 0.05 seconds
+constexpr int MAX_TOTAL_SLEEP_USEC = 10000000; // 10 seconds
// Whitelist output desired in the logcat output.
bool is_allowed_in_logcat(enum logtype ltype) {
@@ -78,14 +78,13 @@
}
}
-int wait_for_sigstop(pid_t tid, int* total_sleep_time_usec, bool* detach_failed) {
- bool allow_dead_tid = false;
- for (;;) {
+int wait_for_signal(pid_t tid, int* total_sleep_time_usec) {
+ while (true) {
int status;
pid_t n = TEMP_FAILURE_RETRY(waitpid(tid, &status, __WALL | WNOHANG));
if (n == -1) {
ALOGE("waitpid failed: tid %d, %s", tid, strerror(errno));
- break;
+ return -1;
} else if (n == tid) {
if (WIFSTOPPED(status)) {
return WSTOPSIG(status);
@@ -93,29 +92,18 @@
ALOGE("unexpected waitpid response: n=%d, status=%08x\n", n, status);
// This is the only circumstance under which we can allow a detach
// to fail with ESRCH, which indicates the tid has exited.
- allow_dead_tid = true;
- break;
+ return -1;
}
}
if (*total_sleep_time_usec > MAX_TOTAL_SLEEP_USEC) {
ALOGE("timed out waiting for stop signal: tid=%d", tid);
- break;
+ return -1;
}
usleep(SLEEP_TIME_USEC);
*total_sleep_time_usec += SLEEP_TIME_USEC;
}
-
- if (ptrace(PTRACE_DETACH, tid, 0, 0) != 0) {
- if (allow_dead_tid && errno == ESRCH) {
- ALOGE("tid exited before attach completed: tid %d", tid);
- } else {
- *detach_failed = true;
- ALOGE("detach failed: tid %d, %s", tid, strerror(errno));
- }
- }
- return -1;
}
#define MEMORY_BYTES_TO_DUMP 256
diff --git a/debuggerd/utility.h b/debuggerd/utility.h
index 8bef192..ed08ddc 100644
--- a/debuggerd/utility.h
+++ b/debuggerd/utility.h
@@ -74,7 +74,7 @@
void _LOG(log_t* log, logtype ltype, const char *fmt, ...)
__attribute__ ((format(printf, 3, 4)));
-int wait_for_sigstop(pid_t, int*, bool*);
+int wait_for_signal(pid_t tid, int* total_sleep_time_usec);
void dump_memory(log_t* log, Backtrace* backtrace, uintptr_t addr, const char* fmt, ...);
diff --git a/fastboot/.clang-format b/fastboot/.clang-format
new file mode 100644
index 0000000..bcb8d8a
--- /dev/null
+++ b/fastboot/.clang-format
@@ -0,0 +1,15 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+
+ColumnLimit: 100
+CommentPragmas: NOLINT:.*
+DerivePointerAlignment: false
+IndentWidth: 4
+ContinuationIndentWidth: 8
+ConstructorInitializerIndentWidth: 8
+AccessModifierOffset: -2
+PointerAlignment: Left
+TabWidth: 4
+UseTab: Never
+PenaltyExcessCharacter: 32
diff --git a/fastboot/Android.mk b/fastboot/Android.mk
index 8cbc79b..fcec5b1 100644
--- a/fastboot/Android.mk
+++ b/fastboot/Android.mk
@@ -24,7 +24,15 @@
$(LOCAL_PATH)/../../extras/ext4_utils \
$(LOCAL_PATH)/../../extras/f2fs_utils \
-LOCAL_SRC_FILES := protocol.cpp engine.cpp bootimg_utils.cpp fastboot.cpp util.cpp fs.cpp
+LOCAL_SRC_FILES := \
+ bootimg_utils.cpp \
+ engine.cpp \
+ fastboot.cpp \
+ fs.cpp\
+ protocol.cpp \
+ socket.cpp \
+ util.cpp \
+
LOCAL_MODULE := fastboot
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE_HOST_OS := darwin linux windows
@@ -33,15 +41,15 @@
LOCAL_CFLAGS += -DFASTBOOT_REVISION='"$(fastboot_version)"'
-LOCAL_SRC_FILES_linux := socket_unix.cpp usb_linux.cpp util_linux.cpp
-LOCAL_STATIC_LIBRARIES_linux := libcutils libselinux
+LOCAL_SRC_FILES_linux := usb_linux.cpp util_linux.cpp
+LOCAL_STATIC_LIBRARIES_linux := libselinux
-LOCAL_SRC_FILES_darwin := socket_unix.cpp usb_osx.cpp util_osx.cpp
-LOCAL_STATIC_LIBRARIES_darwin := libcutils libselinux
+LOCAL_SRC_FILES_darwin := usb_osx.cpp util_osx.cpp
+LOCAL_STATIC_LIBRARIES_darwin := libselinux
LOCAL_LDLIBS_darwin := -lpthread -framework CoreFoundation -framework IOKit -framework Carbon
LOCAL_CFLAGS_darwin := -Wno-unused-parameter
-LOCAL_SRC_FILES_windows := socket_windows.cpp usb_windows.cpp util_windows.cpp
+LOCAL_SRC_FILES_windows := usb_windows.cpp util_windows.cpp
LOCAL_STATIC_LIBRARIES_windows := AdbWinApi
LOCAL_REQUIRED_MODULES_windows := AdbWinApi
LOCAL_LDLIBS_windows := -lws2_32
@@ -56,6 +64,7 @@
libz \
libdiagnose_usb \
libbase \
+ libcutils \
# libf2fs_dlutils_host will dlopen("libf2fs_fmt_host_dyn")
LOCAL_CFLAGS_linux := -DUSE_F2FS
@@ -97,20 +106,14 @@
LOCAL_MODULE := fastboot_test
LOCAL_MODULE_HOST_OS := darwin linux windows
-LOCAL_SRC_FILES := socket_test.cpp
-LOCAL_STATIC_LIBRARIES := libbase
+LOCAL_SRC_FILES := socket.cpp socket_test.cpp
+LOCAL_STATIC_LIBRARIES := libbase libcutils
LOCAL_CFLAGS += -Wall -Wextra -Werror -Wunreachable-code
-LOCAL_SRC_FILES_linux := socket_unix.cpp
-LOCAL_STATIC_LIBRARIES_linux := libcutils
-
-LOCAL_SRC_FILES_darwin := socket_unix.cpp
LOCAL_LDLIBS_darwin := -lpthread -framework CoreFoundation -framework IOKit -framework Carbon
LOCAL_CFLAGS_darwin := -Wno-unused-parameter
-LOCAL_STATIC_LIBRARIES_darwin := libcutils
-LOCAL_SRC_FILES_windows := socket_windows.cpp
LOCAL_LDLIBS_windows := -lws2_32
include $(BUILD_HOST_NATIVE_TEST)
diff --git a/fastboot/engine.cpp b/fastboot/engine.cpp
index ac5a17a..47567c0 100644
--- a/fastboot/engine.cpp
+++ b/fastboot/engine.cpp
@@ -157,17 +157,17 @@
a->msg = mkmsg("writing '%s'", ptn);
}
-void fb_queue_flash_sparse(const char *ptn, struct sparse_file *s, unsigned sz)
-{
+void fb_queue_flash_sparse(const char* ptn, struct sparse_file* s, unsigned sz, size_t current,
+ size_t total) {
Action *a;
a = queue_action(OP_DOWNLOAD_SPARSE, "");
a->data = s;
a->size = 0;
- a->msg = mkmsg("sending sparse '%s' (%d KB)", ptn, sz / 1024);
+ a->msg = mkmsg("sending sparse '%s' %zu/%zu (%d KB)", ptn, current, total, sz / 1024);
a = queue_action(OP_COMMAND, "flash:%s", ptn);
- a->msg = mkmsg("writing '%s'", ptn);
+ a->msg = mkmsg("writing '%s' %zu/%zu", ptn, current, total);
}
static int match(const char* str, const char** value, unsigned count) {
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index bd17485..4573da0 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -43,6 +43,8 @@
#include <sys/types.h>
#include <unistd.h>
#include <functional>
+#include <utility>
+#include <vector>
#include <android-base/parseint.h>
#include <android-base/strings.h>
@@ -705,13 +707,22 @@
sparse_file** s;
switch (buf->type) {
- case FB_BUFFER_SPARSE:
+ case FB_BUFFER_SPARSE: {
+ std::vector<std::pair<sparse_file*, int64_t>> sparse_files;
s = reinterpret_cast<sparse_file**>(buf->data);
while (*s) {
int64_t sz = sparse_file_len(*s, true, false);
- fb_queue_flash_sparse(pname, *s++, sz);
+ sparse_files.emplace_back(*s, sz);
+ ++s;
+ }
+
+ for (size_t i = 0; i < sparse_files.size(); ++i) {
+ const auto& pair = sparse_files[i];
+ fb_queue_flash_sparse(pname, pair.first, pair.second, i + 1, sparse_files.size());
}
break;
+ }
+
case FB_BUFFER:
fb_queue_flash(pname, buf->data, buf->sz);
break;
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index acfbc13..1932bab 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -51,7 +51,8 @@
/* engine.c - high level command queue engine */
bool fb_getvar(Transport* transport, const std::string& key, std::string* value);
void fb_queue_flash(const char *ptn, void *data, uint32_t sz);
-void fb_queue_flash_sparse(const char *ptn, struct sparse_file *s, uint32_t sz);
+void fb_queue_flash_sparse(const char* ptn, struct sparse_file* s, uint32_t sz, size_t current,
+ size_t total);
void fb_queue_erase(const char *ptn);
void fb_queue_format(const char *ptn, int skip_if_not_supported, int32_t max_chunk_sz);
void fb_queue_require(const char *prod, const char *var, bool invert,
diff --git a/fastboot/socket.cpp b/fastboot/socket.cpp
new file mode 100644
index 0000000..d41f1fe
--- /dev/null
+++ b/fastboot/socket.cpp
@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "socket.h"
+
+#include <android-base/stringprintf.h>
+
+Socket::Socket(cutils_socket_t sock) : sock_(sock) {}
+
+Socket::~Socket() {
+ Close();
+}
+
+int Socket::Close() {
+ int ret = 0;
+
+ if (sock_ != INVALID_SOCKET) {
+ ret = socket_close(sock_);
+ sock_ = INVALID_SOCKET;
+ }
+
+ return ret;
+}
+
+bool Socket::SetReceiveTimeout(int timeout_ms) {
+ if (timeout_ms != receive_timeout_ms_) {
+ if (socket_set_receive_timeout(sock_, timeout_ms) == 0) {
+ receive_timeout_ms_ = timeout_ms;
+ return true;
+ }
+ return false;
+ }
+
+ return true;
+}
+
+ssize_t Socket::ReceiveAll(void* data, size_t length, int timeout_ms) {
+ size_t total = 0;
+
+ while (total < length) {
+ ssize_t bytes = Receive(reinterpret_cast<char*>(data) + total, length - total, timeout_ms);
+
+ if (bytes == -1) {
+ if (total == 0) {
+ return -1;
+ }
+ break;
+ }
+ total += bytes;
+ }
+
+ return total;
+}
+
+// Implements the Socket interface for UDP.
+class UdpSocket : public Socket {
+ public:
+ enum class Type { kClient, kServer };
+
+ UdpSocket(Type type, cutils_socket_t sock);
+
+ ssize_t Send(const void* data, size_t length) override;
+ ssize_t Receive(void* data, size_t length, int timeout_ms) override;
+
+ private:
+ std::unique_ptr<sockaddr_storage> addr_;
+ socklen_t addr_size_ = 0;
+
+ DISALLOW_COPY_AND_ASSIGN(UdpSocket);
+};
+
+UdpSocket::UdpSocket(Type type, cutils_socket_t sock) : Socket(sock) {
+ // Only servers need to remember addresses; clients are connected to a server in NewClient()
+ // so will send to that server without needing to specify the address again.
+ if (type == Type::kServer) {
+ addr_.reset(new sockaddr_storage);
+ addr_size_ = sizeof(*addr_);
+ memset(addr_.get(), 0, addr_size_);
+ }
+}
+
+ssize_t UdpSocket::Send(const void* data, size_t length) {
+ return TEMP_FAILURE_RETRY(sendto(sock_, reinterpret_cast<const char*>(data), length, 0,
+ reinterpret_cast<sockaddr*>(addr_.get()), addr_size_));
+}
+
+ssize_t UdpSocket::Receive(void* data, size_t length, int timeout_ms) {
+ if (!SetReceiveTimeout(timeout_ms)) {
+ return -1;
+ }
+
+ socklen_t* addr_size_ptr = nullptr;
+ if (addr_ != nullptr) {
+ // Reset addr_size as it may have been modified by previous recvfrom() calls.
+ addr_size_ = sizeof(*addr_);
+ addr_size_ptr = &addr_size_;
+ }
+
+ return TEMP_FAILURE_RETRY(recvfrom(sock_, reinterpret_cast<char*>(data), length, 0,
+ reinterpret_cast<sockaddr*>(addr_.get()), addr_size_ptr));
+}
+
+// Implements the Socket interface for TCP.
+class TcpSocket : public Socket {
+ public:
+ TcpSocket(cutils_socket_t sock) : Socket(sock) {}
+
+ ssize_t Send(const void* data, size_t length) override;
+ ssize_t Receive(void* data, size_t length, int timeout_ms) override;
+
+ std::unique_ptr<Socket> Accept() override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(TcpSocket);
+};
+
+ssize_t TcpSocket::Send(const void* data, size_t length) {
+ size_t total = 0;
+
+ while (total < length) {
+ ssize_t bytes = TEMP_FAILURE_RETRY(
+ send(sock_, reinterpret_cast<const char*>(data) + total, length - total, 0));
+
+ if (bytes == -1) {
+ if (total == 0) {
+ return -1;
+ }
+ break;
+ }
+ total += bytes;
+ }
+
+ return total;
+}
+
+ssize_t TcpSocket::Receive(void* data, size_t length, int timeout_ms) {
+ if (!SetReceiveTimeout(timeout_ms)) {
+ return -1;
+ }
+
+ return TEMP_FAILURE_RETRY(recv(sock_, reinterpret_cast<char*>(data), length, 0));
+}
+
+std::unique_ptr<Socket> TcpSocket::Accept() {
+ cutils_socket_t handler = accept(sock_, nullptr, nullptr);
+ if (handler == INVALID_SOCKET) {
+ return nullptr;
+ }
+ return std::unique_ptr<TcpSocket>(new TcpSocket(handler));
+}
+
+std::unique_ptr<Socket> Socket::NewClient(Protocol protocol, const std::string& host, int port,
+ std::string* error) {
+ if (protocol == Protocol::kUdp) {
+ cutils_socket_t sock = socket_network_client(host.c_str(), port, SOCK_DGRAM);
+ if (sock != INVALID_SOCKET) {
+ return std::unique_ptr<UdpSocket>(new UdpSocket(UdpSocket::Type::kClient, sock));
+ }
+ } else {
+ cutils_socket_t sock = socket_network_client(host.c_str(), port, SOCK_STREAM);
+ if (sock != INVALID_SOCKET) {
+ return std::unique_ptr<TcpSocket>(new TcpSocket(sock));
+ }
+ }
+
+ if (error) {
+ *error = android::base::StringPrintf("Failed to connect to %s:%d", host.c_str(), port);
+ }
+ return nullptr;
+}
+
+// This functionality is currently only used by tests so we don't need any error messages.
+std::unique_ptr<Socket> Socket::NewServer(Protocol protocol, int port) {
+ if (protocol == Protocol::kUdp) {
+ cutils_socket_t sock = socket_inaddr_any_server(port, SOCK_DGRAM);
+ if (sock != INVALID_SOCKET) {
+ return std::unique_ptr<UdpSocket>(new UdpSocket(UdpSocket::Type::kServer, sock));
+ }
+ } else {
+ cutils_socket_t sock = socket_inaddr_any_server(port, SOCK_STREAM);
+ if (sock != INVALID_SOCKET) {
+ return std::unique_ptr<TcpSocket>(new TcpSocket(sock));
+ }
+ }
+
+ return nullptr;
+}
diff --git a/fastboot/socket.h b/fastboot/socket.h
index 888b530..3e66c27 100644
--- a/fastboot/socket.h
+++ b/fastboot/socket.h
@@ -26,36 +26,41 @@
* SUCH DAMAGE.
*/
-// This file provides a class interface for cross-platform UDP functionality. The main fastboot
+// This file provides a class interface for cross-platform socket functionality. The main fastboot
// engine should not be using this interface directly, but instead should use a higher-level
-// interface that enforces the fastboot UDP protocol.
+// interface that enforces the fastboot protocol.
#ifndef SOCKET_H_
#define SOCKET_H_
-#include "android-base/macros.h"
-
#include <memory>
#include <string>
-// UdpSocket interface to be implemented for each platform.
-class UdpSocket {
+#include <android-base/macros.h>
+#include <cutils/sockets.h>
+
+// Socket interface to be implemented for each platform.
+class Socket {
public:
+ enum class Protocol { kTcp, kUdp };
+
// Creates a new client connection. Clients are connected to a specific hostname/port and can
// only send to that destination.
// On failure, |error| is filled (if non-null) and nullptr is returned.
- static std::unique_ptr<UdpSocket> NewUdpClient(const std::string& hostname, int port,
- std::string* error);
+ static std::unique_ptr<Socket> NewClient(Protocol protocol, const std::string& hostname,
+ int port, std::string* error);
// Creates a new server bound to local |port|. This is only meant for testing, during normal
// fastboot operation the device acts as the server.
- // The server saves sender addresses in Receive(), and uses the most recent address during
+ // A UDP server saves sender addresses in Receive(), and uses the most recent address during
// calls to Send().
- static std::unique_ptr<UdpSocket> NewUdpServer(int port);
+ static std::unique_ptr<Socket> NewServer(Protocol protocol, int port);
- virtual ~UdpSocket() = default;
+ // Destructor closes the socket if it's open.
+ virtual ~Socket();
- // Sends |length| bytes of |data|. Returns the number of bytes actually sent or -1 on error.
+ // Sends |length| bytes of |data|. For TCP sockets this will continue trying to send until all
+ // bytes are transmitted. Returns the number of bytes actually sent or -1 on error.
virtual ssize_t Send(const void* data, size_t length) = 0;
// Waits up to |timeout_ms| to receive up to |length| bytes of data. |timout_ms| of 0 will
@@ -63,14 +68,29 @@
// errno will be set to EAGAIN or EWOULDBLOCK.
virtual ssize_t Receive(void* data, size_t length, int timeout_ms) = 0;
+ // Calls Receive() until exactly |length| bytes have been received or an error occurs.
+ virtual ssize_t ReceiveAll(void* data, size_t length, int timeout_ms);
+
// Closes the socket. Returns 0 on success, -1 on error.
- virtual int Close() = 0;
+ virtual int Close();
+
+ // Accepts an incoming TCP connection. No effect for UDP sockets. Returns a new Socket
+ // connected to the client on success, nullptr on failure.
+ virtual std::unique_ptr<Socket> Accept() { return nullptr; }
protected:
// Protected constructor to force factory function use.
- UdpSocket() = default;
+ Socket(cutils_socket_t sock);
- DISALLOW_COPY_AND_ASSIGN(UdpSocket);
+ // Update the socket receive timeout if necessary.
+ bool SetReceiveTimeout(int timeout_ms);
+
+ cutils_socket_t sock_ = INVALID_SOCKET;
+
+ private:
+ int receive_timeout_ms_ = 0;
+
+ DISALLOW_COPY_AND_ASSIGN(Socket);
};
#endif // SOCKET_H_
diff --git a/fastboot/socket_test.cpp b/fastboot/socket_test.cpp
index 6ada964..1fd9d7c 100644
--- a/fastboot/socket_test.cpp
+++ b/fastboot/socket_test.cpp
@@ -14,184 +14,113 @@
* limitations under the License.
*/
-// Tests UDP functionality using loopback connections. Requires that kDefaultPort is available
+// Tests UDP functionality using loopback connections. Requires that kTestPort is available
// for loopback communication on the host. These tests also assume that no UDP packets are lost,
// which should be the case for loopback communication, but is not guaranteed.
#include "socket.h"
-#include <errno.h>
-#include <time.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
#include <gtest/gtest.h>
enum {
// This port must be available for loopback communication.
- kDefaultPort = 54321,
+ kTestPort = 54321,
// Don't wait forever in a unit test.
- kDefaultTimeoutMs = 3000,
+ kTestTimeoutMs = 3000,
};
-static const char kReceiveStringError[] = "Error receiving string";
-
-// Test fixture to provide some helper functions. Makes each test a little simpler since we can
-// just check a bool for socket creation and don't have to pass hostname or port information.
-class SocketTest : public ::testing::Test {
- protected:
- bool StartServer(int port = kDefaultPort) {
- server_ = UdpSocket::NewUdpServer(port);
- return server_ != nullptr;
+// Creates connected sockets |server| and |client|. Returns true on success.
+bool MakeConnectedSockets(Socket::Protocol protocol, std::unique_ptr<Socket>* server,
+ std::unique_ptr<Socket>* client, const std::string hostname = "localhost",
+ int port = kTestPort) {
+ *server = Socket::NewServer(protocol, port);
+ if (*server == nullptr) {
+ ADD_FAILURE() << "Failed to create server.";
+ return false;
}
- bool StartClient(const std::string hostname = "localhost", int port = kDefaultPort) {
- client_ = UdpSocket::NewUdpClient(hostname, port, nullptr);
- return client_ != nullptr;
+ *client = Socket::NewClient(protocol, hostname, port, nullptr);
+ if (*client == nullptr) {
+ ADD_FAILURE() << "Failed to create client.";
+ return false;
}
- bool StartClient2(const std::string hostname = "localhost", int port = kDefaultPort) {
- client2_ = UdpSocket::NewUdpClient(hostname, port, nullptr);
- return client2_ != nullptr;
+ // TCP passes the client off to a new socket.
+ if (protocol == Socket::Protocol::kTcp) {
+ *server = (*server)->Accept();
+ if (*server == nullptr) {
+ ADD_FAILURE() << "Failed to accept client connection.";
+ return false;
+ }
}
- std::unique_ptr<UdpSocket> server_, client_, client2_;
-};
+ return true;
+}
-// Sends a string over a UdpSocket. Returns true if the full string (without terminating char)
+// Sends a string over a Socket. Returns true if the full string (without terminating char)
// was sent.
-static bool SendString(UdpSocket* udp, const std::string& message) {
- return udp->Send(message.c_str(), message.length()) == static_cast<ssize_t>(message.length());
+static bool SendString(Socket* sock, const std::string& message) {
+ return sock->Send(message.c_str(), message.length()) == static_cast<ssize_t>(message.length());
}
-// Receives a string from a UdpSocket. Returns the string, or kReceiveStringError on failure.
-static std::string ReceiveString(UdpSocket* udp, size_t receive_size = 128) {
- std::vector<char> buffer(receive_size);
-
- ssize_t result = udp->Receive(buffer.data(), buffer.size(), kDefaultTimeoutMs);
- if (result >= 0) {
- return std::string(buffer.data(), result);
- }
- return kReceiveStringError;
-}
-
-// Calls Receive() on the UdpSocket with the given timeout. Returns true if the call timed out.
-static bool ReceiveTimeout(UdpSocket* udp, int timeout_ms) {
- char buffer[1];
-
- errno = 0;
- return udp->Receive(buffer, 1, timeout_ms) == -1 && (errno == EAGAIN || errno == EWOULDBLOCK);
+// Receives a string from a Socket. Returns true if the full string (without terminating char)
+// was received.
+static bool ReceiveString(Socket* sock, const std::string& message) {
+ std::string received(message.length(), '\0');
+ ssize_t bytes = sock->ReceiveAll(&received[0], received.length(), kTestTimeoutMs);
+ return static_cast<size_t>(bytes) == received.length() && received == message;
}
// Tests sending packets client -> server, then server -> client.
-TEST_F(SocketTest, SendAndReceive) {
- ASSERT_TRUE(StartServer());
- ASSERT_TRUE(StartClient());
+TEST(SocketTest, TestSendAndReceive) {
+ std::unique_ptr<Socket> server, client;
- EXPECT_TRUE(SendString(client_.get(), "foo"));
- EXPECT_EQ("foo", ReceiveString(server_.get()));
+ for (Socket::Protocol protocol : {Socket::Protocol::kUdp, Socket::Protocol::kTcp}) {
+ ASSERT_TRUE(MakeConnectedSockets(protocol, &server, &client));
- EXPECT_TRUE(SendString(server_.get(), "bar baz"));
- EXPECT_EQ("bar baz", ReceiveString(client_.get()));
+ EXPECT_TRUE(SendString(client.get(), "foo"));
+ EXPECT_TRUE(ReceiveString(server.get(), "foo"));
+
+ EXPECT_TRUE(SendString(server.get(), "bar baz"));
+ EXPECT_TRUE(ReceiveString(client.get(), "bar baz"));
+ }
}
// Tests sending and receiving large packets.
-TEST_F(SocketTest, LargePackets) {
- std::string message(512, '\0');
+TEST(SocketTest, TestLargePackets) {
+ std::string message(1024, '\0');
+ std::unique_ptr<Socket> server, client;
- ASSERT_TRUE(StartServer());
- ASSERT_TRUE(StartClient());
+ for (Socket::Protocol protocol : {Socket::Protocol::kUdp, Socket::Protocol::kTcp}) {
+ ASSERT_TRUE(MakeConnectedSockets(protocol, &server, &client));
- // Run through the test a few times.
- for (int i = 0; i < 10; ++i) {
- // Use a different message each iteration to prevent false positives.
- for (size_t j = 0; j < message.length(); ++j) {
- message[j] = static_cast<char>(i + j);
+ // Run through the test a few times.
+ for (int i = 0; i < 10; ++i) {
+ // Use a different message each iteration to prevent false positives.
+ for (size_t j = 0; j < message.length(); ++j) {
+ message[j] = static_cast<char>(i + j);
+ }
+
+ EXPECT_TRUE(SendString(client.get(), message));
+ EXPECT_TRUE(ReceiveString(server.get(), message));
}
-
- EXPECT_TRUE(SendString(client_.get(), message));
- EXPECT_EQ(message, ReceiveString(server_.get(), message.length()));
}
}
-// Tests IPv4 client/server.
-TEST_F(SocketTest, IPv4) {
- ASSERT_TRUE(StartServer());
- ASSERT_TRUE(StartClient("127.0.0.1"));
+// Tests UDP receive overflow when the UDP packet is larger than the receive buffer.
+TEST(SocketTest, TestUdpReceiveOverflow) {
+ std::unique_ptr<Socket> server, client;
+ ASSERT_TRUE(MakeConnectedSockets(Socket::Protocol::kUdp, &server, &client));
- EXPECT_TRUE(SendString(client_.get(), "foo"));
- EXPECT_EQ("foo", ReceiveString(server_.get()));
+ EXPECT_TRUE(SendString(client.get(), "1234567890"));
- EXPECT_TRUE(SendString(server_.get(), "bar"));
- EXPECT_EQ("bar", ReceiveString(client_.get()));
-}
-
-// Tests IPv6 client/server.
-TEST_F(SocketTest, IPv6) {
- ASSERT_TRUE(StartServer());
- ASSERT_TRUE(StartClient("::1"));
-
- EXPECT_TRUE(SendString(client_.get(), "foo"));
- EXPECT_EQ("foo", ReceiveString(server_.get()));
-
- EXPECT_TRUE(SendString(server_.get(), "bar"));
- EXPECT_EQ("bar", ReceiveString(client_.get()));
-}
-
-// Tests receive timeout. The timing verification logic must be very coarse to make sure different
-// systems running different loads can all pass these tests.
-TEST_F(SocketTest, ReceiveTimeout) {
- time_t start_time;
-
- ASSERT_TRUE(StartServer());
-
- // Make sure a 20ms timeout completes in 1 second or less.
- start_time = time(nullptr);
- EXPECT_TRUE(ReceiveTimeout(server_.get(), 20));
- EXPECT_LE(difftime(time(nullptr), start_time), 1.0);
-
- // Make sure a 1250ms timeout takes 1 second or more.
- start_time = time(nullptr);
- EXPECT_TRUE(ReceiveTimeout(server_.get(), 1250));
- EXPECT_LE(1.0, difftime(time(nullptr), start_time));
-}
-
-// Tests receive overflow (the UDP packet is larger than the receive buffer).
-TEST_F(SocketTest, ReceiveOverflow) {
- ASSERT_TRUE(StartServer());
- ASSERT_TRUE(StartClient());
-
- EXPECT_TRUE(SendString(client_.get(), "1234567890"));
-
- // This behaves differently on different systems; some give us a truncated UDP packet, others
- // will error out and not return anything at all.
- std::string rx_string = ReceiveString(server_.get(), 5);
-
- // If we didn't get an error then the packet should have been truncated.
- if (rx_string != kReceiveStringError) {
- EXPECT_EQ("12345", rx_string);
+ // This behaves differently on different systems, either truncating the packet or returning -1.
+ char buffer[5];
+ ssize_t bytes = server->Receive(buffer, 5, kTestTimeoutMs);
+ if (bytes == 5) {
+ EXPECT_EQ(0, memcmp(buffer, "12345", 5));
+ } else {
+ EXPECT_EQ(-1, bytes);
}
}
-
-// Tests multiple clients sending to the same server.
-TEST_F(SocketTest, MultipleClients) {
- ASSERT_TRUE(StartServer());
- ASSERT_TRUE(StartClient());
- ASSERT_TRUE(StartClient2());
-
- EXPECT_TRUE(SendString(client_.get(), "client"));
- EXPECT_TRUE(SendString(client2_.get(), "client2"));
-
- // Receive the packets and send a response for each (note that packets may be received
- // out-of-order).
- for (int i = 0; i < 2; ++i) {
- std::string received = ReceiveString(server_.get());
- EXPECT_TRUE(SendString(server_.get(), received + " response"));
- }
-
- EXPECT_EQ("client response", ReceiveString(client_.get()));
- EXPECT_EQ("client2 response", ReceiveString(client2_.get()));
-}
diff --git a/fastboot/socket_unix.cpp b/fastboot/socket_unix.cpp
deleted file mode 100644
index 462256a..0000000
--- a/fastboot/socket_unix.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include "socket.h"
-
-#include <errno.h>
-#include <netdb.h>
-
-#include <android-base/stringprintf.h>
-#include <cutils/sockets.h>
-
-class UnixUdpSocket : public UdpSocket {
- public:
- enum class Type { kClient, kServer };
-
- UnixUdpSocket(int fd, Type type);
- ~UnixUdpSocket() override;
-
- ssize_t Send(const void* data, size_t length) override;
- ssize_t Receive(void* data, size_t length, int timeout_ms) override;
- int Close() override;
-
- private:
- int fd_;
- int receive_timeout_ms_ = 0;
- std::unique_ptr<sockaddr_storage> addr_;
- socklen_t addr_size_ = 0;
-
- DISALLOW_COPY_AND_ASSIGN(UnixUdpSocket);
-};
-
-UnixUdpSocket::UnixUdpSocket(int fd, Type type) : fd_(fd) {
- // Only servers need to remember addresses; clients are connected to a server in NewUdpClient()
- // so will send to that server without needing to specify the address again.
- if (type == Type::kServer) {
- addr_.reset(new sockaddr_storage);
- addr_size_ = sizeof(*addr_);
- memset(addr_.get(), 0, addr_size_);
- }
-}
-
-UnixUdpSocket::~UnixUdpSocket() {
- Close();
-}
-
-ssize_t UnixUdpSocket::Send(const void* data, size_t length) {
- return TEMP_FAILURE_RETRY(
- sendto(fd_, data, length, 0, reinterpret_cast<sockaddr*>(addr_.get()), addr_size_));
-}
-
-ssize_t UnixUdpSocket::Receive(void* data, size_t length, int timeout_ms) {
- // Only set socket timeout if it's changed.
- if (receive_timeout_ms_ != timeout_ms) {
- timeval tv;
- tv.tv_sec = timeout_ms / 1000;
- tv.tv_usec = (timeout_ms % 1000) * 1000;
- if (setsockopt(fd_, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
- return -1;
- }
- receive_timeout_ms_ = timeout_ms;
- }
-
- socklen_t* addr_size_ptr = nullptr;
- if (addr_ != nullptr) {
- // Reset addr_size as it may have been modified by previous recvfrom() calls.
- addr_size_ = sizeof(*addr_);
- addr_size_ptr = &addr_size_;
- }
- return TEMP_FAILURE_RETRY(recvfrom(fd_, data, length, 0,
- reinterpret_cast<sockaddr*>(addr_.get()), addr_size_ptr));
-}
-
-int UnixUdpSocket::Close() {
- int result = 0;
- if (fd_ != -1) {
- result = close(fd_);
- fd_ = -1;
- }
- return result;
-}
-
-std::unique_ptr<UdpSocket> UdpSocket::NewUdpClient(const std::string& host, int port,
- std::string* error) {
- int getaddrinfo_error = 0;
- int fd = socket_network_client_timeout(host.c_str(), port, SOCK_DGRAM, 0, &getaddrinfo_error);
- if (fd == -1) {
- if (error) {
- *error = android::base::StringPrintf(
- "Failed to connect to %s:%d: %s", host.c_str(), port,
- getaddrinfo_error ? gai_strerror(getaddrinfo_error) : strerror(errno));
- }
- return nullptr;
- }
-
- return std::unique_ptr<UdpSocket>(new UnixUdpSocket(fd, UnixUdpSocket::Type::kClient));
-}
-
-std::unique_ptr<UdpSocket> UdpSocket::NewUdpServer(int port) {
- int fd = socket_inaddr_any_server(port, SOCK_DGRAM);
- if (fd == -1) {
- // This is just used in testing, no need for an error message.
- return nullptr;
- }
-
- return std::unique_ptr<UdpSocket>(new UnixUdpSocket(fd, UnixUdpSocket::Type::kServer));
-}
diff --git a/fastboot/socket_windows.cpp b/fastboot/socket_windows.cpp
deleted file mode 100644
index 4ad379f..0000000
--- a/fastboot/socket_windows.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include "socket.h"
-
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#include <memory>
-
-#include <android-base/stringprintf.h>
-
-// Windows UDP socket functionality.
-class WindowsUdpSocket : public UdpSocket {
- public:
- enum class Type { kClient, kServer };
-
- WindowsUdpSocket(SOCKET sock, Type type);
- ~WindowsUdpSocket() override;
-
- ssize_t Send(const void* data, size_t len) override;
- ssize_t Receive(void* data, size_t len, int timeout_ms) override;
- int Close() override;
-
- private:
- SOCKET sock_;
- int receive_timeout_ms_ = 0;
- std::unique_ptr<sockaddr_storage> addr_;
- int addr_size_ = 0;
-
- DISALLOW_COPY_AND_ASSIGN(WindowsUdpSocket);
-};
-
-WindowsUdpSocket::WindowsUdpSocket(SOCKET sock, Type type) : sock_(sock) {
- // Only servers need to remember addresses; clients are connected to a server in NewUdpClient()
- // so will send to that server without needing to specify the address again.
- if (type == Type::kServer) {
- addr_.reset(new sockaddr_storage);
- addr_size_ = sizeof(*addr_);
- memset(addr_.get(), 0, addr_size_);
- }
-}
-
-WindowsUdpSocket::~WindowsUdpSocket() {
- Close();
-}
-
-ssize_t WindowsUdpSocket::Send(const void* data, size_t len) {
- return sendto(sock_, reinterpret_cast<const char*>(data), len, 0,
- reinterpret_cast<sockaddr*>(addr_.get()), addr_size_);
-}
-
-ssize_t WindowsUdpSocket::Receive(void* data, size_t len, int timeout_ms) {
- // Only set socket timeout if it's changed.
- if (receive_timeout_ms_ != timeout_ms) {
- if (setsockopt(sock_, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<const char*>(&timeout_ms),
- sizeof(timeout_ms)) < 0) {
- return -1;
- }
- receive_timeout_ms_ = timeout_ms;
- }
-
- int* addr_size_ptr = nullptr;
- if (addr_ != nullptr) {
- // Reset addr_size as it may have been modified by previous recvfrom() calls.
- addr_size_ = sizeof(*addr_);
- addr_size_ptr = &addr_size_;
- }
- int result = recvfrom(sock_, reinterpret_cast<char*>(data), len, 0,
- reinterpret_cast<sockaddr*>(addr_.get()), addr_size_ptr);
- if (result < 0 && WSAGetLastError() == WSAETIMEDOUT) {
- errno = EAGAIN;
- }
- return result;
-}
-
-int WindowsUdpSocket::Close() {
- int result = 0;
- if (sock_ != INVALID_SOCKET) {
- result = closesocket(sock_);
- sock_ = INVALID_SOCKET;
- }
- return result;
-}
-
-static int GetProtocol(int sock_type) {
- switch (sock_type) {
- case SOCK_DGRAM:
- return IPPROTO_UDP;
- case SOCK_STREAM:
- return IPPROTO_TCP;
- default:
- // 0 lets the system decide which protocol to use.
- return 0;
- }
-}
-
-// Windows implementation of this libcutils function. This function does not make any calls to
-// WSAStartup() or WSACleanup() so that must be handled by the caller.
-// TODO(dpursell): share this code with adb.
-static SOCKET socket_network_client(const std::string& host, int port, int type) {
- // First resolve the host and port parameters into a usable network address.
- addrinfo hints;
- memset(&hints, 0, sizeof(hints));
- hints.ai_socktype = type;
- hints.ai_protocol = GetProtocol(type);
-
- addrinfo* address = nullptr;
- getaddrinfo(host.c_str(), android::base::StringPrintf("%d", port).c_str(), &hints, &address);
- if (address == nullptr) {
- return INVALID_SOCKET;
- }
-
- // Now create and connect the socket.
- SOCKET sock = socket(address->ai_family, address->ai_socktype, address->ai_protocol);
- if (sock == INVALID_SOCKET) {
- freeaddrinfo(address);
- return INVALID_SOCKET;
- }
-
- if (connect(sock, address->ai_addr, address->ai_addrlen) == SOCKET_ERROR) {
- closesocket(sock);
- freeaddrinfo(address);
- return INVALID_SOCKET;
- }
-
- freeaddrinfo(address);
- return sock;
-}
-
-// Windows implementation of this libcutils function. This implementation creates a dual-stack
-// server socket that can accept incoming IPv4 or IPv6 packets. This function does not make any
-// calls to WSAStartup() or WSACleanup() so that must be handled by the caller.
-// TODO(dpursell): share this code with adb.
-static SOCKET socket_inaddr_any_server(int port, int type) {
- SOCKET sock = socket(AF_INET6, type, GetProtocol(type));
- if (sock == INVALID_SOCKET) {
- return INVALID_SOCKET;
- }
-
- // Enforce exclusive addresses (1), and enable dual-stack so both IPv4 and IPv6 work (2).
- // (1) https://msdn.microsoft.com/en-us/library/windows/desktop/ms740621(v=vs.85).aspx.
- // (2) https://msdn.microsoft.com/en-us/library/windows/desktop/bb513665(v=vs.85).aspx.
- int exclusive = 1;
- DWORD v6_only = 0;
- if (setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, reinterpret_cast<const char*>(&exclusive),
- sizeof(exclusive)) == SOCKET_ERROR ||
- setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char*>(&v6_only),
- sizeof(v6_only)) == SOCKET_ERROR) {
- closesocket(sock);
- return INVALID_SOCKET;
- }
-
- // Bind the socket to our local port.
- sockaddr_in6 addr;
- memset(&addr, 0, sizeof(addr));
- addr.sin6_family = AF_INET6;
- addr.sin6_port = htons(port);
- addr.sin6_addr = in6addr_any;
- if (bind(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == SOCKET_ERROR) {
- closesocket(sock);
- return INVALID_SOCKET;
- }
-
- return sock;
-}
-
-// Documentation at https://msdn.microsoft.com/en-us/library/windows/desktop/ms741549(v=vs.85).aspx
-// claims WSACleanup() should be called before program exit, but general consensus seems to be that
-// it hasn't actually been necessary for a long time, possibly since Windows 3.1.
-//
-// Both adb (1) and Chrome (2) purposefully avoid WSACleanup(), and since no adverse affects have
-// been found we may as well do the same here to keep this code simpler.
-// (1) https://android.googlesource.com/platform/system/core.git/+/master/adb/sysdeps_win32.cpp#816
-// (2) https://code.google.com/p/chromium/codesearch#chromium/src/net/base/winsock_init.cc&l=35
-static bool InitWinsock() {
- static bool init_success = false;
-
- if (!init_success) {
- WSADATA wsaData;
- init_success = (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0);
- }
-
- return init_success;
-}
-
-std::unique_ptr<UdpSocket> UdpSocket::NewUdpClient(const std::string& host, int port,
- std::string* error) {
- if (!InitWinsock()) {
- if (error) {
- *error = android::base::StringPrintf("Failed to initialize Winsock (error %d)",
- WSAGetLastError());
- }
- return nullptr;
- }
-
- SOCKET sock = socket_network_client(host, port, SOCK_DGRAM);
- if (sock == INVALID_SOCKET) {
- if (error) {
- *error = android::base::StringPrintf("Failed to connect to %s:%d (error %d)",
- host.c_str(), port, WSAGetLastError());
- }
- return nullptr;
- }
-
- return std::unique_ptr<UdpSocket>(new WindowsUdpSocket(sock, WindowsUdpSocket::Type::kClient));
-}
-
-// This functionality is currently only used by tests so we don't need any error messages.
-std::unique_ptr<UdpSocket> UdpSocket::NewUdpServer(int port) {
- if (!InitWinsock()) {
- return nullptr;
- }
-
- SOCKET sock = socket_inaddr_any_server(port, SOCK_DGRAM);
- if (sock == INVALID_SOCKET) {
- return nullptr;
- }
-
- return std::unique_ptr<UdpSocket>(new WindowsUdpSocket(sock, WindowsUdpSocket::Type::kServer));
-}
diff --git a/include/cutils/sockets.h b/include/cutils/sockets.h
index 2d3c743..e25c555 100644
--- a/include/cutils/sockets.h
+++ b/include/cutils/sockets.h
@@ -24,10 +24,20 @@
#include <stdbool.h>
#if defined(_WIN32)
+
#include <winsock2.h>
+#include <ws2tcpip.h>
+
typedef int socklen_t;
+typedef SOCKET cutils_socket_t;
+
#else
+
#include <sys/socket.h>
+
+typedef int cutils_socket_t;
+#define INVALID_SOCKET (-1)
+
#endif
#define ANDROID_SOCKET_ENV_PREFIX "ANDROID_SOCKET_"
@@ -45,7 +55,7 @@
* This is inline and not in libcutils proper because we want to use this in
* third-party daemons with minimal modification.
*/
-static inline int android_get_control_socket(const char *name)
+static inline int android_get_control_socket(const char* name)
{
char key[64];
snprintf(key, sizeof(key), ANDROID_SOCKET_ENV_PREFIX "%s", name);
@@ -74,17 +84,52 @@
// Normal filesystem namespace
#define ANDROID_SOCKET_NAMESPACE_FILESYSTEM 2
-extern int socket_loopback_client(int port, int type);
-extern int socket_network_client(const char *host, int port, int type);
-extern int socket_network_client_timeout(const char *host, int port, int type,
- int timeout, int* getaddrinfo_error);
-extern int socket_loopback_server(int port, int type);
-extern int socket_local_server(const char *name, int namespaceId, int type);
-extern int socket_local_server_bind(int s, const char *name, int namespaceId);
-extern int socket_local_client_connect(int fd,
- const char *name, int namespaceId, int type);
-extern int socket_local_client(const char *name, int namespaceId, int type);
-extern int socket_inaddr_any_server(int port, int type);
+/*
+ * Functions to create sockets for some common usages.
+ *
+ * All these functions are implemented for Unix, but only a few are implemented
+ * for Windows. Those which are can be identified by the cutils_socket_t
+ * return type. The idea is to be able to use this return value with the
+ * standard Unix socket functions on any platform.
+ *
+ * On Unix the returned cutils_socket_t is a standard int file descriptor and
+ * can always be used as normal with all file descriptor functions.
+ *
+ * On Windows utils_socket_t is an unsigned int pointer, and is only valid
+ * with functions that specifically take a socket, e.g. send(), sendto(),
+ * recv(), and recvfrom(). General file descriptor functions such as read(),
+ * write(), and close() will not work with utils_socket_t and will require
+ * special handling.
+ *
+ * These functions return INVALID_SOCKET (-1) on failure for all platforms.
+ */
+int socket_loopback_client(int port, int type);
+cutils_socket_t socket_network_client(const char* host, int port, int type);
+int socket_network_client_timeout(const char* host, int port, int type,
+ int timeout, int* getaddrinfo_error);
+int socket_loopback_server(int port, int type);
+int socket_local_server(const char* name, int namespaceId, int type);
+int socket_local_server_bind(int s, const char* name, int namespaceId);
+int socket_local_client_connect(int fd, const char *name, int namespaceId,
+ int type);
+int socket_local_client(const char* name, int namespaceId, int type);
+cutils_socket_t socket_inaddr_any_server(int port, int type);
+
+/*
+ * Closes a cutils_socket_t. Windows doesn't allow calling close() on a socket
+ * so this is a cross-platform way to close a cutils_socket_t.
+ *
+ * Returns 0 on success.
+ */
+int socket_close(cutils_socket_t sock);
+
+/*
+ * Sets socket receive timeout using SO_RCVTIMEO. Setting |timeout_ms| to 0
+ * disables receive timeouts.
+ *
+ * Return 0 on success.
+ */
+int socket_set_receive_timeout(cutils_socket_t sock, int timeout_ms);
/*
* socket_peer_is_trusted - Takes a socket which is presumed to be a
@@ -101,4 +146,4 @@
}
#endif
-#endif /* __CUTILS_SOCKETS_H */
+#endif /* __CUTILS_SOCKETS_H */
diff --git a/include/log/log.h b/include/log/log.h
index 3d9240d..1bd9165 100644
--- a/include/log/log.h
+++ b/include/log/log.h
@@ -585,14 +585,6 @@
(__android_log_is_loggable(prio, tag, ANDROID_LOG_VERBOSE) != 0)
#endif
-// TODO: remove these prototypes and their users
-#define android_writevLog(vec,num) do{}while(0)
-#define android_write1Log(str,len) do{}while (0)
-#define android_setMinPriority(tag, prio) do{}while(0)
-//#define android_logToCallback(func) do{}while(0)
-#define android_logToFile(tag, file) (0)
-#define android_logToFd(tag, fd) (0)
-
typedef enum log_id {
LOG_ID_MIN = 0,
diff --git a/include/log/logd.h b/include/log/logd.h
index b7aedaf..b271602 100644
--- a/include/log/logd.h
+++ b/include/log/logd.h
@@ -45,6 +45,7 @@
int __android_log_bswrite(int32_t tag, const char *payload);
int __android_log_security_bwrite(int32_t tag, const void *payload, size_t len);
+int __android_log_security_bswrite(int32_t tag, const char *payload);
#ifdef __cplusplus
}
diff --git a/include/private/android_filesystem_config.h b/include/private/android_filesystem_config.h
index 9876e34..85d6c19 100644
--- a/include/private/android_filesystem_config.h
+++ b/include/private/android_filesystem_config.h
@@ -87,6 +87,7 @@
#define AID_METRICSD 1043 /* metricsd process */
#define AID_WEBSERV 1044 /* webservd process */
#define AID_DEBUGGERD 1045 /* debuggerd unprivileged user */
+#define AID_MEDIA_CODEC 1046 /* mediacodec process */
#define AID_SHELL 2000 /* adb and debug shell user */
#define AID_CACHE 2001 /* cache access */
@@ -192,6 +193,7 @@
{ "metricsd", AID_METRICSD },
{ "webserv", AID_WEBSERV },
{ "debuggerd", AID_DEBUGGERD, },
+ { "mediacodec", AID_MEDIA_CODEC, },
{ "shell", AID_SHELL, },
{ "cache", AID_CACHE, },
diff --git a/include/ziparchive/zip_archive_stream_entry.h b/include/ziparchive/zip_archive_stream_entry.h
new file mode 100644
index 0000000..a40b799
--- /dev/null
+++ b/include/ziparchive/zip_archive_stream_entry.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+// Read-only stream access to Zip archives entries.
+#ifndef LIBZIPARCHIVE_ZIPARCHIVESTREAMENTRY_H_
+#define LIBZIPARCHIVE_ZIPARCHIVESTREAMENTRY_H_
+
+#include <vector>
+
+#include <ziparchive/zip_archive.h>
+
+class ZipArchiveStreamEntry {
+ public:
+ virtual ~ZipArchiveStreamEntry() {}
+
+ virtual const std::vector<uint8_t>* Read() = 0;
+
+ virtual bool Verify() = 0;
+
+ static ZipArchiveStreamEntry* Create(ZipArchiveHandle handle, const ZipEntry& entry);
+ static ZipArchiveStreamEntry* CreateRaw(ZipArchiveHandle handle, const ZipEntry& entry);
+
+ protected:
+ ZipArchiveStreamEntry(ZipArchiveHandle handle) : handle_(handle) {}
+
+ virtual bool Init(const ZipEntry& entry);
+
+ ZipArchiveHandle handle_;
+
+ uint32_t crc32_;
+};
+
+#endif // LIBZIPARCHIVE_ZIPARCHIVESTREAMENTRY_H_
diff --git a/include/ziparchive/zip_writer.h b/include/ziparchive/zip_writer.h
index 0efade8..0b6ede4 100644
--- a/include/ziparchive/zip_writer.h
+++ b/include/ziparchive/zip_writer.h
@@ -87,11 +87,27 @@
int32_t StartEntry(const char* path, size_t flags);
/**
+ * Starts a new zip entry with the given path and flags, where the
+ * entry will be aligned to the given alignment.
+ * Flags can only be ZipWriter::kCompress. Using the flag ZipWriter::kAlign32
+ * will result in an error.
+ * Subsequent calls to WriteBytes(const void*, size_t) will add data to this entry.
+ * Returns 0 on success, and an error value < 0 on failure.
+ */
+ int32_t StartAlignedEntry(const char* path, size_t flags, uint32_t alignment);
+
+ /**
* Same as StartEntry(const char*, size_t), but sets a last modified time for the entry.
*/
int32_t StartEntryWithTime(const char* path, size_t flags, time_t time);
/**
+ * Same as StartAlignedEntry(const char*, size_t), but sets a last modified time for the entry.
+ */
+ int32_t StartAlignedEntryWithTime(const char* path, size_t flags, time_t time,
+ uint32_t alignment);
+
+ /**
* Writes bytes to the zip file for the previously started zip entry.
* Returns 0 on success, and an error value < 0 on failure.
*/
diff --git a/init/builtins.cpp b/init/builtins.cpp
index d2291bb..35f1a9e 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -418,20 +418,32 @@
while (1) { pause(); } // never reached
}
-static void import_late() {
- static const std::vector<std::string> init_directories = {
- "/system/etc/init",
- "/vendor/etc/init",
- "/odm/etc/init"
- };
-
+/* Imports .rc files from the specified paths. Default ones are applied if none is given.
+ *
+ * start_index: index of the first path in the args list
+ */
+static void import_late(const std::vector<std::string>& args, size_t start_index) {
Parser& parser = Parser::GetInstance();
- for (const auto& dir : init_directories) {
- parser.ParseConfig(dir.c_str());
+ if (args.size() <= start_index) {
+ // Use the default set if no path is given
+ static const std::vector<std::string> init_directories = {
+ "/system/etc/init",
+ "/vendor/etc/init",
+ "/odm/etc/init"
+ };
+
+ for (const auto& dir : init_directories) {
+ parser.ParseConfig(dir);
+ }
+ } else {
+ for (size_t i = start_index; i < args.size(); ++i) {
+ parser.ParseConfig(args[i]);
+ }
}
}
-/*
+/* mount_all <fstab> [ <path> ]*
+ *
* This function might request a reboot, in which case it will
* not return.
*/
@@ -478,7 +490,8 @@
return -1;
}
- import_late();
+ /* Paths of .rc files are specified at the 2nd argument and beyond */
+ import_late(args, 2);
if (ret == FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION) {
property_set("vold.decrypt", "trigger_encryption");
@@ -900,7 +913,7 @@
{"load_system_props", {0, 0, do_load_system_props}},
{"loglevel", {1, 1, do_loglevel}},
{"mkdir", {1, 4, do_mkdir}},
- {"mount_all", {1, 1, do_mount_all}},
+ {"mount_all", {1, kMax, do_mount_all}},
{"mount", {3, kMax, do_mount}},
{"powerctl", {1, 1, do_powerctl}},
{"restart", {1, 1, do_restart}},
diff --git a/init/log.cpp b/init/log.cpp
index a72906b..ace9fd7 100644
--- a/init/log.cpp
+++ b/init/log.cpp
@@ -27,6 +27,8 @@
static void init_klog_vwrite(int level, const char* fmt, va_list ap) {
static const char* tag = basename(getprogname());
+ if (level > klog_get_level()) return;
+
// The kernel's printk buffer is only 1024 bytes.
// TODO: should we automatically break up long lines into multiple lines?
// Or we could log but with something like "..." at the end?
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 806608e..5c1ae79 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -113,18 +113,6 @@
return check_mac_perms(ctl_name, sctx, cr);
}
-/*
- * Checks permissions for setting system properties.
- * Returns 1 if uid allowed, 0 otherwise.
- */
-static int check_perms(const char *name, char *sctx, struct ucred *cr)
-{
- if(!strncmp(name, "ro.", 3))
- name +=3;
-
- return check_mac_perms(name, sctx, cr);
-}
-
std::string property_get(const char* name) {
char value[PROP_VALUE_MAX] = {0};
__system_property_get(name, value);
@@ -312,7 +300,7 @@
msg.name + 4, msg.value, cr.uid, cr.gid, cr.pid);
}
} else {
- if (check_perms(msg.name, source_ctx, &cr)) {
+ if (check_mac_perms(msg.name, source_ctx, &cr)) {
property_set((char*) msg.name, (char*) msg.value);
} else {
ERROR("sys_prop: permission denied uid:%d name:%s\n",
diff --git a/init/readme.txt b/init/readme.txt
index bacd6bd..ef85ccf 100644
--- a/init/readme.txt
+++ b/init/readme.txt
@@ -40,15 +40,43 @@
These directories are intended for all Actions and Services used after
file system mounting.
+One may specify paths in the mount_all command line to have it import
+.rc files at the specified paths instead of the default ones listed above.
+This is primarily for supporting factory mode and other non-standard boot
+modes. The three default paths should be used for the normal boot process.
+
The intention of these directories is as follows
1) /system/etc/init/ is for core system items such as
- SurfaceFlinger and MediaService.
+ SurfaceFlinger, MediaService, and logcatd.
2) /vendor/etc/init/ is for SoC vendor items such as actions or
daemons needed for core SoC functionality.
3) /odm/etc/init/ is for device manufacturer items such as
actions or daemons needed for motion sensor or other peripheral
functionality.
+All services whose binaries reside on the system, vendor, or odm
+partitions should have their service entries placed into a
+corresponding init .rc file, located in the /etc/init/
+directory of the partition where they reside. There is a build
+system macro, LOCAL_INIT_RC, that handles this for developers. Each
+init .rc file should additionally contain any actions associated with
+its service.
+
+An example is the logcatd.rc and Android.mk files located in the
+system/core/logcat directory. The LOCAL_INIT_RC macro in the
+Android.mk file places logcatd.rc in /system/etc/init/ during the
+build process. Init loads logcatd.rc during the mount_all command and
+allows the service to be run and the action to be queued when
+appropriate.
+
+This break up of init .rc files according to their daemon is preferred
+to the previously used monolithic init .rc files. This approach
+ensures that the only service entries that init reads and the only
+actions that init performs correspond to services whose binaries are in
+fact present on the file system, which was not the case with the
+monolithic init .rc files. This additionally will aid in merge
+conflict resolution when multiple services are added to the system, as
+each one will go into a separate file.
Actions
-------
@@ -263,8 +291,10 @@
owned by the root user and root group. If provided, the mode, owner and group
will be updated if the directory exists already.
-mount_all <fstab>
- Calls fs_mgr_mount_all on the given fs_mgr-format fstab.
+mount_all <fstab> [ <path> ]*
+ Calls fs_mgr_mount_all on the given fs_mgr-format fstab and imports .rc files
+ at the specified paths (e.g., on the partitions just mounted). Refer to the
+ section of "Init .rc Files" for detail.
mount <type> <device> <dir> [ <flag> ]* [<options>]
Attempt to mount the named device at the directory <dir>
@@ -358,7 +388,8 @@
There are only two times where the init executable imports .rc files,
1) When it imports /init.rc during initial boot
- 2) When it imports /{system,vendor,odm}/etc/init/ during mount_all
+ 2) When it imports /{system,vendor,odm}/etc/init/ or .rc files at specified
+ paths during mount_all
Properties
diff --git a/libbacktrace/Android.mk b/libbacktrace/Android.mk
index 5d3dd86..6cffb11 100644
--- a/libbacktrace/Android.mk
+++ b/libbacktrace/Android.mk
@@ -48,7 +48,6 @@
Backtrace.cpp \
BacktraceCurrent.cpp \
BacktraceMap.cpp \
- BacktraceOffline.cpp \
BacktracePtrace.cpp \
thread_utils.c \
ThreadEntry.cpp \
@@ -61,25 +60,6 @@
liblog \
libunwind \
-# Use shared llvm library on device to save space.
-libbacktrace_shared_libraries_target := \
- libLLVM \
-
-# Use static llvm libraries on host to remove dependency on 32-bit llvm shared library
-# which is not included in the prebuilt.
-libbacktrace_static_libraries_host := \
- libcutils \
- libLLVMObject \
- libLLVMBitReader \
- libLLVMMC \
- libLLVMMCParser \
- libLLVMCore \
- libLLVMSupport \
-
-libbacktrace_ldlibs_host := \
- -lpthread \
- -lrt \
-
module := libbacktrace
module_tag := optional
build_type := target
@@ -98,6 +78,40 @@
libbacktrace_static_libraries :=
#-------------------------------------------------------------------------
+# The libbacktrace_offline shared library.
+#-------------------------------------------------------------------------
+libbacktrace_offline_src_files := \
+ BacktraceOffline.cpp \
+
+libbacktrace_offline_shared_libraries := \
+ libbacktrace \
+ liblog \
+ libunwind \
+
+# Use shared llvm library on device to save space.
+libbacktrace_offline_shared_libraries_target := \
+ libLLVM \
+
+# Use static llvm libraries on host to remove dependency on 32-bit llvm shared library
+# which is not included in the prebuilt.
+libbacktrace_offline_static_libraries_host := \
+ libLLVMObject \
+ libLLVMBitReader \
+ libLLVMMC \
+ libLLVMMCParser \
+ libLLVMCore \
+ libLLVMSupport \
+
+module := libbacktrace_offline
+module_tag := optional
+build_type := target
+build_target := SHARED_LIBRARY
+include $(LOCAL_PATH)/Android.build.mk
+build_type := host
+libbacktrace_multilib := both
+include $(LOCAL_PATH)/Android.build.mk
+
+#-------------------------------------------------------------------------
# The libbacktrace_test library needed by backtrace_test.
#-------------------------------------------------------------------------
libbacktrace_test_cflags := \
@@ -141,6 +155,7 @@
backtrace_test_shared_libraries := \
libbacktrace_test \
libbacktrace \
+ libbacktrace_offline \
libbase \
libcutils \
libunwind \
diff --git a/libbacktrace/Backtrace.cpp b/libbacktrace/Backtrace.cpp
index 3c8f879..baa3d0f 100644
--- a/libbacktrace/Backtrace.cpp
+++ b/libbacktrace/Backtrace.cpp
@@ -28,7 +28,6 @@
#include <backtrace/BacktraceMap.h>
#include "BacktraceLog.h"
-#include "BacktraceOffline.h"
#include "thread_utils.h"
#include "UnwindCurrent.h"
#include "UnwindPtrace.h"
@@ -149,8 +148,3 @@
return new UnwindPtrace(pid, tid, map);
}
}
-
-Backtrace* Backtrace::CreateOffline(pid_t pid, pid_t tid, BacktraceMap* map,
- const backtrace_stackinfo_t& stack, bool cache_file) {
- return new BacktraceOffline(pid, tid, map, stack, cache_file);
-}
diff --git a/libbacktrace/BacktraceOffline.cpp b/libbacktrace/BacktraceOffline.cpp
index abc186b..e84ae74 100644
--- a/libbacktrace/BacktraceOffline.cpp
+++ b/libbacktrace/BacktraceOffline.cpp
@@ -659,3 +659,8 @@
}
return nullptr;
}
+
+Backtrace* Backtrace::CreateOffline(pid_t pid, pid_t tid, BacktraceMap* map,
+ const backtrace_stackinfo_t& stack, bool cache_file) {
+ return new BacktraceOffline(pid, tid, map, stack, cache_file);
+}
diff --git a/libbacktrace/backtrace_test.cpp b/libbacktrace/backtrace_test.cpp
index 23636db..7d829fe 100644
--- a/libbacktrace/backtrace_test.cpp
+++ b/libbacktrace/backtrace_test.cpp
@@ -1156,7 +1156,7 @@
int fd = open(tmp_so_name, O_RDONLY);
ASSERT_TRUE(fd != -1);
- void* map = mmap(NULL, map_size, PROT_READ, MAP_PRIVATE, fd, 0);
+ void* map = mmap(NULL, map_size, PROT_READ | PROT_EXEC, MAP_PRIVATE, fd, 0);
ASSERT_TRUE(map != MAP_FAILED);
close(fd);
ASSERT_TRUE(unlink(tmp_so_name) != -1);
@@ -1206,7 +1206,7 @@
exit(0);
}
- void* map = mmap(NULL, map_size, PROT_READ, MAP_PRIVATE, fd, 0);
+ void* map = mmap(NULL, map_size, PROT_READ | PROT_EXEC, MAP_PRIVATE, fd, 0);
if (map == MAP_FAILED) {
fprintf(stderr, "Failed to map in memory: %s\n", strerror(errno));
unlink(tmp_so_name);
diff --git a/libcutils/Android.mk b/libcutils/Android.mk
index dd08108..25b056b 100644
--- a/libcutils/Android.mk
+++ b/libcutils/Android.mk
@@ -39,26 +39,33 @@
libcutils_nonwindows_sources := \
fs.c \
multiuser.c \
- socket_inaddr_any_server.c \
- socket_local_client.c \
- socket_local_server.c \
- socket_loopback_client.c \
- socket_loopback_server.c \
- socket_network_client.c \
- sockets.c \
+ socket_inaddr_any_server_unix.c \
+ socket_local_client_unix.c \
+ socket_local_server_unix.c \
+ socket_loopback_client_unix.c \
+ socket_loopback_server_unix.c \
+ socket_network_client_unix.c \
+ sockets_unix.c \
str_parms.c \
libcutils_nonwindows_host_sources := \
ashmem-host.c \
- trace-host.c
+ trace-host.c \
+libcutils_windows_host_sources := \
+ socket_inaddr_any_server_windows.c \
+ socket_network_client_windows.c \
+ sockets_windows.c \
# Shared and static library for host
+# Note: when linking this library on Windows, you must also link to Winsock2
+# using "LOCAL_LDLIBS_windows := -lws2_32".
# ========================================================
LOCAL_MODULE := libcutils
LOCAL_SRC_FILES := $(libcutils_common_sources) dlmalloc_stubs.c
LOCAL_SRC_FILES_darwin := $(libcutils_nonwindows_sources) $(libcutils_nonwindows_host_sources)
LOCAL_SRC_FILES_linux := $(libcutils_nonwindows_sources) $(libcutils_nonwindows_host_sources)
+LOCAL_SRC_FILES_windows := $(libcutils_windows_host_sources)
LOCAL_STATIC_LIBRARIES := liblog
LOCAL_CFLAGS := -Werror -Wall -Wextra
LOCAL_MULTILIB := both
diff --git a/libcutils/klog.c b/libcutils/klog.c
index 710dc66..7402903 100644
--- a/libcutils/klog.c
+++ b/libcutils/klog.c
@@ -62,6 +62,7 @@
}
void klog_write(int level, const char* fmt, ...) {
+ if (level > klog_level) return;
char buf[LOG_BUF_MAX];
va_list ap;
va_start(ap, fmt);
diff --git a/libcutils/socket_inaddr_any_server.c b/libcutils/socket_inaddr_any_server_unix.c
similarity index 97%
rename from libcutils/socket_inaddr_any_server.c
rename to libcutils/socket_inaddr_any_server_unix.c
index e1b7d84..387258f 100644
--- a/libcutils/socket_inaddr_any_server.c
+++ b/libcutils/socket_inaddr_any_server_unix.c
@@ -20,12 +20,10 @@
#include <string.h>
#include <unistd.h>
-#if !defined(_WIN32)
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/types.h>
#include <netinet/in.h>
-#endif
#include <cutils/sockets.h>
diff --git a/libcutils/socket_inaddr_any_server_windows.c b/libcutils/socket_inaddr_any_server_windows.c
new file mode 100644
index 0000000..c15200a
--- /dev/null
+++ b/libcutils/socket_inaddr_any_server_windows.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <errno.h>
+
+#include <cutils/sockets.h>
+
+#define LISTEN_BACKLOG 4
+
+extern bool initialize_windows_sockets();
+
+SOCKET socket_inaddr_any_server(int port, int type) {
+ if (!initialize_windows_sockets()) {
+ return INVALID_SOCKET;
+ }
+
+ SOCKET sock = socket(AF_INET6, type, 0);
+ if (sock == INVALID_SOCKET) {
+ return INVALID_SOCKET;
+ }
+
+ // Enforce exclusive addresses so nobody can steal the port from us (1),
+ // and enable dual-stack so both IPv4 and IPv6 work (2).
+ // (1) https://msdn.microsoft.com/en-us/library/windows/desktop/ms740621(v=vs.85).aspx.
+ // (2) https://msdn.microsoft.com/en-us/library/windows/desktop/bb513665(v=vs.85).aspx.
+ int exclusive = 1;
+ DWORD v6_only = 0;
+ if (setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&exclusive,
+ sizeof(exclusive)) == SOCKET_ERROR ||
+ setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&v6_only,
+ sizeof(v6_only)) == SOCKET_ERROR) {
+ closesocket(sock);
+ return INVALID_SOCKET;
+ }
+
+ // Bind the socket to our local port.
+ struct sockaddr_in6 addr;
+ memset(&addr, 0, sizeof(addr));
+ addr.sin6_family = AF_INET6;
+ addr.sin6_port = htons(port);
+ addr.sin6_addr = in6addr_any;
+ if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
+ closesocket(sock);
+ return INVALID_SOCKET;
+ }
+
+ // Start listening for connections if this is a TCP socket.
+ if (type == SOCK_STREAM && listen(sock, LISTEN_BACKLOG) == SOCKET_ERROR) {
+ closesocket(sock);
+ return INVALID_SOCKET;
+ }
+
+ return sock;
+}
diff --git a/libcutils/socket_local_client.c b/libcutils/socket_local_client_unix.c
similarity index 98%
rename from libcutils/socket_local_client.c
rename to libcutils/socket_local_client_unix.c
index 2526146..92fb9f1 100644
--- a/libcutils/socket_local_client.c
+++ b/libcutils/socket_local_client_unix.c
@@ -37,7 +37,7 @@
#include <sys/select.h>
#include <sys/types.h>
-#include "socket_local.h"
+#include "socket_local_unix.h"
#define UNUSED __attribute__((unused))
diff --git a/libcutils/socket_local_server.c b/libcutils/socket_local_server_unix.c
similarity index 98%
rename from libcutils/socket_local_server.c
rename to libcutils/socket_local_server_unix.c
index c9acdad..db9e1e0 100644
--- a/libcutils/socket_local_server.c
+++ b/libcutils/socket_local_server_unix.c
@@ -39,7 +39,7 @@
#include <sys/types.h>
#include <netinet/in.h>
-#include "socket_local.h"
+#include "socket_local_unix.h"
#define LISTEN_BACKLOG 4
diff --git a/libcutils/socket_local.h b/libcutils/socket_local_unix.h
similarity index 100%
rename from libcutils/socket_local.h
rename to libcutils/socket_local_unix.h
diff --git a/libcutils/socket_loopback_client.c b/libcutils/socket_loopback_client_unix.c
similarity index 100%
rename from libcutils/socket_loopback_client.c
rename to libcutils/socket_loopback_client_unix.c
diff --git a/libcutils/socket_loopback_server.c b/libcutils/socket_loopback_server_unix.c
similarity index 100%
rename from libcutils/socket_loopback_server.c
rename to libcutils/socket_loopback_server_unix.c
diff --git a/libcutils/socket_network_client.c b/libcutils/socket_network_client_unix.c
similarity index 100%
rename from libcutils/socket_network_client.c
rename to libcutils/socket_network_client_unix.c
diff --git a/libcutils/socket_network_client_windows.c b/libcutils/socket_network_client_windows.c
new file mode 100644
index 0000000..ab1a52f
--- /dev/null
+++ b/libcutils/socket_network_client_windows.c
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <cutils/sockets.h>
+
+extern bool initialize_windows_sockets();
+
+SOCKET socket_network_client(const char* host, int port, int type) {
+ if (!initialize_windows_sockets()) {
+ return INVALID_SOCKET;
+ }
+
+ // First resolve the host and port parameters into a usable network address.
+ struct addrinfo hints;
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_socktype = type;
+
+ struct addrinfo* address = NULL;
+ char port_str[16];
+ snprintf(port_str, sizeof(port_str), "%d", port);
+ if (getaddrinfo(host, port_str, &hints, &address) != 0 || address == NULL) {
+ if (address != NULL) {
+ freeaddrinfo(address);
+ }
+ return INVALID_SOCKET;
+ }
+
+ // Now create and connect the socket.
+ SOCKET sock = socket(address->ai_family, address->ai_socktype,
+ address->ai_protocol);
+ if (sock == INVALID_SOCKET) {
+ freeaddrinfo(address);
+ return INVALID_SOCKET;
+ }
+
+ if (connect(sock, address->ai_addr, address->ai_addrlen) == SOCKET_ERROR) {
+ closesocket(sock);
+ freeaddrinfo(address);
+ return INVALID_SOCKET;
+ }
+
+ freeaddrinfo(address);
+ return sock;
+}
diff --git a/libcutils/sockets.c b/libcutils/sockets_unix.c
similarity index 82%
rename from libcutils/sockets.c
rename to libcutils/sockets_unix.c
index d438782..5eddc4b 100644
--- a/libcutils/sockets.c
+++ b/libcutils/sockets_unix.c
@@ -45,3 +45,14 @@
return true;
}
+
+int socket_close(int sock) {
+ return close(sock);
+}
+
+int socket_set_receive_timeout(cutils_socket_t sock, int timeout_ms) {
+ struct timeval tv;
+ tv.tv_sec = timeout_ms / 1000;
+ tv.tv_usec = (timeout_ms % 1000) * 1000;
+ return setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+}
diff --git a/libcutils/sockets_windows.c b/libcutils/sockets_windows.c
new file mode 100644
index 0000000..1bf2933
--- /dev/null
+++ b/libcutils/sockets_windows.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <cutils/sockets.h>
+
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms741549(v=vs.85).aspx
+// claims WSACleanup() should be called before program exit, but general
+// consensus seems to be that it hasn't actually been necessary for a long time,
+// likely since Windows 3.1. Additionally, trying to properly use WSACleanup()
+// can be extremely tricky and cause deadlock when using threads or atexit().
+//
+// Both adb (1) and Chrome (2) purposefully avoid WSACleanup() with no issues.
+// (1) https://android.googlesource.com/platform/system/core.git/+/master/adb/sysdeps_win32.cpp
+// (2) https://code.google.com/p/chromium/codesearch#chromium/src/net/base/winsock_init.cc
+bool initialize_windows_sockets() {
+ // There's no harm in calling WSAStartup() multiple times but no benefit
+ // either, we may as well skip it after the first.
+ static bool init_success = false;
+
+ if (!init_success) {
+ WSADATA wsaData;
+ init_success = (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0);
+ }
+
+ return init_success;
+}
+
+int socket_close(cutils_socket_t sock) {
+ return closesocket(sock);
+}
+
+int socket_set_receive_timeout(cutils_socket_t sock, int timeout_ms) {
+ return setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout_ms,
+ sizeof(timeout_ms));
+}
diff --git a/libcutils/tests/Android.mk b/libcutils/tests/Android.mk
index cf70345..4da5ed6 100644
--- a/libcutils/tests/Android.mk
+++ b/libcutils/tests/Android.mk
@@ -15,6 +15,9 @@
LOCAL_PATH := $(call my-dir)
test_src_files := \
+ sockets_test.cpp \
+
+test_src_files_nonwindows := \
test_str_parms.cpp \
test_target_only_src_files := \
@@ -55,7 +58,7 @@
include $(CLEAR_VARS)
LOCAL_MODULE := libcutils_test
-LOCAL_SRC_FILES := $(test_src_files)
+LOCAL_SRC_FILES := $(test_src_files) $(test_src_files_nonwindows)
LOCAL_SHARED_LIBRARIES := $(test_libraries)
LOCAL_MULTILIB := both
LOCAL_MODULE_STEM_32 := $(LOCAL_MODULE)32
@@ -65,9 +68,13 @@
include $(CLEAR_VARS)
LOCAL_MODULE := libcutils_test_static
LOCAL_SRC_FILES := $(test_src_files)
+LOCAL_SRC_FILES_darwin := $(test_src_files_nonwindows)
+LOCAL_SRC_FILES_linux := $(test_src_files_nonwindows)
LOCAL_STATIC_LIBRARIES := $(test_libraries)
+LOCAL_LDLIBS_windows := -lws2_32
LOCAL_CXX_STL := libc++_static
LOCAL_MULTILIB := both
LOCAL_MODULE_STEM_32 := $(LOCAL_MODULE)32
LOCAL_MODULE_STEM_64 := $(LOCAL_MODULE)64
+LOCAL_MODULE_HOST_OS := darwin linux windows
include $(BUILD_HOST_NATIVE_TEST)
diff --git a/libcutils/tests/sockets_test.cpp b/libcutils/tests/sockets_test.cpp
new file mode 100644
index 0000000..966dfe7
--- /dev/null
+++ b/libcutils/tests/sockets_test.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+// Tests socket functionality using loopback connections. Requires IPv4 and
+// IPv6 capabilities, and that kTestPort is available for loopback
+// communication. These tests also assume that no UDP packets are lost,
+// which should be the case for loopback communication, but is not guaranteed.
+
+#include <cutils/sockets.h>
+
+#include <time.h>
+
+#include <gtest/gtest.h>
+
+enum {
+ // This port must be available for loopback communication.
+ kTestPort = 54321
+};
+
+// Makes sure the passed sockets are valid, sends data between them, and closes
+// them. Any failures are logged with gtest.
+//
+// On Mac recvfrom() will not fill in the address for TCP sockets, so we need
+// separate logic paths depending on socket type.
+static void TestConnectedSockets(cutils_socket_t server, cutils_socket_t client,
+ int type) {
+ ASSERT_NE(INVALID_SOCKET, server);
+ ASSERT_NE(INVALID_SOCKET, client);
+
+ char buffer[3];
+ sockaddr_storage addr;
+ socklen_t addr_size = sizeof(addr);
+
+ // Send client -> server first to get the UDP client's address.
+ ASSERT_EQ(3, send(client, "foo", 3, 0));
+ if (type == SOCK_DGRAM) {
+ EXPECT_EQ(3, recvfrom(server, buffer, 3, 0,
+ reinterpret_cast<sockaddr*>(&addr), &addr_size));
+ } else {
+ EXPECT_EQ(3, recv(server, buffer, 3, 0));
+ }
+ EXPECT_EQ(0, memcmp(buffer, "foo", 3));
+
+ // Now send server -> client.
+ if (type == SOCK_DGRAM) {
+ ASSERT_EQ(3, sendto(server, "bar", 3, 0,
+ reinterpret_cast<sockaddr*>(&addr), addr_size));
+ } else {
+ ASSERT_EQ(3, send(server, "bar", 3, 0));
+ }
+ EXPECT_EQ(3, recv(client, buffer, 3, 0));
+ EXPECT_EQ(0, memcmp(buffer, "bar", 3));
+
+ EXPECT_EQ(0, socket_close(server));
+ EXPECT_EQ(0, socket_close(client));
+}
+
+// Tests receive timeout. The timing verification logic must be very coarse to
+// make sure different systems can all pass these tests.
+void TestReceiveTimeout(cutils_socket_t sock) {
+ time_t start_time;
+ char buffer[32];
+
+ // Make sure a 20ms timeout completes in 1 second or less.
+ EXPECT_EQ(0, socket_set_receive_timeout(sock, 20));
+ start_time = time(nullptr);
+ EXPECT_EQ(-1, recv(sock, buffer, sizeof(buffer), 0));
+ EXPECT_LE(difftime(time(nullptr), start_time), 1.0);
+
+ // Make sure a 1250ms timeout takes 1 second or more.
+ EXPECT_EQ(0, socket_set_receive_timeout(sock, 1250));
+ start_time = time(nullptr);
+ EXPECT_EQ(-1, recv(sock, buffer, sizeof(buffer), 0));
+ EXPECT_LE(1.0, difftime(time(nullptr), start_time));
+}
+
+// Tests socket_inaddr_any_server() and socket_network_client() for IPv4 UDP.
+TEST(SocketsTest, TestIpv4UdpLoopback) {
+ cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_DGRAM);
+ cutils_socket_t client = socket_network_client("127.0.0.1", kTestPort,
+ SOCK_DGRAM);
+
+ TestConnectedSockets(server, client, SOCK_DGRAM);
+}
+
+// Tests socket_inaddr_any_server() and socket_network_client() for IPv4 TCP.
+TEST(SocketsTest, TestIpv4TcpLoopback) {
+ cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_STREAM);
+ ASSERT_NE(INVALID_SOCKET, server);
+
+ cutils_socket_t client = socket_network_client("127.0.0.1", kTestPort,
+ SOCK_STREAM);
+ cutils_socket_t handler = accept(server, nullptr, nullptr);
+ EXPECT_EQ(0, socket_close(server));
+
+ TestConnectedSockets(handler, client, SOCK_STREAM);
+}
+
+// Tests socket_inaddr_any_server() and socket_network_client() for IPv6 UDP.
+TEST(SocketsTest, TestIpv6UdpLoopback) {
+ cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_DGRAM);
+ cutils_socket_t client = socket_network_client("::1", kTestPort,
+ SOCK_DGRAM);
+
+ TestConnectedSockets(server, client, SOCK_DGRAM);
+}
+
+// Tests socket_inaddr_any_server() and socket_network_client() for IPv6 TCP.
+TEST(SocketsTest, TestIpv6TcpLoopback) {
+ cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_STREAM);
+ ASSERT_NE(INVALID_SOCKET, server);
+
+ cutils_socket_t client = socket_network_client("::1", kTestPort,
+ SOCK_STREAM);
+ cutils_socket_t handler = accept(server, nullptr, nullptr);
+ EXPECT_EQ(0, socket_close(server));
+
+ TestConnectedSockets(handler, client, SOCK_STREAM);
+}
+
+// Tests setting a receive timeout for UDP sockets.
+TEST(SocketsTest, TestUdpReceiveTimeout) {
+ cutils_socket_t sock = socket_inaddr_any_server(kTestPort, SOCK_DGRAM);
+ ASSERT_NE(INVALID_SOCKET, sock);
+
+ TestReceiveTimeout(sock);
+
+ EXPECT_EQ(0, socket_close(sock));
+}
+
+// Tests setting a receive timeout for TCP sockets.
+TEST(SocketsTest, TestTcpReceiveTimeout) {
+ cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_STREAM);
+ ASSERT_NE(INVALID_SOCKET, server);
+
+ cutils_socket_t client = socket_network_client("localhost", kTestPort,
+ SOCK_STREAM);
+ cutils_socket_t handler = accept(server, nullptr, nullptr);
+ EXPECT_EQ(0, socket_close(server));
+
+ TestReceiveTimeout(handler);
+
+ EXPECT_EQ(0, socket_close(client));
+ EXPECT_EQ(0, socket_close(handler));
+}
diff --git a/liblog/logd_write.c b/liblog/logd_write.c
index 5406c50..4946073 100644
--- a/liblog/logd_write.c
+++ b/liblog/logd_write.c
@@ -204,14 +204,36 @@
if (vec[0].iov_len < 4) {
return -EINVAL;
}
- if ((last_uid != AID_SYSTEM) && (last_uid != AID_ROOT)) {
+ /* Matches clientHasLogCredentials() in logd */
+ if ((last_uid != AID_SYSTEM) && (last_uid != AID_ROOT) && (last_uid != AID_LOG)) {
uid_t uid = geteuid();
- if ((uid != AID_SYSTEM) && (uid != AID_ROOT)) {
+ if ((uid != AID_SYSTEM) && (uid != AID_ROOT) && (uid != AID_LOG)) {
gid_t gid = getgid();
- if ((gid != AID_SYSTEM) && (gid != AID_ROOT)) {
+ if ((gid != AID_SYSTEM) && (gid != AID_ROOT) && (gid != AID_LOG)) {
gid = getegid();
- if ((gid != AID_SYSTEM) && (gid != AID_ROOT)) {
- return -EPERM;
+ if ((gid != AID_SYSTEM) && (gid != AID_ROOT) && (gid != AID_LOG)) {
+ int num_groups;
+ gid_t *groups;
+
+ num_groups = getgroups(0, NULL);
+ if (num_groups <= 0) {
+ return -EPERM;
+ }
+ groups = calloc(num_groups, sizeof(gid_t));
+ if (!groups) {
+ return -ENOMEM;
+ }
+ num_groups = getgroups(num_groups, groups);
+ while (num_groups > 0) {
+ if (groups[num_groups - 1] == AID_LOG) {
+ break;
+ }
+ --num_groups;
+ }
+ free(groups);
+ if (num_groups <= 0) {
+ return -EPERM;
+ }
}
}
}
@@ -668,3 +690,25 @@
return write_to_log(LOG_ID_EVENTS, vec, 4);
}
+
+/*
+ * Like __android_log_security_bwrite, but used for writing strings to the
+ * security log.
+ */
+int __android_log_security_bswrite(int32_t tag, const char *payload)
+{
+ struct iovec vec[4];
+ char type = EVENT_TYPE_STRING;
+ uint32_t len = strlen(payload);
+
+ vec[0].iov_base = &tag;
+ vec[0].iov_len = sizeof(tag);
+ vec[1].iov_base = &type;
+ vec[1].iov_len = sizeof(type);
+ vec[2].iov_base = &len;
+ vec[2].iov_len = sizeof(len);
+ vec[3].iov_base = (void*)payload;
+ vec[3].iov_len = len;
+
+ return write_to_log(LOG_ID_SECURITY, vec, 4);
+}
diff --git a/liblog/logprint.c b/liblog/logprint.c
index bd36cdd..4ef62a1 100644
--- a/liblog/logprint.c
+++ b/liblog/logprint.c
@@ -1488,7 +1488,7 @@
strcat(p, suffixBuf);
p += suffixLen;
} else {
- while(pm < (entry->message + entry->messageLen)) {
+ do {
const char *lineStart;
size_t lineLen;
lineStart = pm;
@@ -1510,7 +1510,7 @@
p += suffixLen;
if (*pm == '\n') pm++;
- }
+ } while (pm < (entry->message + entry->messageLen));
}
if (p_outLength != NULL) {
diff --git a/liblog/tests/liblog_test.cpp b/liblog/tests/liblog_test.cpp
index 50afc5f..a936455 100644
--- a/liblog/tests/liblog_test.cpp
+++ b/liblog/tests/liblog_test.cpp
@@ -165,6 +165,133 @@
android_logger_list_close(logger_list);
}
+static inline int32_t get4LE(const char* src)
+{
+ return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
+}
+
+TEST(liblog, __android_log_bswrite) {
+ struct logger_list *logger_list;
+
+ pid_t pid = getpid();
+
+ ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
+ LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
+
+ static const char buffer[] = "Hello World";
+ log_time ts(android_log_clockid());
+
+ ASSERT_LT(0, __android_log_bswrite(0, buffer));
+ usleep(1000000);
+
+ int count = 0;
+
+ for (;;) {
+ log_msg log_msg;
+ if (android_logger_list_read(logger_list, &log_msg) <= 0) {
+ break;
+ }
+
+ ASSERT_EQ(log_msg.entry.pid, pid);
+
+ if ((log_msg.entry.sec < (ts.tv_sec - 1))
+ || ((ts.tv_sec + 1) < log_msg.entry.sec)
+ || (log_msg.entry.len != (4 + 1 + 4 + sizeof(buffer) - 1))
+ || (log_msg.id() != LOG_ID_EVENTS)) {
+ continue;
+ }
+
+ char *eventData = log_msg.msg();
+
+ if (eventData[4] != EVENT_TYPE_STRING) {
+ continue;
+ }
+
+ int len = get4LE(eventData + 4 + 1);
+ if (len == (sizeof(buffer) - 1)) {
+ ++count;
+
+ AndroidLogFormat *logformat = android_log_format_new();
+ EXPECT_TRUE(NULL != logformat);
+ AndroidLogEntry entry;
+ char msgBuf[1024];
+ EXPECT_EQ(0, android_log_processBinaryLogBuffer(&log_msg.entry_v1,
+ &entry,
+ NULL,
+ msgBuf,
+ sizeof(msgBuf)));
+ fflush(stderr);
+ EXPECT_EQ(31, android_log_printLogLine(logformat, fileno(stderr), &entry));
+ android_log_format_free(logformat);
+ }
+ }
+
+ EXPECT_EQ(1, count);
+
+ android_logger_list_close(logger_list);
+}
+
+TEST(liblog, __android_log_bswrite__empty_string) {
+ struct logger_list *logger_list;
+
+ pid_t pid = getpid();
+
+ ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
+ LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
+
+ static const char buffer[] = "";
+ log_time ts(android_log_clockid());
+
+ ASSERT_LT(0, __android_log_bswrite(0, buffer));
+ usleep(1000000);
+
+ int count = 0;
+
+ for (;;) {
+ log_msg log_msg;
+ if (android_logger_list_read(logger_list, &log_msg) <= 0) {
+ break;
+ }
+
+ ASSERT_EQ(log_msg.entry.pid, pid);
+
+ if ((log_msg.entry.sec < (ts.tv_sec - 1))
+ || ((ts.tv_sec + 1) < log_msg.entry.sec)
+ || (log_msg.entry.len != (4 + 1 + 4))
+ || (log_msg.id() != LOG_ID_EVENTS)) {
+ continue;
+ }
+
+ char *eventData = log_msg.msg();
+
+ if (eventData[4] != EVENT_TYPE_STRING) {
+ continue;
+ }
+
+ int len = get4LE(eventData + 4 + 1);
+ if (len == 0) {
+ ++count;
+
+ AndroidLogFormat *logformat = android_log_format_new();
+ EXPECT_TRUE(NULL != logformat);
+ AndroidLogEntry entry;
+ char msgBuf[1024];
+ EXPECT_EQ(0, android_log_processBinaryLogBuffer(&log_msg.entry_v1,
+ &entry,
+ NULL,
+ msgBuf,
+ sizeof(msgBuf)));
+ fflush(stderr);
+ EXPECT_EQ(20, android_log_printLogLine(logformat, fileno(stderr), &entry));
+ android_log_format_free(logformat);
+ }
+ }
+
+ EXPECT_EQ(1, count);
+
+ android_logger_list_close(logger_list);
+}
+
TEST(liblog, __security) {
static const char persist_key[] = "persist.logd.security";
static const char readonly_key[] = "ro.device_owner";
@@ -1106,11 +1233,6 @@
property_set(key + base_offset, hold[3]);
}
-static inline int32_t get4LE(const char* src)
-{
- return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
-}
-
TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__typical) {
const int TAG = 123456781;
const char SUBTAG[] = "test-subtag";
diff --git a/libnativeloader/native_loader.cpp b/libnativeloader/native_loader.cpp
index 403a4f4..6e6b0b9 100644
--- a/libnativeloader/native_loader.cpp
+++ b/libnativeloader/native_loader.cpp
@@ -48,7 +48,9 @@
"libm.so:"
"libOpenMAXAL.so:"
"libOpenSLES.so:"
+ "libRS.so:"
"libstdc++.so:"
+ "libwebviewchromium_plat_support.so:"
"libz.so";
class LibraryNamespaces {
diff --git a/libnetutils/ifc_utils.c b/libnetutils/ifc_utils.c
index 956ed30..e0a9f7f 100644
--- a/libnetutils/ifc_utils.c
+++ b/libnetutils/ifc_utils.c
@@ -253,6 +253,7 @@
int prefixlen) {
int ifindex, s, len, ret;
struct sockaddr_storage ss;
+ int saved_errno;
void *addr;
size_t addrlen;
struct {
@@ -317,15 +318,21 @@
memcpy(RTA_DATA(rta), addr, addrlen);
s = socket(PF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
- if (send(s, &req, req.n.nlmsg_len, 0) < 0) {
- close(s);
+ if (s < 0) {
return -errno;
}
+ if (send(s, &req, req.n.nlmsg_len, 0) < 0) {
+ saved_errno = errno;
+ close(s);
+ return -saved_errno;
+ }
+
len = recv(s, buf, sizeof(buf), 0);
+ saved_errno = errno;
close(s);
if (len < 0) {
- return -errno;
+ return -saved_errno;
}
// Parse the acknowledgement to find the return code.
diff --git a/libpixelflinger/codeflinger/CodeCache.cpp b/libpixelflinger/codeflinger/CodeCache.cpp
index d770302..4b498c1 100644
--- a/libpixelflinger/codeflinger/CodeCache.cpp
+++ b/libpixelflinger/codeflinger/CodeCache.cpp
@@ -63,7 +63,7 @@
#define USAGE_ERROR_ACTION(m,p) \
heap_error("ARGUMENT IS INVALID HEAP ADDRESS", __FUNCTION__, p)
-#include "../../../../bionic/libc/upstream-dlmalloc/malloc.c"
+#include "../../../../external/dlmalloc/malloc.c"
static void heap_error(const char* msg, const char* function, void* p) {
ALOG(LOG_FATAL, LOG_TAG, "@@@ ABORTING: CODE FLINGER: %s IN %s addr=%p",
diff --git a/libziparchive/Android.mk b/libziparchive/Android.mk
index 8a4921f..056b3e1 100644
--- a/libziparchive/Android.mk
+++ b/libziparchive/Android.mk
@@ -15,34 +15,46 @@
LOCAL_PATH := $(call my-dir)
-source_files := zip_archive.cc zip_writer.cc
-test_files := zip_archive_test.cc zip_writer_test.cc entry_name_utils_test.cc
+libziparchive_source_files := \
+ zip_archive.cc \
+ zip_archive_stream_entry.cc \
+ zip_writer.cc \
+
+libziparchive_test_files := \
+ entry_name_utils_test.cc \
+ zip_archive_test.cc \
+ zip_writer_test.cc \
# ZLIB_CONST turns on const for input buffers, which is pretty standard.
-common_c_flags := -Werror -Wall -DZLIB_CONST
+libziparchive_common_c_flags := \
+ -DZLIB_CONST \
+ -Werror \
+ -Wall \
# Incorrectly warns when C++11 empty brace {} initializer is used.
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61489
-common_cpp_flags := -Wold-style-cast -Wno-missing-field-initializers
+libziparchive_common_cpp_flags := \
+ -Wold-style-cast \
+ -Wno-missing-field-initializers \
include $(CLEAR_VARS)
LOCAL_CPP_EXTENSION := .cc
-LOCAL_SRC_FILES := ${source_files}
+LOCAL_SRC_FILES := $(libziparchive_source_files)
LOCAL_STATIC_LIBRARIES := libz
LOCAL_SHARED_LIBRARIES := libutils libbase
LOCAL_MODULE:= libziparchive
-LOCAL_CFLAGS := $(common_c_flags)
-LOCAL_CPPFLAGS := $(common_cpp_flags)
+LOCAL_CFLAGS := $(libziparchive_common_c_flags)
+LOCAL_CPPFLAGS := $(libziparchive_common_cpp_flags)
include $(BUILD_STATIC_LIBRARY)
include $(CLEAR_VARS)
LOCAL_CPP_EXTENSION := .cc
-LOCAL_SRC_FILES := ${source_files}
+LOCAL_SRC_FILES := $(libziparchive_source_files)
LOCAL_STATIC_LIBRARIES := libz libutils libbase
LOCAL_MODULE:= libziparchive-host
-LOCAL_CFLAGS := $(common_c_flags)
+LOCAL_CFLAGS := $(libziparchive_common_c_flags)
LOCAL_CFLAGS_windows := -mno-ms-bitfields
-LOCAL_CPPFLAGS := $(common_cpp_flags)
+LOCAL_CPPFLAGS := $(libziparchive_common_cpp_flags)
LOCAL_MULTILIB := both
LOCAL_MODULE_HOST_OS := darwin linux windows
@@ -50,12 +62,12 @@
include $(CLEAR_VARS)
LOCAL_CPP_EXTENSION := .cc
-LOCAL_SRC_FILES := ${source_files}
+LOCAL_SRC_FILES := $(libziparchive_source_files)
LOCAL_STATIC_LIBRARIES := libutils
LOCAL_SHARED_LIBRARIES := libz-host liblog libbase
LOCAL_MODULE:= libziparchive-host
-LOCAL_CFLAGS := $(common_c_flags)
-LOCAL_CPPFLAGS := $(common_cpp_flags)
+LOCAL_CFLAGS := $(libziparchive_common_c_flags)
+LOCAL_CPPFLAGS := $(libziparchive_common_cpp_flags)
LOCAL_MULTILIB := both
include $(BUILD_HOST_SHARED_LIBRARY)
@@ -63,21 +75,33 @@
include $(CLEAR_VARS)
LOCAL_MODULE := ziparchive-tests
LOCAL_CPP_EXTENSION := .cc
-LOCAL_CFLAGS := $(common_c_flags)
-LOCAL_CPPFLAGS := $(common_cpp_flags)
-LOCAL_SRC_FILES := $(test_files)
-LOCAL_SHARED_LIBRARIES := liblog libbase
-LOCAL_STATIC_LIBRARIES := libziparchive libz libutils
+LOCAL_CFLAGS := $(libziparchive_common_c_flags)
+LOCAL_CPPFLAGS := $(libziparchive_common_cpp_flags)
+LOCAL_SRC_FILES := $(libziparchive_test_files)
+LOCAL_SHARED_LIBRARIES := \
+ libbase \
+ liblog \
+
+LOCAL_STATIC_LIBRARIES := \
+ libziparchive \
+ libz \
+ libutils \
+
include $(BUILD_NATIVE_TEST)
include $(CLEAR_VARS)
LOCAL_MODULE := ziparchive-tests-host
LOCAL_CPP_EXTENSION := .cc
-LOCAL_CFLAGS := $(common_c_flags)
-LOCAL_CPPFLAGS := -Wno-unnamed-type-template-args $(common_cpp_flags)
-LOCAL_SRC_FILES := $(test_files)
-LOCAL_SHARED_LIBRARIES := libziparchive-host liblog libbase
+LOCAL_CFLAGS := $(libziparchive_common_c_flags)
+LOCAL_CPPFLAGS := -Wno-unnamed-type-template-args $(libziparchive_common_cpp_flags)
+LOCAL_SRC_FILES := $(libziparchive_test_files)
+LOCAL_SHARED_LIBRARIES := \
+ libziparchive-host \
+ liblog \
+ libbase \
+
LOCAL_STATIC_LIBRARIES := \
+ libutils \
libz \
- libutils
+
include $(BUILD_HOST_NATIVE_TEST)
diff --git a/libziparchive/testdata/bad_crc.zip b/libziparchive/testdata/bad_crc.zip
new file mode 100644
index 0000000..e12ba07
--- /dev/null
+++ b/libziparchive/testdata/bad_crc.zip
Binary files differ
diff --git a/libziparchive/testdata/large.zip b/libziparchive/testdata/large.zip
new file mode 100644
index 0000000..49659c8
--- /dev/null
+++ b/libziparchive/testdata/large.zip
Binary files differ
diff --git a/libziparchive/zip_archive.cc b/libziparchive/zip_archive.cc
index 07ef6cd..3b1e972 100644
--- a/libziparchive/zip_archive.cc
+++ b/libziparchive/zip_archive.cc
@@ -36,11 +36,12 @@
#include "log/log.h"
#include "utils/Compat.h"
#include "utils/FileMap.h"
+#include "ziparchive/zip_archive.h"
#include "zlib.h"
#include "entry_name_utils-inl.h"
#include "zip_archive_common.h"
-#include "ziparchive/zip_archive.h"
+#include "zip_archive_private.h"
using android::base::get_unaligned;
@@ -134,43 +135,6 @@
* every page that the Central Directory touches. Easier to tuck a copy
* of the string length into the hash table entry.
*/
-struct ZipArchive {
- /* open Zip archive */
- const int fd;
- const bool close_file;
-
- /* mapped central directory area */
- off64_t directory_offset;
- android::FileMap directory_map;
-
- /* number of entries in the Zip archive */
- uint16_t num_entries;
-
- /*
- * We know how many entries are in the Zip archive, so we can have a
- * fixed-size hash table. We define a load factor of 0.75 and overallocat
- * so the maximum number entries can never be higher than
- * ((4 * UINT16_MAX) / 3 + 1) which can safely fit into a uint32_t.
- */
- uint32_t hash_table_size;
- ZipString* hash_table;
-
- ZipArchive(const int fd, bool assume_ownership) :
- fd(fd),
- close_file(assume_ownership),
- directory_offset(0),
- num_entries(0),
- hash_table_size(0),
- hash_table(NULL) {}
-
- ~ZipArchive() {
- if (close_file && fd >= 0) {
- close(fd);
- }
-
- free(hash_table);
- }
-};
/*
* Round up to the next highest power of 2.
diff --git a/libziparchive/zip_archive_private.h b/libziparchive/zip_archive_private.h
new file mode 100644
index 0000000..ab52368
--- /dev/null
+++ b/libziparchive/zip_archive_private.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+#ifndef LIBZIPARCHIVE_ZIPARCHIVE_PRIVATE_H_
+#define LIBZIPARCHIVE_ZIPARCHIVE_PRIVATE_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <utils/FileMap.h>
+#include <ziparchive/zip_archive.h>
+
+struct ZipArchive {
+ // open Zip archive
+ const int fd;
+ const bool close_file;
+
+ // mapped central directory area
+ off64_t directory_offset;
+ android::FileMap directory_map;
+
+ // number of entries in the Zip archive
+ uint16_t num_entries;
+
+ // We know how many entries are in the Zip archive, so we can have a
+ // fixed-size hash table. We define a load factor of 0.75 and over
+ // allocate so the maximum number entries can never be higher than
+ // ((4 * UINT16_MAX) / 3 + 1) which can safely fit into a uint32_t.
+ uint32_t hash_table_size;
+ ZipString* hash_table;
+
+ ZipArchive(const int fd, bool assume_ownership) :
+ fd(fd),
+ close_file(assume_ownership),
+ directory_offset(0),
+ num_entries(0),
+ hash_table_size(0),
+ hash_table(NULL) {}
+
+ ~ZipArchive() {
+ if (close_file && fd >= 0) {
+ close(fd);
+ }
+
+ free(hash_table);
+ }
+};
+
+#endif // LIBZIPARCHIVE_ZIPARCHIVE_PRIVATE_H_
diff --git a/libziparchive/zip_archive_stream_entry.cc b/libziparchive/zip_archive_stream_entry.cc
new file mode 100644
index 0000000..f618835
--- /dev/null
+++ b/libziparchive/zip_archive_stream_entry.cc
@@ -0,0 +1,305 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+// Read-only stream access to Zip Archive entries.
+#include <errno.h>
+#include <inttypes.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <memory>
+#include <vector>
+
+#define LOG_TAG "ZIPARCHIVE"
+#include <android-base/file.h>
+#include <log/log.h>
+#include <ziparchive/zip_archive.h>
+#include <ziparchive/zip_archive_stream_entry.h>
+#include <zlib.h>
+
+#include "zip_archive_private.h"
+
+static constexpr size_t kBufSize = 65535;
+
+bool ZipArchiveStreamEntry::Init(const ZipEntry& entry) {
+ ZipArchive* archive = reinterpret_cast<ZipArchive*>(handle_);
+ off64_t data_offset = entry.offset;
+ if (lseek64(archive->fd, data_offset, SEEK_SET) != data_offset) {
+ ALOGW("lseek to data at %" PRId64 " failed: %s", data_offset, strerror(errno));
+ return false;
+ }
+ crc32_ = entry.crc32;
+ return true;
+}
+
+class ZipArchiveStreamEntryUncompressed : public ZipArchiveStreamEntry {
+ public:
+ ZipArchiveStreamEntryUncompressed(ZipArchiveHandle handle) : ZipArchiveStreamEntry(handle) {}
+ virtual ~ZipArchiveStreamEntryUncompressed() {}
+
+ const std::vector<uint8_t>* Read() override;
+
+ bool Verify() override;
+
+ protected:
+ bool Init(const ZipEntry& entry) override;
+
+ uint32_t length_;
+
+ private:
+ std::vector<uint8_t> data_;
+ uint32_t computed_crc32_;
+};
+
+bool ZipArchiveStreamEntryUncompressed::Init(const ZipEntry& entry) {
+ if (!ZipArchiveStreamEntry::Init(entry)) {
+ return false;
+ }
+
+ length_ = entry.uncompressed_length;
+
+ data_.resize(kBufSize);
+ computed_crc32_ = 0;
+
+ return true;
+}
+
+const std::vector<uint8_t>* ZipArchiveStreamEntryUncompressed::Read() {
+ if (length_ == 0) {
+ return nullptr;
+ }
+
+ size_t bytes = (length_ > data_.size()) ? data_.size() : length_;
+ ZipArchive* archive = reinterpret_cast<ZipArchive*>(handle_);
+ errno = 0;
+ if (!android::base::ReadFully(archive->fd, data_.data(), bytes)) {
+ if (errno != 0) {
+ ALOGE("Error reading from archive fd: %s", strerror(errno));
+ } else {
+ ALOGE("Short read of zip file, possibly corrupted zip?");
+ }
+ length_ = 0;
+ return nullptr;
+ }
+
+ if (bytes < data_.size()) {
+ data_.resize(bytes);
+ }
+ computed_crc32_ = crc32(computed_crc32_, data_.data(), data_.size());
+ length_ -= bytes;
+ return &data_;
+}
+
+bool ZipArchiveStreamEntryUncompressed::Verify() {
+ return length_ == 0 && crc32_ == computed_crc32_;
+}
+
+class ZipArchiveStreamEntryCompressed : public ZipArchiveStreamEntry {
+ public:
+ ZipArchiveStreamEntryCompressed(ZipArchiveHandle handle) : ZipArchiveStreamEntry(handle) {}
+ virtual ~ZipArchiveStreamEntryCompressed();
+
+ const std::vector<uint8_t>* Read() override;
+
+ bool Verify() override;
+
+ protected:
+ bool Init(const ZipEntry& entry) override;
+
+ private:
+ bool z_stream_init_ = false;
+ z_stream z_stream_;
+ std::vector<uint8_t> in_;
+ std::vector<uint8_t> out_;
+ uint32_t uncompressed_length_;
+ uint32_t compressed_length_;
+ uint32_t computed_crc32_;
+};
+
+// This method is using libz macros with old-style-casts
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+static inline int zlib_inflateInit2(z_stream* stream, int window_bits) {
+ return inflateInit2(stream, window_bits);
+}
+#pragma GCC diagnostic pop
+
+bool ZipArchiveStreamEntryCompressed::Init(const ZipEntry& entry) {
+ if (!ZipArchiveStreamEntry::Init(entry)) {
+ return false;
+ }
+
+ // Initialize the zlib stream struct.
+ memset(&z_stream_, 0, sizeof(z_stream_));
+ z_stream_.zalloc = Z_NULL;
+ z_stream_.zfree = Z_NULL;
+ z_stream_.opaque = Z_NULL;
+ z_stream_.next_in = nullptr;
+ z_stream_.avail_in = 0;
+ z_stream_.avail_out = 0;
+ z_stream_.data_type = Z_UNKNOWN;
+
+ // Use the undocumented "negative window bits" feature to tell zlib
+ // that there's no zlib header waiting for it.
+ int zerr = zlib_inflateInit2(&z_stream_, -MAX_WBITS);
+ if (zerr != Z_OK) {
+ if (zerr == Z_VERSION_ERROR) {
+ ALOGE("Installed zlib is not compatible with linked version (%s)",
+ ZLIB_VERSION);
+ } else {
+ ALOGE("Call to inflateInit2 failed (zerr=%d)", zerr);
+ }
+
+ return false;
+ }
+
+ z_stream_init_ = true;
+
+ uncompressed_length_ = entry.uncompressed_length;
+ compressed_length_ = entry.compressed_length;
+
+ out_.resize(kBufSize);
+ in_.resize(kBufSize);
+
+ computed_crc32_ = 0;
+
+ return true;
+}
+
+ZipArchiveStreamEntryCompressed::~ZipArchiveStreamEntryCompressed() {
+ if (z_stream_init_) {
+ inflateEnd(&z_stream_);
+ z_stream_init_ = false;
+ }
+}
+
+bool ZipArchiveStreamEntryCompressed::Verify() {
+ return z_stream_init_ && uncompressed_length_ == 0 && compressed_length_ == 0 &&
+ crc32_ == computed_crc32_;
+}
+
+const std::vector<uint8_t>* ZipArchiveStreamEntryCompressed::Read() {
+ if (z_stream_.avail_out == 0) {
+ z_stream_.next_out = out_.data();
+ z_stream_.avail_out = out_.size();;
+ }
+
+ while (true) {
+ if (z_stream_.avail_in == 0) {
+ if (compressed_length_ == 0) {
+ return nullptr;
+ }
+ size_t bytes = (compressed_length_ > in_.size()) ? in_.size() : compressed_length_;
+ ZipArchive* archive = reinterpret_cast<ZipArchive*>(handle_);
+ errno = 0;
+ if (!android::base::ReadFully(archive->fd, in_.data(), bytes)) {
+ if (errno != 0) {
+ ALOGE("Error reading from archive fd: %s", strerror(errno));
+ } else {
+ ALOGE("Short read of zip file, possibly corrupted zip?");
+ }
+ return nullptr;
+ }
+
+ compressed_length_ -= bytes;
+ z_stream_.next_in = in_.data();
+ z_stream_.avail_in = bytes;
+ }
+
+ int zerr = inflate(&z_stream_, Z_NO_FLUSH);
+ if (zerr != Z_OK && zerr != Z_STREAM_END) {
+ ALOGE("inflate zerr=%d (nIn=%p aIn=%u nOut=%p aOut=%u)",
+ zerr, z_stream_.next_in, z_stream_.avail_in,
+ z_stream_.next_out, z_stream_.avail_out);
+ return nullptr;
+ }
+
+ if (z_stream_.avail_out == 0) {
+ uncompressed_length_ -= out_.size();
+ computed_crc32_ = crc32(computed_crc32_, out_.data(), out_.size());
+ return &out_;
+ }
+ if (zerr == Z_STREAM_END) {
+ if (z_stream_.avail_out != 0) {
+ // Resize the vector down to the actual size of the data.
+ out_.resize(out_.size() - z_stream_.avail_out);
+ computed_crc32_ = crc32(computed_crc32_, out_.data(), out_.size());
+ uncompressed_length_ -= out_.size();
+ return &out_;
+ }
+ return nullptr;
+ }
+ }
+ return nullptr;
+}
+
+class ZipArchiveStreamEntryRawCompressed : public ZipArchiveStreamEntryUncompressed {
+ public:
+ ZipArchiveStreamEntryRawCompressed(ZipArchiveHandle handle)
+ : ZipArchiveStreamEntryUncompressed(handle) {}
+ virtual ~ZipArchiveStreamEntryRawCompressed() {}
+
+ bool Verify() override;
+
+ protected:
+ bool Init(const ZipEntry& entry) override;
+};
+
+bool ZipArchiveStreamEntryRawCompressed::Init(const ZipEntry& entry) {
+ if (!ZipArchiveStreamEntryUncompressed::Init(entry)) {
+ return false;
+ }
+ length_ = entry.compressed_length;
+
+ return true;
+}
+
+bool ZipArchiveStreamEntryRawCompressed::Verify() {
+ return length_ == 0;
+}
+
+ZipArchiveStreamEntry* ZipArchiveStreamEntry::Create(
+ ZipArchiveHandle handle, const ZipEntry& entry) {
+ ZipArchiveStreamEntry* stream = nullptr;
+ if (entry.method != kCompressStored) {
+ stream = new ZipArchiveStreamEntryCompressed(handle);
+ } else {
+ stream = new ZipArchiveStreamEntryUncompressed(handle);
+ }
+ if (stream && !stream->Init(entry)) {
+ delete stream;
+ stream = nullptr;
+ }
+
+ return stream;
+}
+
+ZipArchiveStreamEntry* ZipArchiveStreamEntry::CreateRaw(
+ ZipArchiveHandle handle, const ZipEntry& entry) {
+ ZipArchiveStreamEntry* stream = nullptr;
+ if (entry.method == kCompressStored) {
+ // Not compressed, don't need to do anything special.
+ stream = new ZipArchiveStreamEntryUncompressed(handle);
+ } else {
+ stream = new ZipArchiveStreamEntryRawCompressed(handle);
+ }
+ if (stream && !stream->Init(entry)) {
+ delete stream;
+ stream = nullptr;
+ }
+ return stream;
+}
diff --git a/libziparchive/zip_archive_test.cc b/libziparchive/zip_archive_test.cc
index cb0f410..d426dc4 100644
--- a/libziparchive/zip_archive_test.cc
+++ b/libziparchive/zip_archive_test.cc
@@ -14,54 +14,49 @@
* limitations under the License.
*/
-#include "ziparchive/zip_archive.h"
-
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdio.h>
+#include <string.h>
#include <unistd.h>
+
#include <vector>
#include <android-base/file.h>
#include <gtest/gtest.h>
+#include <ziparchive/zip_archive.h>
+#include <ziparchive/zip_archive_stream_entry.h>
static std::string test_data_dir;
static const std::string kMissingZip = "missing.zip";
static const std::string kValidZip = "valid.zip";
+static const std::string kLargeZip = "large.zip";
+static const std::string kBadCrcZip = "bad_crc.zip";
-static const uint8_t kATxtContents[] = {
+static const std::vector<uint8_t> kATxtContents {
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'\n'
};
-static const uint8_t kBTxtContents[] = {
+static const std::vector<uint8_t> kATxtContentsCompressed {
+ 'K', 'L', 'J', 'N', 'I', 'M', 'K', 207, 'H',
+ 132, 210, '\\', '\0'
+};
+
+static const std::vector<uint8_t> kBTxtContents {
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'\n'
};
-static const uint16_t kATxtNameLength = 5;
-static const uint16_t kBTxtNameLength = 5;
-static const uint16_t kNonexistentTxtNameLength = 15;
-static const uint16_t kEmptyTxtNameLength = 9;
-
-static const uint8_t kATxtName[kATxtNameLength] = {
- 'a', '.', 't', 'x', 't'
-};
-
-static const uint8_t kBTxtName[kBTxtNameLength] = {
- 'b', '.', 't', 'x', 't'
-};
-
-static const uint8_t kNonexistentTxtName[kNonexistentTxtNameLength] = {
- 'n', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 't', 'x' ,'t'
-};
-
-static const uint8_t kEmptyTxtName[kEmptyTxtNameLength] = {
- 'e', 'm', 'p', 't', 'y', '.', 't', 'x', 't'
-};
+static const std::string kATxtName("a.txt");
+static const std::string kBTxtName("b.txt");
+static const std::string kNonexistentTxtName("nonexistent.txt");
+static const std::string kEmptyTxtName("empty.txt");
+static const std::string kLargeCompressTxtName("compress.txt");
+static const std::string kLargeUncompressTxtName("uncompress.txt");
static int32_t OpenArchiveWrapper(const std::string& name,
ZipArchiveHandle* handle) {
@@ -75,6 +70,11 @@
ASSERT_EQ(0, memcmp(name_str.c_str(), name.name, name.name_length));
}
+static void SetZipString(ZipString* zip_str, const std::string& str) {
+ zip_str->name = reinterpret_cast<const uint8_t*>(str.c_str());
+ zip_str->name_length = str.size();
+}
+
TEST(ziparchive, Open) {
ZipArchiveHandle handle;
ASSERT_EQ(0, OpenArchiveWrapper(kValidZip, &handle));
@@ -115,7 +115,7 @@
ASSERT_EQ(0, OpenArchiveWrapper(kValidZip, &handle));
void* iteration_cookie;
- ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, NULL, NULL));
+ ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, nullptr, nullptr));
ZipEntry data;
ZipString name;
@@ -152,7 +152,7 @@
void* iteration_cookie;
ZipString prefix("b/");
- ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, &prefix, NULL));
+ ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, &prefix, nullptr));
ZipEntry data;
ZipString name;
@@ -181,7 +181,7 @@
void* iteration_cookie;
ZipString suffix(".txt");
- ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, NULL, &suffix));
+ ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, nullptr, &suffix));
ZipEntry data;
ZipString name;
@@ -262,8 +262,7 @@
ZipEntry data;
ZipString name;
- name.name = kATxtName;
- name.name_length = kATxtNameLength;
+ SetZipString(&name, kATxtName);
ASSERT_EQ(0, FindEntry(handle, name, &data));
// Known facts about a.txt, from zipinfo -v.
@@ -276,8 +275,7 @@
// An entry that doesn't exist. Should be a negative return code.
ZipString absent_name;
- absent_name.name = kNonexistentTxtName;
- absent_name.name_length = kNonexistentTxtNameLength;
+ SetZipString(&absent_name, kNonexistentTxtName);
ASSERT_LT(FindEntry(handle, absent_name, &data), 0);
CloseArchive(handle);
@@ -288,7 +286,7 @@
ASSERT_EQ(0, OpenArchiveWrapper("declaredlength.zip", &handle));
void* iteration_cookie;
- ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, NULL, NULL));
+ ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, nullptr, nullptr));
ZipString name;
ZipEntry data;
@@ -306,26 +304,24 @@
// An entry that's deflated.
ZipEntry data;
ZipString a_name;
- a_name.name = kATxtName;
- a_name.name_length = kATxtNameLength;
+ SetZipString(&a_name, kATxtName);
ASSERT_EQ(0, FindEntry(handle, a_name, &data));
const uint32_t a_size = data.uncompressed_length;
- ASSERT_EQ(a_size, sizeof(kATxtContents));
+ ASSERT_EQ(a_size, kATxtContents.size());
uint8_t* buffer = new uint8_t[a_size];
ASSERT_EQ(0, ExtractToMemory(handle, &data, buffer, a_size));
- ASSERT_EQ(0, memcmp(buffer, kATxtContents, a_size));
+ ASSERT_EQ(0, memcmp(buffer, kATxtContents.data(), a_size));
delete[] buffer;
// An entry that's stored.
ZipString b_name;
- b_name.name = kBTxtName;
- b_name.name_length = kBTxtNameLength;
+ SetZipString(&b_name, kBTxtName);
ASSERT_EQ(0, FindEntry(handle, b_name, &data));
const uint32_t b_size = data.uncompressed_length;
- ASSERT_EQ(b_size, sizeof(kBTxtContents));
+ ASSERT_EQ(b_size, kBTxtContents.size());
buffer = new uint8_t[b_size];
ASSERT_EQ(0, ExtractToMemory(handle, &data, buffer, b_size));
- ASSERT_EQ(0, memcmp(buffer, kBTxtContents, b_size));
+ ASSERT_EQ(0, memcmp(buffer, kBTxtContents.data(), b_size));
delete[] buffer;
CloseArchive(handle);
@@ -374,8 +370,7 @@
0x0100, 0x4c00, 0x0000, 0x5b00, 0x0001, 0x0000, 0x0000
};
-static const uint8_t kAbTxtName[] = { 'a', 'b', '.', 't', 'x', 't' };
-static const uint16_t kAbTxtNameLength = sizeof(kAbTxtName);
+static const std::string kAbTxtName("ab.txt");
static const size_t kAbUncompressedSize = 270216;
static int make_temporary_file(const char* file_name_pattern) {
@@ -405,8 +400,7 @@
ZipEntry entry;
ZipString empty_name;
- empty_name.name = kEmptyTxtName;
- empty_name.name_length = kEmptyTxtNameLength;
+ SetZipString(&empty_name, kEmptyTxtName);
ASSERT_EQ(0, FindEntry(handle, empty_name, &entry));
ASSERT_EQ(static_cast<uint32_t>(0), entry.uncompressed_length);
uint8_t buffer[1];
@@ -436,8 +430,7 @@
ZipEntry entry;
ZipString ab_name;
- ab_name.name = kAbTxtName;
- ab_name.name_length = kAbTxtNameLength;
+ SetZipString(&ab_name, kAbTxtName);
ASSERT_EQ(0, FindEntry(handle, ab_name, &entry));
ASSERT_EQ(kAbUncompressedSize, entry.uncompressed_length);
@@ -504,8 +497,7 @@
ZipEntry entry;
ZipString name;
- name.name = kATxtName;
- name.name_length = kATxtNameLength;
+ SetZipString(&name, kATxtName);
ASSERT_EQ(0, FindEntry(handle, name, &entry));
ASSERT_EQ(0, ExtractEntryToFile(handle, &entry, fd));
@@ -521,22 +513,131 @@
ASSERT_EQ(static_cast<ssize_t>(entry.uncompressed_length),
TEMP_FAILURE_RETRY(
read(fd, &uncompressed_data[0], entry.uncompressed_length)));
- ASSERT_EQ(0, memcmp(&uncompressed_data[0], kATxtContents,
- sizeof(kATxtContents)));
+ ASSERT_EQ(0, memcmp(&uncompressed_data[0], kATxtContents.data(),
+ kATxtContents.size()));
// Assert that the total length of the file is sane
- ASSERT_EQ(data_size + static_cast<ssize_t>(sizeof(kATxtContents)),
+ ASSERT_EQ(data_size + static_cast<ssize_t>(kATxtContents.size()),
lseek64(fd, 0, SEEK_END));
close(fd);
}
+static void ZipArchiveStreamTest(
+ ZipArchiveHandle& handle, const std::string& entry_name, bool raw,
+ bool verified, ZipEntry* entry, std::vector<uint8_t>* read_data) {
+ ZipString name;
+ SetZipString(&name, entry_name);
+ ASSERT_EQ(0, FindEntry(handle, name, entry));
+ std::unique_ptr<ZipArchiveStreamEntry> stream;
+ if (raw) {
+ stream.reset(ZipArchiveStreamEntry::CreateRaw(handle, *entry));
+ if (entry->method == kCompressStored) {
+ read_data->resize(entry->uncompressed_length);
+ } else {
+ read_data->resize(entry->compressed_length);
+ }
+ } else {
+ stream.reset(ZipArchiveStreamEntry::Create(handle, *entry));
+ read_data->resize(entry->uncompressed_length);
+ }
+ uint8_t* read_data_ptr = read_data->data();
+ ASSERT_TRUE(stream.get() != nullptr);
+ const std::vector<uint8_t>* data;
+ uint64_t total_size = 0;
+ while ((data = stream->Read()) != nullptr) {
+ total_size += data->size();
+ memcpy(read_data_ptr, data->data(), data->size());
+ read_data_ptr += data->size();
+ }
+ ASSERT_EQ(verified, stream->Verify());
+ ASSERT_EQ(total_size, read_data->size());
+}
+
+static void ZipArchiveStreamTestUsingContents(
+ const std::string& zip_file, const std::string& entry_name,
+ const std::vector<uint8_t>& contents, bool raw) {
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveWrapper(zip_file, &handle));
+
+ ZipEntry entry;
+ std::vector<uint8_t> read_data;
+ ZipArchiveStreamTest(handle, entry_name, raw, true, &entry, &read_data);
+
+ ASSERT_EQ(contents.size(), read_data.size());
+ ASSERT_TRUE(memcmp(read_data.data(), contents.data(), read_data.size()) == 0);
+
+ CloseArchive(handle);
+}
+
+static void ZipArchiveStreamTestUsingMemory(const std::string& zip_file, const std::string& entry_name) {
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveWrapper(zip_file, &handle));
+
+ ZipEntry entry;
+ std::vector<uint8_t> read_data;
+ ZipArchiveStreamTest(handle, entry_name, false, true, &entry, &read_data);
+
+ std::vector<uint8_t> cmp_data(entry.uncompressed_length);
+ ASSERT_EQ(entry.uncompressed_length, read_data.size());
+ ASSERT_EQ(0, ExtractToMemory(handle, &entry, cmp_data.data(), cmp_data.size()));
+ ASSERT_TRUE(memcmp(read_data.data(), cmp_data.data(), read_data.size()) == 0);
+
+ CloseArchive(handle);
+}
+
+TEST(ziparchive, StreamCompressed) {
+ ZipArchiveStreamTestUsingContents(kValidZip, kATxtName, kATxtContents, false);
+}
+
+TEST(ziparchive, StreamUncompressed) {
+ ZipArchiveStreamTestUsingContents(kValidZip, kBTxtName, kBTxtContents, false);
+}
+
+TEST(ziparchive, StreamRawCompressed) {
+ ZipArchiveStreamTestUsingContents(kValidZip, kATxtName, kATxtContentsCompressed, true);
+}
+
+TEST(ziparchive, StreamRawUncompressed) {
+ ZipArchiveStreamTestUsingContents(kValidZip, kBTxtName, kBTxtContents, true);
+}
+
+TEST(ziparchive, StreamLargeCompressed) {
+ ZipArchiveStreamTestUsingMemory(kLargeZip, kLargeCompressTxtName);
+}
+
+TEST(ziparchive, StreamLargeUncompressed) {
+ ZipArchiveStreamTestUsingMemory(kLargeZip, kLargeUncompressTxtName);
+}
+
+TEST(ziparchive, StreamCompressedBadCrc) {
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveWrapper(kBadCrcZip, &handle));
+
+ ZipEntry entry;
+ std::vector<uint8_t> read_data;
+ ZipArchiveStreamTest(handle, kATxtName, false, false, &entry, &read_data);
+
+ CloseArchive(handle);
+}
+
+TEST(ziparchive, StreamUncompressedBadCrc) {
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveWrapper(kBadCrcZip, &handle));
+
+ ZipEntry entry;
+ std::vector<uint8_t> read_data;
+ ZipArchiveStreamTest(handle, kBTxtName, false, false, &entry, &read_data);
+
+ CloseArchive(handle);
+}
+
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
static struct option options[] = {
- { "test_data_dir", required_argument, NULL, 't' },
- { NULL, 0, NULL, 0 }
+ { "test_data_dir", required_argument, nullptr, 't' },
+ { nullptr, 0, nullptr, 0 }
};
while (true) {
@@ -557,9 +658,15 @@
}
if (test_data_dir[0] != '/') {
- printf("Test data must be an absolute path, was %s\n\n",
- test_data_dir.c_str());
- return -2;
+ std::vector<char> cwd_buffer(1024);
+ const char* cwd = getcwd(cwd_buffer.data(), cwd_buffer.size() - 1);
+ if (cwd == nullptr) {
+ printf("Cannot get current working directory, use an absolute path instead, was %s\n\n",
+ test_data_dir.c_str());
+ return -2;
+ }
+ test_data_dir = '/' + test_data_dir;
+ test_data_dir = cwd + test_data_dir;
}
return RUN_ALL_TESTS();
diff --git a/libziparchive/zip_writer.cc b/libziparchive/zip_writer.cc
index f117cc5..1ebed30 100644
--- a/libziparchive/zip_writer.cc
+++ b/libziparchive/zip_writer.cc
@@ -20,12 +20,19 @@
#include <utils/Log.h>
+#include <sys/param.h>
+
#include <cassert>
#include <cstdio>
#include <memory>
+#include <vector>
#include <zlib.h>
#define DEF_MEM_LEVEL 8 // normally in zutil.h?
+#if !defined(powerof2)
+#define powerof2(x) ((((x)-1)&(x))==0)
+#endif
+
/* Zip compression methods we support */
enum {
kCompressStored = 0, // no compression
@@ -50,6 +57,12 @@
// An error occurred in zlib.
static const int32_t kZlibError = -4;
+// The start aligned function was called with the aligned flag.
+static const int32_t kInvalidAlign32Flag = -5;
+
+// The alignment parameter is not a power of 2.
+static const int32_t kInvalidAlignment = -6;
+
static const char* sErrorCodes[] = {
"Invalid state",
"IO error",
@@ -102,7 +115,25 @@
}
int32_t ZipWriter::StartEntry(const char* path, size_t flags) {
- return StartEntryWithTime(path, flags, time_t());
+ uint32_t alignment = 0;
+ if (flags & kAlign32) {
+ flags &= ~kAlign32;
+ alignment = 4;
+ }
+ return StartAlignedEntryWithTime(path, flags, time_t(), alignment);
+}
+
+int32_t ZipWriter::StartAlignedEntry(const char* path, size_t flags, uint32_t alignment) {
+ return StartAlignedEntryWithTime(path, flags, time_t(), alignment);
+}
+
+int32_t ZipWriter::StartEntryWithTime(const char* path, size_t flags, time_t time) {
+ uint32_t alignment = 0;
+ if (flags & kAlign32) {
+ flags &= ~kAlign32;
+ alignment = 4;
+ }
+ return StartAlignedEntryWithTime(path, flags, time, alignment);
}
static void ExtractTimeAndDate(time_t when, uint16_t* out_time, uint16_t* out_date) {
@@ -126,11 +157,20 @@
*out_time = ptm->tm_hour << 11 | ptm->tm_min << 5 | ptm->tm_sec >> 1;
}
-int32_t ZipWriter::StartEntryWithTime(const char* path, size_t flags, time_t time) {
+int32_t ZipWriter::StartAlignedEntryWithTime(const char* path, size_t flags,
+ time_t time, uint32_t alignment) {
if (state_ != State::kWritingZip) {
return kInvalidState;
}
+ if (flags & kAlign32) {
+ return kInvalidAlign32Flag;
+ }
+
+ if (powerof2(alignment) == 0) {
+ return kInvalidAlignment;
+ }
+
FileInfo fileInfo = {};
fileInfo.path = std::string(path);
fileInfo.local_file_header_offset = current_offset_;
@@ -166,11 +206,14 @@
header.file_name_length = fileInfo.path.size();
off64_t offset = current_offset_ + sizeof(header) + fileInfo.path.size();
- if ((flags & ZipWriter::kAlign32) && (offset & 0x03)) {
+ std::vector<char> zero_padding;
+ if (alignment != 0 && (offset & (alignment - 1))) {
// Pad the extra field so the data will be aligned.
- uint16_t padding = 4 - (offset % 4);
+ uint16_t padding = alignment - (offset % alignment);
header.extra_field_length = padding;
offset += padding;
+ zero_padding.resize(padding);
+ memset(zero_padding.data(), 0, zero_padding.size());
}
if (fwrite(&header, sizeof(header), 1, file_) != 1) {
@@ -181,7 +224,9 @@
return HandleError(kIoError);
}
- if (fwrite("\0\0\0", 1, header.extra_field_length, file_) != header.extra_field_length) {
+ if (header.extra_field_length != 0 &&
+ fwrite(zero_padding.data(), 1, header.extra_field_length, file_)
+ != header.extra_field_length) {
return HandleError(kIoError);
}
diff --git a/libziparchive/zip_writer_test.cc b/libziparchive/zip_writer_test.cc
index b7d1458..fe0846d 100644
--- a/libziparchive/zip_writer_test.cc
+++ b/libziparchive/zip_writer_test.cc
@@ -19,6 +19,7 @@
#include <android-base/test_utils.h>
#include <gtest/gtest.h>
+#include <time.h>
#include <memory>
#include <vector>
@@ -122,7 +123,7 @@
CloseArchive(handle);
}
-TEST_F(zipwriter, WriteUncompressedZipWithAlignedFile) {
+TEST_F(zipwriter, WriteUncompressedZipFileWithAlignedFlag) {
ZipWriter writer(file_);
ASSERT_EQ(0, writer.StartEntry("align.txt", ZipWriter::kAlign32));
@@ -142,6 +143,103 @@
CloseArchive(handle);
}
+void ConvertZipTimeToTm(uint32_t& zip_time, struct tm* tm) {
+ memset(tm, 0, sizeof(struct tm));
+ tm->tm_hour = (zip_time >> 11) & 0x1f;
+ tm->tm_min = (zip_time >> 5) & 0x3f;
+ tm->tm_sec = (zip_time & 0x1f) << 1;
+
+ tm->tm_year = ((zip_time >> 25) & 0x7f) + 80;
+ tm->tm_mon = ((zip_time >> 21) & 0xf) - 1;
+ tm->tm_mday = (zip_time >> 16) & 0x1f;
+}
+
+TEST_F(zipwriter, WriteUncompressedZipFileWithAlignedFlagAndTime) {
+ ZipWriter writer(file_);
+
+ struct tm tm;
+ memset(&tm, 0, sizeof(struct tm));
+ ASSERT_TRUE(strptime("18:30:20 1/12/2001", "%H:%M:%S %d/%m/%Y", &tm) != nullptr);
+ time_t time = mktime(&tm);
+ ASSERT_EQ(0, writer.StartEntryWithTime("align.txt", ZipWriter::kAlign32, time));
+ ASSERT_EQ(0, writer.WriteBytes("he", 2));
+ ASSERT_EQ(0, writer.FinishEntry());
+ ASSERT_EQ(0, writer.Finish());
+
+ ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
+
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
+
+ ZipEntry data;
+ ASSERT_EQ(0, FindEntry(handle, ZipString("align.txt"), &data));
+ EXPECT_EQ(0, data.offset & 0x03);
+
+ struct tm mod;
+ ConvertZipTimeToTm(data.mod_time, &mod);
+ EXPECT_EQ(tm.tm_sec, mod.tm_sec);
+ EXPECT_EQ(tm.tm_min, mod.tm_min);
+ EXPECT_EQ(tm.tm_hour, mod.tm_hour);
+ EXPECT_EQ(tm.tm_mday, mod.tm_mday);
+ EXPECT_EQ(tm.tm_mon, mod.tm_mon);
+ EXPECT_EQ(tm.tm_year, mod.tm_year);
+
+ CloseArchive(handle);
+}
+
+TEST_F(zipwriter, WriteUncompressedZipFileWithAlignedValue) {
+ ZipWriter writer(file_);
+
+ ASSERT_EQ(0, writer.StartAlignedEntry("align.txt", 0, 4096));
+ ASSERT_EQ(0, writer.WriteBytes("he", 2));
+ ASSERT_EQ(0, writer.FinishEntry());
+ ASSERT_EQ(0, writer.Finish());
+
+ ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
+
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
+
+ ZipEntry data;
+ ASSERT_EQ(0, FindEntry(handle, ZipString("align.txt"), &data));
+ EXPECT_EQ(0, data.offset & 0xfff);
+
+ CloseArchive(handle);
+}
+
+TEST_F(zipwriter, WriteUncompressedZipFileWithAlignedValueAndTime) {
+ ZipWriter writer(file_);
+
+ struct tm tm;
+ memset(&tm, 0, sizeof(struct tm));
+ ASSERT_TRUE(strptime("18:30:20 1/12/2001", "%H:%M:%S %d/%m/%Y", &tm) != nullptr);
+ time_t time = mktime(&tm);
+ ASSERT_EQ(0, writer.StartAlignedEntryWithTime("align.txt", 0, time, 4096));
+ ASSERT_EQ(0, writer.WriteBytes("he", 2));
+ ASSERT_EQ(0, writer.FinishEntry());
+ ASSERT_EQ(0, writer.Finish());
+
+ ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
+
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
+
+ ZipEntry data;
+ ASSERT_EQ(0, FindEntry(handle, ZipString("align.txt"), &data));
+ EXPECT_EQ(0, data.offset & 0xfff);
+
+ struct tm mod;
+ ConvertZipTimeToTm(data.mod_time, &mod);
+ EXPECT_EQ(tm.tm_sec, mod.tm_sec);
+ EXPECT_EQ(tm.tm_min, mod.tm_min);
+ EXPECT_EQ(tm.tm_hour, mod.tm_hour);
+ EXPECT_EQ(tm.tm_mday, mod.tm_mday);
+ EXPECT_EQ(tm.tm_mon, mod.tm_mon);
+ EXPECT_EQ(tm.tm_year, mod.tm_year);
+
+ CloseArchive(handle);
+}
+
TEST_F(zipwriter, WriteCompressedZipWithOneFile) {
ZipWriter writer(file_);
@@ -206,3 +304,10 @@
CloseArchive(handle);
}
+
+TEST_F(zipwriter, CheckStartEntryErrors) {
+ ZipWriter writer(file_);
+
+ ASSERT_EQ(-5, writer.StartAlignedEntry("align.txt", ZipWriter::kAlign32, 4096));
+ ASSERT_EQ(-6, writer.StartAlignedEntry("align.txt", 0, 3));
+}
diff --git a/logd/FlushCommand.cpp b/logd/FlushCommand.cpp
index cb3d1c2..48036d3 100644
--- a/logd/FlushCommand.cpp
+++ b/logd/FlushCommand.cpp
@@ -36,7 +36,7 @@
mLogMask(logMask),
mPid(pid),
mStart(start),
- mTimeout(timeout) {
+ mTimeout((start > 1) ? timeout : 0) {
}
// runSocketCommand is called once for every open client on the
diff --git a/logd/LogBuffer.cpp b/logd/LogBuffer.cpp
index 707527b..9e0d451 100644
--- a/logd/LogBuffer.cpp
+++ b/logd/LogBuffer.cpp
@@ -109,6 +109,9 @@
}
log_id_for_each(i) {
+ mLastSet[i] = false;
+ mLast[i] = mLogElements.begin();
+
char key[PROP_NAME_MAX];
snprintf(key, sizeof(key), "%s.%s",
@@ -329,7 +332,23 @@
}
}
+ bool setLast[LOG_ID_MAX];
+ bool doSetLast = false;
+ log_id_for_each(i) {
+ doSetLast |= setLast[i] = mLastSet[i] && (it == mLast[i]);
+ }
it = mLogElements.erase(it);
+ if (doSetLast) {
+ log_id_for_each(i) {
+ if (setLast[i]) {
+ if (it == mLogElements.end()) { // unlikely
+ mLastSet[i] = false;
+ } else {
+ mLast[i] = it;
+ }
+ }
+ }
+ }
if (coalesce) {
stats.erase(element);
} else {
@@ -490,7 +509,8 @@
if (caller_uid != AID_ROOT) {
// Only here if clearAll condition (pruneRows == ULONG_MAX)
- for(it = mLogElements.begin(); it != mLogElements.end();) {
+ it = mLastSet[id] ? mLast[id] : mLogElements.begin();
+ while (it != mLogElements.end()) {
LogBufferElement *element = *it;
if ((element->getLogId() != id) || (element->getUid() != caller_uid)) {
@@ -498,6 +518,11 @@
continue;
}
+ if (!mLastSet[id] || ((*mLast[id])->getLogId() != id)) {
+ mLast[id] = it;
+ mLastSet[id] = true;
+ }
+
if (oldest && (oldest->mStart <= element->getSequence())) {
busy = true;
if (oldest->mTimeout.tv_sec || oldest->mTimeout.tv_nsec) {
@@ -566,7 +591,7 @@
bool kick = false;
bool leading = true;
- it = mLogElements.begin();
+ it = mLastSet[id] ? mLast[id] : mLogElements.begin();
// Perform at least one mandatory garbage collection cycle in following
// - clear leading chatty tags
// - coalesce chatty tags
@@ -615,6 +640,11 @@
continue;
}
+ if (leading && (!mLastSet[id] || ((*mLast[id])->getLogId() != id))) {
+ mLast[id] = it;
+ mLastSet[id] = true;
+ }
+
unsigned short dropped = element->getDropped();
// remove any leading drops
@@ -725,7 +755,7 @@
bool whitelist = false;
bool hasWhitelist = (id != LOG_ID_SECURITY) && mPrune.nice() && !clearAll;
- it = mLogElements.begin();
+ it = mLastSet[id] ? mLast[id] : mLogElements.begin();
while((pruneRows > 0) && (it != mLogElements.end())) {
LogBufferElement *element = *it;
@@ -734,6 +764,11 @@
continue;
}
+ if (!mLastSet[id] || ((*mLast[id])->getLogId() != id)) {
+ mLast[id] = it;
+ mLastSet[id] = true;
+ }
+
if (oldest && (oldest->mStart <= element->getSequence())) {
busy = true;
if (whitelist) {
@@ -764,7 +799,7 @@
// Do not save the whitelist if we are reader range limited
if (whitelist && (pruneRows > 0)) {
- it = mLogElements.begin();
+ it = mLastSet[id] ? mLast[id] : mLogElements.begin();
while((it != mLogElements.end()) && (pruneRows > 0)) {
LogBufferElement *element = *it;
@@ -773,6 +808,11 @@
continue;
}
+ if (!mLastSet[id] || ((*mLast[id])->getLogId() != id)) {
+ mLast[id] = it;
+ mLastSet[id] = true;
+ }
+
if (oldest && (oldest->mStart <= element->getSequence())) {
busy = true;
if (stats.sizes(id) > (2 * log_buffer_size(id))) {
diff --git a/logd/LogBuffer.h b/logd/LogBuffer.h
index 2667e78..03739c7 100644
--- a/logd/LogBuffer.h
+++ b/logd/LogBuffer.h
@@ -82,6 +82,9 @@
LogStatistics stats;
PruneList mPrune;
+ // watermark for last per log id
+ LogBufferElementCollection::iterator mLast[LOG_ID_MAX];
+ bool mLastSet[LOG_ID_MAX];
// watermark of any worst/chatty uid processing
typedef std::unordered_map<uid_t,
LogBufferElementCollection::iterator>
diff --git a/logd/LogListener.cpp b/logd/LogListener.cpp
index 5348a2d..846dd7c 100644
--- a/logd/LogListener.cpp
+++ b/logd/LogListener.cpp
@@ -15,6 +15,7 @@
*/
#include <limits.h>
+#include <sys/cdefs.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/types.h>
@@ -46,7 +47,7 @@
+ LOGGER_ENTRY_MAX_PAYLOAD];
struct iovec iov = { buffer, sizeof(buffer) };
- char control[CMSG_SPACE(sizeof(struct ucred))];
+ char control[CMSG_SPACE(sizeof(struct ucred))] __aligned(4);
struct msghdr hdr = {
NULL,
0,
diff --git a/logd/tests/Android.mk b/logd/tests/Android.mk
index a7c6b53..808087a 100644
--- a/logd/tests/Android.mk
+++ b/logd/tests/Android.mk
@@ -43,6 +43,6 @@
LOCAL_MODULE := $(test_module_prefix)unit-tests
LOCAL_MODULE_TAGS := $(test_tags)
LOCAL_CFLAGS += $(test_c_flags)
-LOCAL_SHARED_LIBRARIES := libcutils
+LOCAL_SHARED_LIBRARIES := libbase libcutils liblog
LOCAL_SRC_FILES := $(test_src_files)
include $(BUILD_NATIVE_TEST)
diff --git a/logd/tests/logd_test.cpp b/logd/tests/logd_test.cpp
index 7d0dd44..de19790 100644
--- a/logd/tests/logd_test.cpp
+++ b/logd/tests/logd_test.cpp
@@ -15,16 +15,20 @@
*/
#include <fcntl.h>
+#include <inttypes.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
+#include <string>
+
#include <gtest/gtest.h>
-#include "cutils/sockets.h"
-#include "log/log.h"
-#include "log/logger.h"
+#include <android-base/stringprintf.h>
+#include <cutils/sockets.h>
+#include <log/log.h>
+#include <log/logger.h>
/*
* returns statistics
@@ -198,6 +202,10 @@
static void dump_log_msg(const char *prefix,
log_msg *msg, unsigned int version, int lid) {
+ std::cout << std::flush;
+ std::cerr << std::flush;
+ fflush(stdout);
+ fflush(stderr);
switch(msg->entry.hdr_size) {
case 0:
version = 1;
@@ -282,6 +290,7 @@
}
}
fprintf(stderr, "}\n");
+ fflush(stderr);
}
TEST(logd, both) {
@@ -524,7 +533,8 @@
ASSERT_GT(totalSize, nowSpamSize * 2);
}
-TEST(logd, timeout) {
+// b/26447386 confirm fixed
+void timeout_negative(const char *command) {
log_msg msg_wrap, msg_timeout;
bool content_wrap = false, content_timeout = false, written = false;
unsigned int alarm_wrap = 0, alarm_timeout = 0;
@@ -538,6 +548,8 @@
SOCK_SEQPACKET);
ASSERT_LT(0, fd);
+ std::string ask(command);
+
struct sigaction ignore, old_sigaction;
memset(&ignore, 0, sizeof(ignore));
ignore.sa_handler = caught_signal;
@@ -545,8 +557,8 @@
sigaction(SIGALRM, &ignore, &old_sigaction);
unsigned int old_alarm = alarm(3);
- static const char ask[] = "dumpAndClose lids=0,1,2,3,4,5 timeout=6";
- written = write(fd, ask, sizeof(ask)) == sizeof(ask);
+ size_t len = ask.length() + 1;
+ written = write(fd, ask.c_str(), len) == (ssize_t)len;
if (!written) {
alarm(old_alarm);
sigaction(SIGALRM, &old_sigaction, NULL);
@@ -559,6 +571,9 @@
alarm_wrap = alarm(5);
content_timeout = recv(fd, msg_timeout.buf, sizeof(msg_timeout), 0) > 0;
+ if (!content_timeout) { // make sure we hit dumpAndClose
+ content_timeout = recv(fd, msg_timeout.buf, sizeof(msg_timeout), 0) > 0;
+ }
alarm_timeout = alarm((old_alarm <= 0)
? old_alarm
@@ -569,7 +584,7 @@
close(fd);
- if (!content_wrap && !alarm_wrap && content_timeout && !alarm_timeout) {
+ if (!content_wrap && !alarm_wrap && content_timeout && alarm_timeout) {
break;
}
}
@@ -583,6 +598,113 @@
}
EXPECT_TRUE(written);
+ EXPECT_TRUE(content_wrap);
+ EXPECT_NE(0U, alarm_wrap);
+ EXPECT_TRUE(content_timeout);
+ EXPECT_NE(0U, alarm_timeout);
+}
+
+TEST(logd, timeout_no_start) {
+ timeout_negative("dumpAndClose lids=0,1,2,3,4,5 timeout=6");
+}
+
+TEST(logd, timeout_start_epoch) {
+ timeout_negative("dumpAndClose lids=0,1,2,3,4,5 timeout=6 start=0.000000000");
+}
+
+// b/26447386 refined behavior
+TEST(logd, timeout) {
+ log_msg msg_wrap, msg_timeout;
+ bool content_wrap = false, content_timeout = false, written = false;
+ unsigned int alarm_wrap = 0, alarm_timeout = 0;
+ // A few tries to get it right just in case wrap kicks in due to
+ // content providers being active during the test
+ int i = 5;
+ log_time now(android_log_clockid());
+ now.tv_sec -= 30; // reach back a moderate period of time
+
+ while (--i) {
+ int fd = socket_local_client("logdr",
+ ANDROID_SOCKET_NAMESPACE_RESERVED,
+ SOCK_SEQPACKET);
+ ASSERT_LT(0, fd);
+
+ std::string ask = android::base::StringPrintf(
+ "dumpAndClose lids=0,1,2,3,4,5 timeout=6 start=%"
+ PRIu32 ".%09" PRIu32,
+ now.tv_sec, now.tv_nsec);
+
+ struct sigaction ignore, old_sigaction;
+ memset(&ignore, 0, sizeof(ignore));
+ ignore.sa_handler = caught_signal;
+ sigemptyset(&ignore.sa_mask);
+ sigaction(SIGALRM, &ignore, &old_sigaction);
+ unsigned int old_alarm = alarm(3);
+
+ size_t len = ask.length() + 1;
+ written = write(fd, ask.c_str(), len) == (ssize_t)len;
+ if (!written) {
+ alarm(old_alarm);
+ sigaction(SIGALRM, &old_sigaction, NULL);
+ close(fd);
+ continue;
+ }
+
+ content_wrap = recv(fd, msg_wrap.buf, sizeof(msg_wrap), 0) > 0;
+
+ alarm_wrap = alarm(5);
+
+ content_timeout = recv(fd, msg_timeout.buf, sizeof(msg_timeout), 0) > 0;
+ if (!content_timeout) { // make sure we hit dumpAndClose
+ content_timeout = recv(fd, msg_timeout.buf, sizeof(msg_timeout), 0) > 0;
+ }
+
+ alarm_timeout = alarm((old_alarm <= 0)
+ ? old_alarm
+ : (old_alarm > (1 + 3 - alarm_wrap))
+ ? old_alarm - 3 + alarm_wrap
+ : 2);
+ sigaction(SIGALRM, &old_sigaction, NULL);
+
+ close(fd);
+
+ if (!content_wrap && !alarm_wrap && content_timeout && alarm_timeout) {
+ break;
+ }
+
+ // modify start time in case content providers are relatively
+ // active _or_ inactive during the test.
+ if (content_timeout) {
+ log_time msg(msg_timeout.entry.sec, msg_timeout.entry.nsec);
+ EXPECT_FALSE(msg < now);
+ if (msg > now) {
+ now = msg;
+ now.tv_sec += 30;
+ msg = log_time(android_log_clockid());
+ if (now > msg) {
+ now = msg;
+ --now.tv_sec;
+ }
+ }
+ } else {
+ now.tv_sec -= 120; // inactive, reach further back!
+ }
+ }
+
+ if (content_wrap) {
+ dump_log_msg("wrap", &msg_wrap, 3, -1);
+ }
+
+ if (content_timeout) {
+ dump_log_msg("timeout", &msg_timeout, 3, -1);
+ }
+
+ if (content_wrap || !content_timeout) {
+ fprintf(stderr, "now=%" PRIu32 ".%09" PRIu32 "\n",
+ now.tv_sec, now.tv_nsec);
+ }
+
+ EXPECT_TRUE(written);
EXPECT_FALSE(content_wrap);
EXPECT_EQ(0U, alarm_wrap);
EXPECT_TRUE(content_timeout);
diff --git a/metricsd/.clang-format b/metricsd/.clang-format
index 65d8277..c98efc2 100644
--- a/metricsd/.clang-format
+++ b/metricsd/.clang-format
@@ -2,6 +2,7 @@
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
+BinPackArguments: false
BinPackParameters: false
CommentPragmas: NOLINT:.*
DerivePointerAlignment: false
diff --git a/metricsd/Android.mk b/metricsd/Android.mk
index 7381703..250c657 100644
--- a/metricsd/Android.mk
+++ b/metricsd/Android.mk
@@ -38,6 +38,7 @@
uploader/metrics_hashes.cc \
uploader/metrics_log_base.cc \
uploader/metrics_log.cc \
+ uploader/metricsd_service_runner.cc \
uploader/sender_http.cc \
uploader/system_profile_cache.cc \
uploader/upload_service.cc
@@ -84,6 +85,7 @@
metricsd_shared_libraries := \
libbinder \
libbrillo \
+ libbrillo-binder \
libbrillo-http \
libchrome \
libprotobuf-cpp-lite \
@@ -200,6 +202,9 @@
LOCAL_SHARED_LIBRARIES := $(metricsd_shared_libraries)
LOCAL_SRC_FILES := $(metricsd_tests_sources) $(metricsd_common)
LOCAL_STATIC_LIBRARIES := libBionicGtestMain libgmock metricsd_protos metricsd_binder_proxy
+ifdef BRILLO
+LOCAL_MODULE_TAGS := debug
+endif
include $(BUILD_NATIVE_TEST)
# Unit tests for metrics_collector.
@@ -215,6 +220,9 @@
$(metrics_collector_common)
LOCAL_STATIC_LIBRARIES := libBionicGtestMain libgmock metricsd_binder_proxy \
$(metrics_collector_static_libraries)
+ifdef BRILLO
+LOCAL_MODULE_TAGS := debug
+endif
include $(BUILD_NATIVE_TEST)
# Weave schema files
diff --git a/metricsd/collectors/cpu_usage_collector.cc b/metricsd/collectors/cpu_usage_collector.cc
index 05934b4..9b0bb34 100644
--- a/metricsd/collectors/cpu_usage_collector.cc
+++ b/metricsd/collectors/cpu_usage_collector.cc
@@ -104,14 +104,15 @@
uint64_t *user_ticks,
uint64_t *user_nice_ticks,
uint64_t *system_ticks) {
- std::vector<std::string> proc_stat_lines;
- base::SplitString(stat_content, '\n', &proc_stat_lines);
+ std::vector<std::string> proc_stat_lines = base::SplitString(
+ stat_content, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
if (proc_stat_lines.empty()) {
LOG(WARNING) << "No lines found in " << kMetricsProcStatFileName;
return false;
}
- std::vector<std::string> proc_stat_totals;
- base::SplitStringAlongWhitespace(proc_stat_lines[0], &proc_stat_totals);
+ std::vector<std::string> proc_stat_totals =
+ base::SplitString(proc_stat_lines[0], base::kWhitespaceASCII,
+ base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
if (proc_stat_totals.size() != kMetricsProcStatFirstLineItemsCount ||
proc_stat_totals[0] != "cpu" ||
diff --git a/metricsd/constants.h b/metricsd/constants.h
index 4815888..b702737 100644
--- a/metricsd/constants.h
+++ b/metricsd/constants.h
@@ -26,6 +26,7 @@
static const char kMetricsServer[] = "https://clients4.google.com/uma/v2";
static const char kConsentFileName[] = "enabled";
static const char kStagedLogName[] = "staged_log";
+static const char kSavedLogName[] = "saved_log";
static const char kFailedUploadCountName[] = "failed_upload_count";
static const char kDefaultVersion[] = "0.0.0.0";
diff --git a/metricsd/libmetrics-334380.gyp b/metricsd/libmetrics-369476.gyp
similarity index 72%
rename from metricsd/libmetrics-334380.gyp
rename to metricsd/libmetrics-369476.gyp
index 9771821..b545d35 100644
--- a/metricsd/libmetrics-334380.gyp
+++ b/metricsd/libmetrics-369476.gyp
@@ -1,6 +1,6 @@
{
'variables': {
- 'libbase_ver': 334380,
+ 'libbase_ver': 369476,
},
'includes': [
'libmetrics.gypi',
diff --git a/metricsd/metrics_collector.cc b/metricsd/metrics_collector.cc
index 2cf2338..ec7e040 100644
--- a/metricsd/metrics_collector.cc
+++ b/metricsd/metrics_collector.cc
@@ -534,18 +534,20 @@
bool MetricsCollector::FillMeminfo(const string& meminfo_raw,
vector<MeminfoRecord>* fields) {
- vector<string> lines;
- unsigned int nlines = Tokenize(meminfo_raw, "\n", &lines);
+ vector<std::string> lines =
+ base::SplitString(meminfo_raw, "\n", base::KEEP_WHITESPACE,
+ base::SPLIT_WANT_NONEMPTY);
// Scan meminfo output and collect field values. Each field name has to
// match a meminfo entry (case insensitive) after removing non-alpha
// characters from the entry.
- unsigned int ifield = 0;
- for (unsigned int iline = 0;
- iline < nlines && ifield < fields->size();
+ size_t ifield = 0;
+ for (size_t iline = 0;
+ iline < lines.size() && ifield < fields->size();
iline++) {
- vector<string> tokens;
- Tokenize(lines[iline], ": ", &tokens);
+ vector<string> tokens =
+ base::SplitString(lines[iline], ": ", base::KEEP_WHITESPACE,
+ base::SPLIT_WANT_NONEMPTY);
if (strcmp((*fields)[ifield].match, tokens[0].c_str()) == 0) {
// Name matches. Parse value and save.
if (!base::StringToInt(tokens[1], &(*fields)[ifield].value)) {
diff --git a/metricsd/metrics_collector_main.cc b/metricsd/metrics_collector_main.cc
index d7aaaf5..14bb935 100644
--- a/metricsd/metrics_collector_main.cc
+++ b/metricsd/metrics_collector_main.cc
@@ -41,7 +41,8 @@
}
dev_path = dev_path_cstr;
// Check that rootdev begins with "/dev/block/".
- if (!base::StartsWithASCII(dev_path, dev_prefix, false)) {
+ if (!base::StartsWith(dev_path, dev_prefix,
+ base::CompareCase::INSENSITIVE_ASCII)) {
LOG(WARNING) << "unexpected root device " << dev_path;
return "";
}
diff --git a/metricsd/metricsd_main.cc b/metricsd/metricsd_main.cc
index f460268..0178342 100644
--- a/metricsd/metricsd_main.cc
+++ b/metricsd/metricsd_main.cc
@@ -14,21 +14,15 @@
* limitations under the License.
*/
-#include <thread>
-
-#include <base/at_exit.h>
#include <base/command_line.h>
#include <base/files/file_path.h>
#include <base/logging.h>
-#include <base/metrics/statistics_recorder.h>
-#include <base/strings/string_util.h>
#include <base/time/time.h>
#include <brillo/flag_helper.h>
#include <brillo/syslog_logging.h>
#include "constants.h"
-#include "uploader/bn_metricsd_impl.h"
-#include "uploader/crash_counters.h"
+#include "uploader/metricsd_service_runner.h"
#include "uploader/upload_service.h"
int main(int argc, char** argv) {
@@ -39,10 +33,13 @@
// Upload Service flags.
DEFINE_int32(upload_interval_secs, 1800,
- "Interval at which metrics_daemon sends the metrics. (needs "
- "-uploader)");
+ "Interval at which metricsd uploads the metrics.");
+ DEFINE_int32(disk_persistence_interval_secs, 300,
+ "Interval at which metricsd saves the aggregated metrics to "
+ "disk to avoid losing them if metricsd stops in between "
+ "two uploads.");
DEFINE_string(server, metrics::kMetricsServer,
- "Server to upload the metrics to. (needs -uploader)");
+ "Server to upload the metrics to.");
DEFINE_string(private_directory, metrics::kMetricsdDirectory,
"Path to the private directory used by metricsd "
"(testing only)");
@@ -76,18 +73,11 @@
return errno;
}
- std::shared_ptr<CrashCounters> counters(new CrashCounters);
-
UploadService upload_service(
FLAGS_server, base::TimeDelta::FromSeconds(FLAGS_upload_interval_secs),
+ base::TimeDelta::FromSeconds(FLAGS_disk_persistence_interval_secs),
base::FilePath(FLAGS_private_directory),
- base::FilePath(FLAGS_shared_directory), counters);
+ base::FilePath(FLAGS_shared_directory));
- base::StatisticsRecorder::Initialize();
-
- // Create and start the binder thread.
- BnMetricsdImpl binder_service(counters);
- std::thread binder_thread(&BnMetricsdImpl::Run, &binder_service);
-
- upload_service.Run();
+ return upload_service.Run();
}
diff --git a/metricsd/uploader/bn_metricsd_impl.cc b/metricsd/uploader/bn_metricsd_impl.cc
index 2cbc2da..219ed60 100644
--- a/metricsd/uploader/bn_metricsd_impl.cc
+++ b/metricsd/uploader/bn_metricsd_impl.cc
@@ -19,8 +19,6 @@
#include <base/metrics/histogram.h>
#include <base/metrics/sparse_histogram.h>
#include <base/metrics/statistics_recorder.h>
-#include <binder/IPCThreadState.h>
-#include <binder/IServiceManager.h>
#include <utils/Errors.h>
#include <utils/String16.h>
#include <utils/String8.h>
@@ -37,16 +35,6 @@
CHECK(counters_) << "Invalid counters argument to constructor";
}
-void BnMetricsdImpl::Run() {
- android::status_t status =
- android::defaultServiceManager()->addService(getInterfaceDescriptor(),
- this);
- CHECK(status == android::OK) << "Metricsd service registration failed";
- android::ProcessState::self()->setThreadPoolMaxThreadCount(0);
- android::IPCThreadState::self()->disableBackgroundScheduling(true);
- android::IPCThreadState::self()->joinThreadPool();
-}
-
Status BnMetricsdImpl::recordHistogram(
const String16& name, int sample, int min, int max, int nbuckets) {
base::HistogramBase* histogram = base::Histogram::FactoryGet(
diff --git a/metricsd/uploader/bn_metricsd_impl.h b/metricsd/uploader/bn_metricsd_impl.h
index 016ccb6..bf47e80 100644
--- a/metricsd/uploader/bn_metricsd_impl.h
+++ b/metricsd/uploader/bn_metricsd_impl.h
@@ -25,9 +25,6 @@
explicit BnMetricsdImpl(const std::shared_ptr<CrashCounters>& counters);
virtual ~BnMetricsdImpl() = default;
- // Starts the binder main loop.
- void Run();
-
// Records a histogram.
android::binder::Status recordHistogram(const android::String16& name,
int sample,
diff --git a/metricsd/uploader/metrics_log.cc b/metricsd/uploader/metrics_log.cc
index a01b5da..fcaa8c1 100644
--- a/metricsd/uploader/metrics_log.cc
+++ b/metricsd/uploader/metrics_log.cc
@@ -18,6 +18,8 @@
#include <string>
+#include <base/files/file_util.h>
+
#include "uploader/proto/system_profile.pb.h"
#include "uploader/system_profile_setter.h"
@@ -27,6 +29,40 @@
: MetricsLogBase("", 0, metrics::MetricsLogBase::ONGOING_LOG, "") {
}
+bool MetricsLog::LoadFromFile(const base::FilePath& saved_log) {
+ std::string encoded_log;
+ if (!base::ReadFileToString(saved_log, &encoded_log)) {
+ LOG(ERROR) << "Failed to read the metrics log backup from "
+ << saved_log.value();
+ return false;
+ }
+
+ if (!uma_proto()->ParseFromString(encoded_log)) {
+ LOG(ERROR) << "Failed to parse log from " << saved_log.value()
+ << ", deleting the log";
+ base::DeleteFile(saved_log, false);
+ uma_proto()->Clear();
+ return false;
+ }
+
+ VLOG(1) << uma_proto()->histogram_event_size() << " histograms loaded from "
+ << saved_log.value();
+
+ return true;
+}
+
+bool MetricsLog::SaveToFile(const base::FilePath& path) {
+ std::string encoded_log;
+ GetEncodedLog(&encoded_log);
+
+ if (static_cast<int>(encoded_log.size()) !=
+ base::WriteFile(path, encoded_log.data(), encoded_log.size())) {
+ LOG(ERROR) << "Failed to persist the current log to " << path.value();
+ return false;
+ }
+ return true;
+}
+
void MetricsLog::IncrementUserCrashCount(unsigned int count) {
metrics::SystemProfileProto::Stability* stability(
uma_proto()->mutable_system_profile()->mutable_stability());
@@ -49,5 +85,6 @@
}
bool MetricsLog::PopulateSystemProfile(SystemProfileSetter* profile_setter) {
+ CHECK(profile_setter);
return profile_setter->Populate(uma_proto());
}
diff --git a/metricsd/uploader/metrics_log.h b/metricsd/uploader/metrics_log.h
index b76cd72..9e60b97 100644
--- a/metricsd/uploader/metrics_log.h
+++ b/metricsd/uploader/metrics_log.h
@@ -19,6 +19,7 @@
#include <string>
+#include <base/files/file_path.h>
#include <base/macros.h>
#include "uploader/metrics_log_base.h"
@@ -44,8 +45,15 @@
// Populate the system profile with system information using setter.
bool PopulateSystemProfile(SystemProfileSetter* setter);
+ // Load the log from |path|.
+ bool LoadFromFile(const base::FilePath& path);
+
+ // Save this log to |path|.
+ bool SaveToFile(const base::FilePath& path);
+
private:
friend class UploadServiceTest;
+ FRIEND_TEST(UploadServiceTest, CurrentLogSavedAndResumed);
FRIEND_TEST(UploadServiceTest, LogContainsAggregatedValues);
FRIEND_TEST(UploadServiceTest, LogContainsCrashCounts);
FRIEND_TEST(UploadServiceTest, LogKernelCrash);
diff --git a/metricsd/uploader/metricsd_service_runner.cc b/metricsd/uploader/metricsd_service_runner.cc
new file mode 100644
index 0000000..5a759d3
--- /dev/null
+++ b/metricsd/uploader/metricsd_service_runner.cc
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include "uploader/metricsd_service_runner.h"
+
+#include <thread>
+
+#include <binder/IServiceManager.h>
+#include <brillo/binder_watcher.h>
+#include <utils/Errors.h>
+
+#include "uploader/bn_metricsd_impl.h"
+
+MetricsdServiceRunner::MetricsdServiceRunner(
+ std::shared_ptr<CrashCounters> counters)
+ : counters_(counters) {}
+
+void MetricsdServiceRunner::Start() {
+ thread_.reset(new std::thread(&MetricsdServiceRunner::Run, this));
+}
+
+void MetricsdServiceRunner::Run() {
+ android::sp<BnMetricsdImpl> metrics_service(new BnMetricsdImpl(counters_));
+
+ android::status_t status = android::defaultServiceManager()->addService(
+ metrics_service->getInterfaceDescriptor(), metrics_service);
+ CHECK(status == android::OK) << "Metricsd service registration failed";
+
+ message_loop_for_io_.reset(new base::MessageLoopForIO);
+
+ brillo::BinderWatcher watcher;
+ CHECK(watcher.Init()) << "failed to initialize the binder file descriptor "
+ << "watcher";
+
+ message_loop_for_io_->Run();
+
+ // Delete the message loop here as it needs to be deconstructed in the thread
+ // it is attached to.
+ message_loop_for_io_.reset();
+}
+
+void MetricsdServiceRunner::Stop() {
+ message_loop_for_io_->PostTask(FROM_HERE,
+ message_loop_for_io_->QuitWhenIdleClosure());
+
+ thread_->join();
+}
diff --git a/metricsd/uploader/metricsd_service_runner.h b/metricsd/uploader/metricsd_service_runner.h
new file mode 100644
index 0000000..1715de0
--- /dev/null
+++ b/metricsd/uploader/metricsd_service_runner.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef METRICS_UPLOADER_METRISCD_SERVICE_RUNNER_H_
+#define METRICS_UPLOADER_METRISCD_SERVICE_RUNNER_H_
+
+#include <memory>
+#include <thread>
+
+#include <base/message_loop/message_loop.h>
+
+#include "uploader/crash_counters.h"
+
+class MetricsdServiceRunner {
+ public:
+ MetricsdServiceRunner(std::shared_ptr<CrashCounters> counters);
+
+ // Start the Metricsd Binder service in a new thread.
+ void Start();
+
+ // Stop the Metricsd service and wait for its thread to exit.
+ void Stop();
+
+ private:
+ // Creates and run the main loop for metricsd's Binder service.
+ void Run();
+
+ std::unique_ptr<base::MessageLoopForIO> message_loop_for_io_;
+
+ std::unique_ptr<std::thread> thread_;
+ std::shared_ptr<CrashCounters> counters_;
+};
+
+#endif // METRICS_UPLOADER_METRISCD_SERVICE_RUNNER_H_
diff --git a/metricsd/uploader/system_profile_cache.cc b/metricsd/uploader/system_profile_cache.cc
index 70f6afd..e6f6617 100644
--- a/metricsd/uploader/system_profile_cache.cc
+++ b/metricsd/uploader/system_profile_cache.cc
@@ -80,6 +80,10 @@
} else {
reader.Load();
auto client = update_engine::UpdateEngineClient::CreateInstance();
+ if (!client) {
+ LOG(ERROR) << "failed to create the update engine client";
+ return false;
+ }
if (!client->GetChannel(&channel)) {
LOG(ERROR) << "failed to read the current channel from update engine.";
return false;
diff --git a/metricsd/uploader/upload_service.cc b/metricsd/uploader/upload_service.cc
index 2fb30c3..0dc59a4 100644
--- a/metricsd/uploader/upload_service.cc
+++ b/metricsd/uploader/upload_service.cc
@@ -42,49 +42,89 @@
UploadService::UploadService(const std::string& server,
const base::TimeDelta& upload_interval,
+ const base::TimeDelta& disk_persistence_interval,
const base::FilePath& private_metrics_directory,
- const base::FilePath& shared_metrics_directory,
- const std::shared_ptr<CrashCounters> counters)
- : histogram_snapshot_manager_(this),
+ const base::FilePath& shared_metrics_directory)
+ : brillo::Daemon(),
+ histogram_snapshot_manager_(this),
sender_(new HttpSender(server)),
failed_upload_count_(metrics::kFailedUploadCountName,
private_metrics_directory),
- counters_(counters),
- upload_interval_(upload_interval) {
+ counters_(new CrashCounters),
+ upload_interval_(upload_interval),
+ disk_persistence_interval_(disk_persistence_interval),
+ metricsd_service_runner_(counters_) {
staged_log_path_ = private_metrics_directory.Append(metrics::kStagedLogName);
+ saved_log_path_ = private_metrics_directory.Append(metrics::kSavedLogName);
consent_file_ = shared_metrics_directory.Append(metrics::kConsentFileName);
}
+void UploadService::LoadSavedLog() {
+ if (base::PathExists(saved_log_path_)) {
+ GetOrCreateCurrentLog()->LoadFromFile(saved_log_path_);
+ }
+}
+
int UploadService::OnInit() {
+ brillo::Daemon::OnInit();
+
+ base::StatisticsRecorder::Initialize();
+ metricsd_service_runner_.Start();
+
system_profile_setter_.reset(new SystemProfileCache());
- base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
- base::Bind(&UploadService::UploadEventCallback,
- base::Unretained(this),
- upload_interval_),
+ base::MessageLoop::current()->PostDelayedTask(
+ FROM_HERE,
+ base::Bind(&UploadService::UploadEventCallback, base::Unretained(this)),
upload_interval_);
+
+ base::MessageLoop::current()->PostDelayedTask(
+ FROM_HERE,
+ base::Bind(&UploadService::PersistEventCallback, base::Unretained(this)),
+ disk_persistence_interval_);
+
+ LoadSavedLog();
+
return EX_OK;
}
+void UploadService::OnShutdown(int* exit_code) {
+ metricsd_service_runner_.Stop();
+ PersistToDisk();
+}
+
void UploadService::InitForTest(SystemProfileSetter* setter) {
+ LoadSavedLog();
system_profile_setter_.reset(setter);
}
void UploadService::StartNewLog() {
- CHECK(!HasStagedLog()) << "the staged log should be discarded before "
- << "starting a new metrics log";
- MetricsLog* log = new MetricsLog();
- current_log_.reset(log);
+ current_log_.reset(new MetricsLog());
}
-void UploadService::UploadEventCallback(const base::TimeDelta& interval) {
+void UploadService::UploadEventCallback() {
UploadEvent();
- base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
- base::Bind(&UploadService::UploadEventCallback,
- base::Unretained(this),
- interval),
- interval);
+ base::MessageLoop::current()->PostDelayedTask(
+ FROM_HERE,
+ base::Bind(&UploadService::UploadEventCallback, base::Unretained(this)),
+ upload_interval_);
+}
+
+void UploadService::PersistEventCallback() {
+ PersistToDisk();
+
+ base::MessageLoop::current()->PostDelayedTask(
+ FROM_HERE,
+ base::Bind(&UploadService::PersistEventCallback, base::Unretained(this)),
+ disk_persistence_interval_);
+}
+
+void UploadService::PersistToDisk() {
+ GatherHistograms();
+ if (current_log_) {
+ current_log_->SaveToFile(saved_log_path_);
+ }
}
void UploadService::UploadEvent() {
@@ -178,14 +218,16 @@
<< "log.";
return;
}
- std::string encoded_log;
- staged_log->GetEncodedLog(&encoded_log);
+
+ if (!base::DeleteFile(saved_log_path_, false)) {
+ // There is a chance that we will upload the same metrics twice but, if we
+ // are lucky, the backup should be overridden before that. In doubt, try not
+ // to lose any metrics.
+ LOG(ERROR) << "failed to delete the last backup of the current log.";
+ }
failed_upload_count_.Set(0);
- if (static_cast<int>(encoded_log.size()) != base::WriteFile(
- staged_log_path_, encoded_log.data(), encoded_log.size())) {
- LOG(ERROR) << "failed to persist to " << staged_log_path_.value();
- }
+ staged_log->SaveToFile(staged_log_path_);
}
MetricsLog* UploadService::GetOrCreateCurrentLog() {
diff --git a/metricsd/uploader/upload_service.h b/metricsd/uploader/upload_service.h
index 420653e..a1d9d3b 100644
--- a/metricsd/uploader/upload_service.h
+++ b/metricsd/uploader/upload_service.h
@@ -28,6 +28,7 @@
#include "persistent_integer.h"
#include "uploader/crash_counters.h"
#include "uploader/metrics_log.h"
+#include "uploader/metricsd_service_runner.h"
#include "uploader/proto/chrome_user_metrics_extension.pb.h"
#include "uploader/sender.h"
#include "uploader/system_profile_cache.h"
@@ -65,19 +66,22 @@
public:
UploadService(const std::string& server,
const base::TimeDelta& upload_interval,
+ const base::TimeDelta& disk_persistence_interval,
const base::FilePath& private_metrics_directory,
- const base::FilePath& shared_metrics_directory,
- const std::shared_ptr<CrashCounters> counters);
+ const base::FilePath& shared_metrics_directory);
// Initializes the upload service.
- int OnInit();
+ int OnInit() override;
+
+ // Cleans up the internal state before exiting.
+ void OnShutdown(int* exit_code) override;
// Starts a new log. The log needs to be regenerated after each successful
// launch as it is destroyed when staging the log.
void StartNewLog();
- // Event callback for handling MessageLoop events.
- void UploadEventCallback(const base::TimeDelta& interval);
+ // Saves the current metrics to a file.
+ void PersistToDisk();
// Triggers an upload event.
void UploadEvent();
@@ -97,6 +101,8 @@
friend class UploadServiceTest;
FRIEND_TEST(UploadServiceTest, CanSendMultipleTimes);
+ FRIEND_TEST(UploadServiceTest, CorruptedSavedLog);
+ FRIEND_TEST(UploadServiceTest, CurrentLogSavedAndResumed);
FRIEND_TEST(UploadServiceTest, DiscardLogsAfterTooManyFailedUpload);
FRIEND_TEST(UploadServiceTest, EmptyLogsAreNotSent);
FRIEND_TEST(UploadServiceTest, FailedSendAreRetried);
@@ -108,6 +114,7 @@
FRIEND_TEST(UploadServiceTest, LogKernelCrash);
FRIEND_TEST(UploadServiceTest, LogUncleanShutdown);
FRIEND_TEST(UploadServiceTest, LogUserCrash);
+ FRIEND_TEST(UploadServiceTest, PersistEmptyLog);
FRIEND_TEST(UploadServiceTest, UnknownCrashIgnored);
FRIEND_TEST(UploadServiceTest, ValuesInConfigFileAreSent);
@@ -118,12 +125,21 @@
// will be discarded.
static const int kMaxFailedUpload;
+ // Loads the log saved to disk if it exists.
+ void LoadSavedLog();
+
// Resets the internal state.
void Reset();
// Returns true iff metrics reporting is enabled.
bool AreMetricsEnabled();
+ // Event callback for handling Upload events.
+ void UploadEventCallback();
+
+ // Event callback for handling Persist events.
+ void PersistEventCallback();
+
// Aggregates all histogram available in memory and store them in the current
// log.
void GatherHistograms();
@@ -153,9 +169,13 @@
std::shared_ptr<CrashCounters> counters_;
base::TimeDelta upload_interval_;
+ base::TimeDelta disk_persistence_interval_;
+
+ MetricsdServiceRunner metricsd_service_runner_;
base::FilePath consent_file_;
base::FilePath staged_log_path_;
+ base::FilePath saved_log_path_;
bool testing_;
};
diff --git a/metricsd/uploader/upload_service_test.cc b/metricsd/uploader/upload_service_test.cc
index ec507e8..70112f4 100644
--- a/metricsd/uploader/upload_service_test.cc
+++ b/metricsd/uploader/upload_service_test.cc
@@ -45,18 +45,18 @@
ASSERT_FALSE(base::StatisticsRecorder::IsActive());
base::StatisticsRecorder::Initialize();
- base::FilePath private_dir = dir_.path().Append("private");
- base::FilePath shared_dir = dir_.path().Append("shared");
+ private_dir_ = dir_.path().Append("private");
+ shared_dir_ = dir_.path().Append("shared");
- EXPECT_TRUE(base::CreateDirectory(private_dir));
- EXPECT_TRUE(base::CreateDirectory(shared_dir));
+ EXPECT_TRUE(base::CreateDirectory(private_dir_));
+ EXPECT_TRUE(base::CreateDirectory(shared_dir_));
- ASSERT_EQ(0, base::WriteFile(shared_dir.Append(metrics::kConsentFileName),
+ ASSERT_EQ(0, base::WriteFile(shared_dir_.Append(metrics::kConsentFileName),
"", 0));
- counters_.reset(new CrashCounters);
- upload_service_.reset(new UploadService("", base::TimeDelta(), private_dir,
- shared_dir, counters_));
+ upload_service_.reset(new UploadService(
+ "", base::TimeDelta(), base::TimeDelta(), private_dir_, shared_dir_));
+ counters_ = upload_service_->counters_;
upload_service_->sender_.reset(new SenderMock);
upload_service_->InitForTest(new MockSystemProfileSetter);
@@ -81,15 +81,16 @@
base::FilePath filepath =
dir_.path().Append("etc/os-release.d").Append(name);
ASSERT_TRUE(base::CreateDirectory(filepath.DirName()));
- ASSERT_EQ(
- value.size(),
- base::WriteFile(filepath, value.data(), value.size()));
+ ASSERT_EQ(value.size(),
+ base::WriteFile(filepath, value.data(), value.size()));
}
const metrics::SystemProfileProto_Stability GetCurrentStability() {
EXPECT_TRUE(upload_service_->current_log_.get());
- return upload_service_->current_log_->uma_proto()->system_profile().stability();
+ return upload_service_->current_log_->uma_proto()
+ ->system_profile()
+ .stability();
}
base::ScopedTempDir dir_;
@@ -97,6 +98,8 @@
std::unique_ptr<base::AtExitManager> exit_manager_;
std::shared_ptr<CrashCounters> counters_;
+ base::FilePath private_dir_;
+ base::FilePath shared_dir_;
};
TEST_F(UploadServiceTest, FailedSendAreRetried) {
@@ -149,12 +152,9 @@
}
TEST_F(UploadServiceTest, LogEmptyByDefault) {
- UploadService upload_service("", base::TimeDelta(), dir_.path(), dir_.path(),
- std::make_shared<CrashCounters>());
-
- // current_log_ should be initialized later as it needs AtExitManager to exit
+ // current_log_ should be initialized later as it needs AtExitManager to exist
// in order to gather system information from SysInfo.
- EXPECT_FALSE(upload_service.current_log_);
+ EXPECT_FALSE(upload_service_->current_log_);
}
TEST_F(UploadServiceTest, CanSendMultipleTimes) {
@@ -222,10 +222,8 @@
}
TEST_F(UploadServiceTest, ExtractChannelFromString) {
- EXPECT_EQ(
- SystemProfileCache::ProtoChannelFromString(
- "developer-build"),
- metrics::SystemProfileProto::CHANNEL_UNKNOWN);
+ EXPECT_EQ(SystemProfileCache::ProtoChannelFromString("developer-build"),
+ metrics::SystemProfileProto::CHANNEL_UNKNOWN);
EXPECT_EQ(metrics::SystemProfileProto::CHANNEL_DEV,
SystemProfileCache::ProtoChannelFromString("dev-channel"));
@@ -300,3 +298,38 @@
SetTestingProperty(metrics::kProductId, "hello");
ASSERT_TRUE(cache.Initialize());
}
+
+TEST_F(UploadServiceTest, CurrentLogSavedAndResumed) {
+ SendHistogram("hello", 10, 0, 100, 10);
+ upload_service_->PersistToDisk();
+ EXPECT_EQ(
+ 1, upload_service_->current_log_->uma_proto()->histogram_event().size());
+ upload_service_.reset(new UploadService(
+ "", base::TimeDelta(), base::TimeDelta(), private_dir_, shared_dir_));
+ upload_service_->InitForTest(nullptr);
+
+ SendHistogram("hello", 10, 0, 100, 10);
+ upload_service_->GatherHistograms();
+ EXPECT_EQ(2, upload_service_->GetOrCreateCurrentLog()
+ ->uma_proto()
+ ->histogram_event()
+ .size());
+}
+
+TEST_F(UploadServiceTest, PersistEmptyLog) {
+ upload_service_->PersistToDisk();
+ EXPECT_FALSE(base::PathExists(upload_service_->saved_log_path_));
+}
+
+TEST_F(UploadServiceTest, CorruptedSavedLog) {
+ // Write a bogus saved log.
+ EXPECT_EQ(5, base::WriteFile(upload_service_->saved_log_path_, "hello", 5));
+
+ upload_service_.reset(new UploadService(
+ "", base::TimeDelta(), base::TimeDelta(), private_dir_, shared_dir_));
+
+ upload_service_->InitForTest(nullptr);
+ // If the log is unreadable, we drop it and continue execution.
+ ASSERT_NE(nullptr, upload_service_->GetOrCreateCurrentLog());
+ ASSERT_FALSE(base::PathExists(upload_service_->saved_log_path_));
+}
diff --git a/rootdir/init.rc b/rootdir/init.rc
index d322402..e400c85 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -28,6 +28,10 @@
on init
sysclktz 0
+ # Mix device-specific information into the entropy pool
+ copy /proc/cmdline /dev/urandom
+ copy /default.prop /dev/urandom
+
# Backward compatibility.
symlink /system/etc /etc
symlink /sys/kernel/debug /d
diff --git a/rootdir/ueventd.rc b/rootdir/ueventd.rc
index b735dc3..6ef491c 100644
--- a/rootdir/ueventd.rc
+++ b/rootdir/ueventd.rc
@@ -1,6 +1,13 @@
subsystem adf
devname uevent_devname
+# ueventd can only set permissions on device nodes and their associated
+# sysfs attributes, not on arbitrary paths.
+#
+# format for /dev rules: devname mode uid gid
+# format for /sys rules: nodename attr mode uid gid
+# shortcut: "mtd@NN" expands to "/dev/mtd/mtdNN"
+
/dev/null 0666 root root
/dev/zero 0666 root root
/dev/full 0666 root root
diff --git a/toolbox/ps.c b/toolbox/ps.c
index 3bc540d..ecc1c9f 100644
--- a/toolbox/ps.c
+++ b/toolbox/ps.c
@@ -57,7 +57,7 @@
int prio, nice, rtprio, sched, psr;
struct passwd *pw;
- sprintf(statline, "/proc/%d", pid);
+ sprintf(statline, "/proc/%d", tid ? tid : pid);
stat(statline, &stats);
if(tid) {