Merge "Hide gnu extension warnings in log/log.h"
diff --git a/adb/Android.mk b/adb/Android.mk
index b2a0dc4..0114ca3 100644
--- a/adb/Android.mk
+++ b/adb/Android.mk
@@ -62,6 +62,7 @@
adb_listeners_test.cpp \
adb_utils_test.cpp \
fdevent_test.cpp \
+ socket_spec_test.cpp \
socket_test.cpp \
sysdeps_test.cpp \
sysdeps/stat_test.cpp \
diff --git a/adb/adb_auth_host.cpp b/adb/adb_auth_host.cpp
index 8366549..072c7f5 100644
--- a/adb/adb_auth_host.cpp
+++ b/adb/adb_auth_host.cpp
@@ -45,7 +45,6 @@
#include "adb_auth.h"
#include "adb_utils.h"
#include "sysdeps.h"
-#include "sysdeps/mutex.h"
static std::mutex& g_keys_mutex = *new std::mutex;
static std::map<std::string, std::shared_ptr<RSA>>& g_keys =
diff --git a/adb/commandline.cpp b/adb/commandline.cpp
index 77c5f96..a9185a0 100644
--- a/adb/commandline.cpp
+++ b/adb/commandline.cpp
@@ -37,6 +37,7 @@
#include <android-base/file.h>
#include <android-base/logging.h>
+#include <android-base/parseint.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
@@ -1549,23 +1550,32 @@
// If -L, -H, or -P are specified, ignore environment variables.
// Otherwise, prefer ADB_SERVER_SOCKET over ANDROID_ADB_SERVER_ADDRESS/PORT.
- if (!(server_host_str || server_port_str || server_socket_str)) {
- server_socket_str = server_socket_str ? server_socket_str : getenv("ADB_SERVER_SOCKET");
+ if (!server_host_str && !server_port_str && !server_socket_str) {
+ server_socket_str = getenv("ADB_SERVER_SOCKET");
}
if (!server_socket_str) {
// tcp:1234 and tcp:localhost:1234 are different with -a, so don't default to localhost
server_host_str = server_host_str ? server_host_str : getenv("ANDROID_ADB_SERVER_ADDRESS");
- long server_port = DEFAULT_ADB_PORT;
+ int server_port = DEFAULT_ADB_PORT;
server_port_str = server_port_str ? server_port_str : getenv("ANDROID_ADB_SERVER_PORT");
+ if (server_port_str && strlen(server_port_str) > 0) {
+ if (!android::base::ParseInt(server_port_str, &server_port, 1, 65535)) {
+ fprintf(stderr,
+ "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive"
+ " number less than 65535. Got \"%s\"\n",
+ server_port_str);
+ exit(1);
+ }
+ }
int rc;
char* temp;
if (server_host_str) {
- rc = asprintf(&temp, "tcp:%s:%ld", server_host_str, server_port);
+ rc = asprintf(&temp, "tcp:%s:%d", server_host_str, server_port);
} else {
- rc = asprintf(&temp, "tcp:%ld", server_port);
+ rc = asprintf(&temp, "tcp:%d", server_port);
}
if (rc < 0) {
fatal("failed to allocate server socket specification");
diff --git a/adb/shell_service.cpp b/adb/shell_service.cpp
index 01e206a..b0b31f1 100644
--- a/adb/shell_service.cpp
+++ b/adb/shell_service.cpp
@@ -493,10 +493,10 @@
// We also need to close the pipes connected to the child process
// so that if it ignores SIGHUP and continues to write data it
// won't fill up the pipe and block.
- stdinout_sfd_.clear();
- stderr_sfd_.clear();
+ stdinout_sfd_.reset();
+ stderr_sfd_.reset();
}
- dead_sfd->clear();
+ dead_sfd->reset();
}
}
}
diff --git a/adb/socket_spec.cpp b/adb/socket_spec.cpp
index 18e6e6d..14eb16b 100644
--- a/adb/socket_spec.cpp
+++ b/adb/socket_spec.cpp
@@ -20,6 +20,8 @@
#include <unordered_map>
#include <vector>
+#include <android-base/parseint.h>
+#include <android-base/parsenetaddress.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <cutils/sockets.h>
@@ -62,55 +64,47 @@
{ "localfilesystem", { ANDROID_SOCKET_NAMESPACE_FILESYSTEM, !ADB_WINDOWS } },
});
-static bool parse_tcp_spec(const std::string& spec, std::string* hostname, int* port,
+bool parse_tcp_socket_spec(const std::string& spec, std::string* hostname, int* port,
std::string* error) {
- std::vector<std::string> fragments = android::base::Split(spec, ":");
- if (fragments.size() == 1 || fragments.size() > 3) {
- *error = StringPrintf("invalid tcp specification: '%s'", spec.c_str());
- return false;
- }
-
- if (fragments[0] != "tcp") {
+ if (!StartsWith(spec, "tcp:")) {
*error = StringPrintf("specification is not tcp: '%s'", spec.c_str());
return false;
}
- // strtol accepts leading whitespace.
- const std::string& port_str = fragments.back();
- if (port_str.empty() || port_str[0] < '0' || port_str[0] > '9') {
- *error = StringPrintf("invalid port '%s'", port_str.c_str());
- return false;
- }
+ std::string hostname_value;
+ int port_value;
- char* parsed_end;
- long parsed_port = strtol(port_str.c_str(), &parsed_end, 10);
- if (*parsed_end != '\0') {
- *error = StringPrintf("trailing chars in port: '%s'", port_str.c_str());
- return false;
- }
- if (parsed_port > 65535) {
- *error = StringPrintf("invalid port %ld", parsed_port);
- return false;
- }
-
- // tcp:123 is valid, tcp::123 isn't.
- if (fragments.size() == 2) {
- // Empty hostname.
- if (hostname) {
- *hostname = "";
- }
- } else {
- if (fragments[1].empty()) {
- *error = StringPrintf("empty host in '%s'", spec.c_str());
+ // If the spec is tcp:<port>, parse it ourselves.
+ // Otherwise, delegate to android::base::ParseNetAddress.
+ if (android::base::ParseInt(&spec[4], &port_value)) {
+ // Do the range checking ourselves, because ParseInt rejects 'tcp:65536' and 'tcp:foo:1234'
+ // identically.
+ if (port_value < 0 || port_value > 65535) {
+ *error = StringPrintf("bad port number '%d'", port_value);
return false;
}
- if (hostname) {
- *hostname = fragments[1];
+ } else {
+ std::string addr = spec.substr(4);
+ port_value = -1;
+
+ // FIXME: ParseNetAddress rejects port 0. This currently doesn't hurt, because listening
+ // on an address that isn't 'localhost' is unsupported.
+ if (!android::base::ParseNetAddress(addr, &hostname_value, &port_value, nullptr, error)) {
+ return false;
}
+
+ if (port_value == -1) {
+ *error = StringPrintf("missing port in specification: '%s'", spec.c_str());
+ return false;
+ }
+ }
+
+ if (hostname) {
+ *hostname = std::move(hostname_value);
}
if (port) {
- *port = parsed_port;
+ *port = port_value;
}
return true;
@@ -141,7 +135,7 @@
std::string error;
std::string hostname;
- if (!parse_tcp_spec(spec, &hostname, nullptr, &error)) {
+ if (!parse_tcp_socket_spec(spec, &hostname, nullptr, &error)) {
return false;
}
return tcp_host_is_local(hostname);
@@ -151,7 +145,7 @@
if (StartsWith(spec, "tcp:")) {
std::string hostname;
int port;
- if (!parse_tcp_spec(spec, &hostname, &port, error)) {
+ if (!parse_tcp_socket_spec(spec, &hostname, &port, error)) {
return -1;
}
@@ -196,7 +190,7 @@
if (StartsWith(spec, "tcp:")) {
std::string hostname;
int port;
- if (!parse_tcp_spec(spec, &hostname, &port, error)) {
+ if (!parse_tcp_socket_spec(spec, &hostname, &port, error)) {
return -1;
}
diff --git a/adb/socket_spec.h b/adb/socket_spec.h
index 6302da5..6920e91 100644
--- a/adb/socket_spec.h
+++ b/adb/socket_spec.h
@@ -25,3 +25,7 @@
int socket_spec_connect(const std::string& spec, std::string* error);
int socket_spec_listen(const std::string& spec, std::string* error,
int* resolved_tcp_port = nullptr);
+
+// Exposed for testing.
+bool parse_tcp_socket_spec(const std::string& spec, std::string* hostname, int* port,
+ std::string* error);
diff --git a/adb/socket_spec_test.cpp b/adb/socket_spec_test.cpp
new file mode 100644
index 0000000..40ce21c
--- /dev/null
+++ b/adb/socket_spec_test.cpp
@@ -0,0 +1,54 @@
+/*
+ * 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 "socket_spec.h"
+
+#include <string>
+
+#include <gtest/gtest.h>
+
+TEST(socket_spec, parse_tcp_socket_spec) {
+ std::string hostname, error;
+ int port;
+ EXPECT_TRUE(parse_tcp_socket_spec("tcp:5037", &hostname, &port, &error));
+ EXPECT_EQ("", hostname);
+ EXPECT_EQ(5037, port);
+
+ // Bad ports:
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:-1", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:65536", &hostname, &port, &error));
+
+ EXPECT_TRUE(parse_tcp_socket_spec("tcp:localhost:1234", &hostname, &port, &error));
+ EXPECT_EQ("localhost", hostname);
+ EXPECT_EQ(1234, port);
+
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:-1", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:65536", &hostname, &port, &error));
+
+ // IPv6:
+ EXPECT_TRUE(parse_tcp_socket_spec("tcp:[::1]:1234", &hostname, &port, &error));
+ EXPECT_EQ("::1", hostname);
+ EXPECT_EQ(1234, port);
+
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:-1", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1", &hostname, &port, &error));
+ EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1:1234", &hostname, &port, &error));
+}
diff --git a/adb/sockets.cpp b/adb/sockets.cpp
index 4ed1c45..abba745 100644
--- a/adb/sockets.cpp
+++ b/adb/sockets.cpp
@@ -36,7 +36,6 @@
#include "adb.h"
#include "adb_io.h"
-#include "sysdeps/mutex.h"
#include "transport.h"
static std::recursive_mutex& local_socket_list_lock = *new std::recursive_mutex();
diff --git a/adb/sysdeps/condition_variable.h b/adb/sysdeps/condition_variable.h
deleted file mode 100644
index 117cd40..0000000
--- a/adb/sysdeps/condition_variable.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <condition_variable>
-
-#include "sysdeps/mutex.h"
-
-#if defined(_WIN32)
-
-#include <windows.h>
-
-#include <android-base/macros.h>
-
-// The prebuilt version of mingw we use doesn't support condition_variable.
-// Therefore, implement our own using the Windows primitives.
-// Put them directly into the std namespace, so that when they're actually available, the build
-// breaks until they're removed.
-
-namespace std {
-
-class condition_variable {
- public:
- condition_variable() {
- InitializeConditionVariable(&cond_);
- }
-
- void wait(std::unique_lock<std::mutex>& lock) {
- std::mutex *m = lock.mutex();
- m->lock_count_--;
- SleepConditionVariableCS(&cond_, m->native_handle(), INFINITE);
- m->lock_count_++;
- }
-
- void notify_one() {
- WakeConditionVariable(&cond_);
- }
-
- private:
- CONDITION_VARIABLE cond_;
-
- DISALLOW_COPY_AND_ASSIGN(condition_variable);
-};
-
-}
-
-#endif // defined(_WIN32)
diff --git a/adb/sysdeps/mutex.h b/adb/sysdeps/mutex.h
deleted file mode 100644
index 226f7f1..0000000
--- a/adb/sysdeps/mutex.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-#if defined(_WIN32)
-
-#include <windows.h>
-
-#include <android-base/macros.h>
-
-#include "adb.h"
-
-// The prebuilt version of mingw we use doesn't support mutex or recursive_mutex.
-// Therefore, implement our own using the Windows primitives.
-// Put them directly into the std namespace, so that when they're actually available, the build
-// breaks until they're removed.
-
-#include <mutex>
-namespace std {
-
-// CRITICAL_SECTION is recursive, so just wrap it in a Mutex-compatible class.
-class recursive_mutex {
- public:
- typedef CRITICAL_SECTION* native_handle_type;
-
- recursive_mutex() {
- InitializeCriticalSection(&cs_);
- }
-
- ~recursive_mutex() {
- DeleteCriticalSection(&cs_);
- }
-
- void lock() {
- EnterCriticalSection(&cs_);
- }
-
- bool try_lock() {
- return TryEnterCriticalSection(&cs_);
- }
-
- void unlock() {
- LeaveCriticalSection(&cs_);
- }
-
- native_handle_type native_handle() {
- return &cs_;
- }
-
- private:
- CRITICAL_SECTION cs_;
-
- DISALLOW_COPY_AND_ASSIGN(recursive_mutex);
-};
-
-class mutex {
- public:
- typedef CRITICAL_SECTION* native_handle_type;
-
- mutex() {
- }
-
- ~mutex() {
- }
-
- void lock() {
- mutex_.lock();
- if (++lock_count_ != 1) {
- fatal("non-recursive mutex locked reentrantly");
- }
- }
-
- void unlock() {
- if (--lock_count_ != 0) {
- fatal("non-recursive mutex unlock resulted in unexpected lock count: %d", lock_count_);
- }
- mutex_.unlock();
- }
-
- bool try_lock() {
- if (!mutex_.try_lock()) {
- return false;
- }
-
- if (lock_count_ != 0) {
- mutex_.unlock();
- return false;
- }
-
- ++lock_count_;
- return true;
- }
-
- native_handle_type native_handle() {
- return mutex_.native_handle();
- }
-
- private:
- recursive_mutex mutex_;
- size_t lock_count_ = 0;
-
- friend class condition_variable;
-};
-
-}
-
-#endif // defined(_WIN32)
diff --git a/adb/sysdeps_test.cpp b/adb/sysdeps_test.cpp
index 740f283..f871675 100644
--- a/adb/sysdeps_test.cpp
+++ b/adb/sysdeps_test.cpp
@@ -17,11 +17,10 @@
#include <gtest/gtest.h>
#include <unistd.h>
#include <atomic>
+#include <condition_variable>
#include "adb_io.h"
#include "sysdeps.h"
-#include "sysdeps/condition_variable.h"
-#include "sysdeps/mutex.h"
static void increment_atomic_int(void* c) {
sleep(1);
diff --git a/adb/transport_local.cpp b/adb/transport_local.cpp
index 395b893..89e950d 100644
--- a/adb/transport_local.cpp
+++ b/adb/transport_local.cpp
@@ -17,8 +17,6 @@
#define TRACE_TAG TRANSPORT
#include "sysdeps.h"
-#include "sysdeps/condition_variable.h"
-#include "sysdeps/mutex.h"
#include "transport.h"
#include <errno.h>
@@ -27,6 +25,7 @@
#include <string.h>
#include <sys/types.h>
+#include <condition_variable>
#include <vector>
#include <android-base/stringprintf.h>
diff --git a/base/include/android-base/mutex.h b/base/include/android-base/mutex.h
deleted file mode 100644
index 22e75c7..0000000
--- a/base/include/android-base/mutex.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <mutex>
-
-#include "android-base/macros.h"
-
-#if defined(_WIN32)
-#include <windows.h>
-
-namespace std {
-class mutex {
- public:
- mutex() {
- InitializeCriticalSection(&critical_section_);
- }
- ~mutex() {
- DeleteCriticalSection(&critical_section_);
- }
-
- void lock() {
- EnterCriticalSection(&critical_section_);
- }
-
- void unlock() {
- LeaveCriticalSection(&critical_section_);
- }
-
- private:
- CRITICAL_SECTION critical_section_;
- DISALLOW_COPY_AND_ASSIGN(mutex);
-};
-} // namespace std
-#endif
diff --git a/base/include/android-base/unique_fd.h b/base/include/android-base/unique_fd.h
index c323311..6cfcfcd 100644
--- a/base/include/android-base/unique_fd.h
+++ b/base/include/android-base/unique_fd.h
@@ -55,7 +55,7 @@
unique_fd_impl() : value_(-1) {}
explicit unique_fd_impl(int value) : value_(value) {}
- ~unique_fd_impl() { clear(); }
+ ~unique_fd_impl() { reset(); }
unique_fd_impl(unique_fd_impl&& other) : value_(other.release()) {}
unique_fd_impl& operator=(unique_fd_impl&& s) {
@@ -63,17 +63,13 @@
return *this;
}
- void reset(int new_value) {
+ void reset(int new_value = -1) {
if (value_ != -1) {
Closer::Close(value_);
}
value_ = new_value;
}
- void clear() {
- reset(-1);
- }
-
int get() const { return value_; }
operator int() const { return get(); }
diff --git a/base/logging.cpp b/base/logging.cpp
index 33313e4..77a0a43 100644
--- a/base/logging.cpp
+++ b/base/logging.cpp
@@ -44,7 +44,6 @@
#include <vector>
#include "android-base/macros.h"
-#include "android-base/mutex.h"
#include "android-base/strings.h"
// Headers for LogMessage::LogLine.
diff --git a/base/quick_exit.cpp b/base/quick_exit.cpp
index fa67122..e4dd62b 100644
--- a/base/quick_exit.cpp
+++ b/base/quick_exit.cpp
@@ -21,8 +21,6 @@
#include <mutex>
#include <vector>
-#include "android-base/mutex.h"
-
namespace android {
namespace base {
diff --git a/debuggerd/debuggerd.cpp b/debuggerd/debuggerd.cpp
index 8834209..77c138f 100644
--- a/debuggerd/debuggerd.cpp
+++ b/debuggerd/debuggerd.cpp
@@ -835,18 +835,19 @@
}
static int do_explicit_dump(pid_t tid, bool dump_backtrace) {
- fprintf(stdout, "Sending request to dump task %d.\n", tid);
+ fprintf(stdout, "Sending request to dump task %d...\n", tid);
+ fflush(stdout);
+ // TODO: we could have better error reporting if debuggerd sent an error string back.
if (dump_backtrace) {
- fflush(stdout);
if (dump_backtrace_to_file(tid, fileno(stdout)) < 0) {
- fputs("Error dumping backtrace.\n", stderr);
+ fputs("Error dumping backtrace (check logcat).\n", stderr);
return 1;
}
} else {
char tombstone_path[PATH_MAX];
if (dump_tombstone(tid, tombstone_path, sizeof(tombstone_path)) < 0) {
- fputs("Error dumping tombstone.\n", stderr);
+ fputs("Error dumping tombstone (check logcat).\n", stderr);
return 1;
}
fprintf(stderr, "Tombstone written to: %s\n", tombstone_path);
@@ -854,12 +855,14 @@
return 0;
}
-static void usage() {
- fputs("Usage: -b [<tid>]\n"
- " -b dump backtrace to console, otherwise dump full tombstone file\n"
+static int usage() {
+ fputs("usage: debuggerd [-b] [<tid>]\n"
"\n"
- "If tid specified, sends a request to debuggerd to dump that task.\n"
- "Otherwise, starts the debuggerd server.\n", stderr);
+ "Given a thread id, sends a request to debuggerd to dump that thread.\n"
+ "Otherwise, starts the debuggerd server.\n"
+ "\n"
+ "-b\tdump backtrace to console, otherwise generate tombstone\n", stderr);
+ return EXIT_FAILURE;
}
int main(int argc, char** argv) {
@@ -873,22 +876,15 @@
}
bool dump_backtrace = false;
- bool have_tid = false;
pid_t tid = 0;
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-b")) {
dump_backtrace = true;
- } else if (!have_tid) {
- tid = atoi(argv[i]);
- have_tid = true;
- } else {
- usage();
- return 1;
+ } else if (tid != 0 || (tid = atoi(argv[i])) == 0) {
+ // Only one tid is allowed. (And 0 isn't a valid tid.)
+ // atoi(3) returns 0 on failure to parse, so this catches anything else too.
+ return usage();
}
}
- if (!have_tid) {
- usage();
- return 1;
- }
- return do_explicit_dump(tid, dump_backtrace);
+ return (tid != 0) ? do_explicit_dump(tid, dump_backtrace) : usage();
}
diff --git a/include/cutils/atomic.h b/include/cutils/atomic.h
index ded972a..0c88bfe 100644
--- a/include/cutils/atomic.h
+++ b/include/cutils/atomic.h
@@ -71,6 +71,15 @@
* If they are not, atomicity is not guaranteed.
*/
+ANDROID_ATOMIC_INLINE
+volatile atomic_int_least32_t* to_atomic_int_least32_t(volatile const int32_t* addr) {
+#ifdef __cplusplus
+ return reinterpret_cast<volatile atomic_int_least32_t*>(const_cast<volatile int32_t*>(addr));
+#else
+ return (volatile atomic_int_least32_t*)addr;
+#endif
+}
+
/*
* Basic arithmetic and bitwise operations. These all provide a
* barrier with "release" ordering, and return the previous value.
@@ -81,7 +90,7 @@
ANDROID_ATOMIC_INLINE
int32_t android_atomic_inc(volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
/* Int32_t, if it exists, is the same as int_least32_t. */
return atomic_fetch_add_explicit(a, 1, memory_order_release);
}
@@ -89,28 +98,28 @@
ANDROID_ATOMIC_INLINE
int32_t android_atomic_dec(volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
return atomic_fetch_sub_explicit(a, 1, memory_order_release);
}
ANDROID_ATOMIC_INLINE
int32_t android_atomic_add(int32_t value, volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
return atomic_fetch_add_explicit(a, value, memory_order_release);
}
ANDROID_ATOMIC_INLINE
int32_t android_atomic_and(int32_t value, volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
return atomic_fetch_and_explicit(a, value, memory_order_release);
}
ANDROID_ATOMIC_INLINE
int32_t android_atomic_or(int32_t value, volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
return atomic_fetch_or_explicit(a, value, memory_order_release);
}
@@ -131,14 +140,14 @@
ANDROID_ATOMIC_INLINE
int32_t android_atomic_acquire_load(volatile const int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
return atomic_load_explicit(a, memory_order_acquire);
}
ANDROID_ATOMIC_INLINE
int32_t android_atomic_release_load(volatile const int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
atomic_thread_fence(memory_order_seq_cst);
/* Any reasonable clients of this interface would probably prefer */
/* something weaker. But some remaining clients seem to be */
@@ -162,7 +171,7 @@
ANDROID_ATOMIC_INLINE
void android_atomic_acquire_store(int32_t value, volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
atomic_store_explicit(a, value, memory_order_relaxed);
atomic_thread_fence(memory_order_seq_cst);
/* Again overly conservative to accomodate weird clients. */
@@ -171,7 +180,7 @@
ANDROID_ATOMIC_INLINE
void android_atomic_release_store(int32_t value, volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
atomic_store_explicit(a, value, memory_order_release);
}
@@ -191,22 +200,22 @@
int android_atomic_acquire_cas(int32_t oldvalue, int32_t newvalue,
volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
- return (int)(!atomic_compare_exchange_strong_explicit(
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
+ return !atomic_compare_exchange_strong_explicit(
a, &oldvalue, newvalue,
memory_order_acquire,
- memory_order_acquire));
+ memory_order_acquire);
}
ANDROID_ATOMIC_INLINE
int android_atomic_release_cas(int32_t oldvalue, int32_t newvalue,
volatile int32_t* addr)
{
- volatile atomic_int_least32_t* a = (volatile atomic_int_least32_t*)addr;
- return (int)(!atomic_compare_exchange_strong_explicit(
+ volatile atomic_int_least32_t* a = to_atomic_int_least32_t(addr);
+ return !atomic_compare_exchange_strong_explicit(
a, &oldvalue, newvalue,
memory_order_release,
- memory_order_relaxed));
+ memory_order_relaxed);
}
/*
diff --git a/include/ziparchive/zip_archive.h b/include/ziparchive/zip_archive.h
index 7dc60ae..4f68c3b 100644
--- a/include/ziparchive/zip_archive.h
+++ b/include/ziparchive/zip_archive.h
@@ -43,8 +43,7 @@
/*
* entry_name has to be an c-style string with only ASCII characters.
*/
- explicit ZipString(const char* entry_name)
- : name(reinterpret_cast<const uint8_t*>(entry_name)), name_length(strlen(entry_name)) {}
+ explicit ZipString(const char* entry_name);
bool operator==(const ZipString& rhs) const {
return name && (name_length == rhs.name_length) &&
diff --git a/libusbhost/Android.mk b/libusbhost/Android.mk
index 5c12f2c..9439846 100644
--- a/libusbhost/Android.mk
+++ b/libusbhost/Android.mk
@@ -22,11 +22,11 @@
ifeq ($(HOST_OS),linux)
include $(CLEAR_VARS)
-
LOCAL_MODULE := libusbhost
LOCAL_SRC_FILES := usbhost.c
LOCAL_CFLAGS := -Werror
-
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
include $(BUILD_HOST_STATIC_LIBRARY)
endif
@@ -35,24 +35,22 @@
# ========================================================
include $(CLEAR_VARS)
-
LOCAL_MODULE := libusbhost
LOCAL_SRC_FILES := usbhost.c
-
LOCAL_CFLAGS := -g -DUSE_LIBLOG -Werror
-
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
# needed for logcat
LOCAL_SHARED_LIBRARIES := libcutils
-
include $(BUILD_SHARED_LIBRARY)
# Static library for target
# ========================================================
include $(CLEAR_VARS)
-
LOCAL_MODULE := libusbhost
LOCAL_SRC_FILES := usbhost.c
LOCAL_CFLAGS := -Werror
-
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
include $(BUILD_STATIC_LIBRARY)
diff --git a/include/usbhost/usbhost.h b/libusbhost/include/usbhost/usbhost.h
similarity index 99%
rename from include/usbhost/usbhost.h
rename to libusbhost/include/usbhost/usbhost.h
index 88b5b44..84594c8 100644
--- a/include/usbhost/usbhost.h
+++ b/libusbhost/include/usbhost/usbhost.h
@@ -216,7 +216,7 @@
int usb_device_bulk_transfer(struct usb_device *device,
int endpoint,
void* buffer,
- int length,
+ unsigned int length,
unsigned int timeout);
/** Reset USB bus for the device */
diff --git a/libusbhost/usbhost.c b/libusbhost/usbhost.c
index 299fdc4..68aca17 100644
--- a/libusbhost/usbhost.c
+++ b/libusbhost/usbhost.c
@@ -600,7 +600,7 @@
int usb_device_bulk_transfer(struct usb_device *device,
int endpoint,
void* buffer,
- int length,
+ unsigned int length,
unsigned int timeout)
{
struct usbdevfs_bulktransfer ctrl;
diff --git a/libziparchive/zip_archive.cc b/libziparchive/zip_archive.cc
index 350be31..4649a75 100644
--- a/libziparchive/zip_archive.cc
+++ b/libziparchive/zip_archive.cc
@@ -31,6 +31,7 @@
#include <vector>
#include "android-base/file.h"
+#include "android-base/logging.h"
#include "android-base/macros.h" // TEMP_FAILURE_RETRY may or may not be in unistd
#include "android-base/memory.h"
#include "log/log.h"
@@ -1073,3 +1074,10 @@
int GetFileDescriptor(const ZipArchiveHandle handle) {
return reinterpret_cast<ZipArchive*>(handle)->fd;
}
+
+ZipString::ZipString(const char* entry_name)
+ : name(reinterpret_cast<const uint8_t*>(entry_name)) {
+ size_t len = strlen(entry_name);
+ CHECK_LE(len, static_cast<size_t>(UINT16_MAX));
+ name_length = static_cast<uint16_t>(len);
+}
diff --git a/libziparchive/zip_writer.cc b/libziparchive/zip_writer.cc
index 1ebed30..b72ed7f 100644
--- a/libziparchive/zip_writer.cc
+++ b/libziparchive/zip_writer.cc
@@ -243,8 +243,12 @@
// Initialize the z_stream for compression.
z_stream_ = std::unique_ptr<z_stream, void(*)(z_stream*)>(new z_stream(), DeleteZStream);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
int zerr = deflateInit2(z_stream_.get(), Z_BEST_COMPRESSION, Z_DEFLATED, -MAX_WBITS,
DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+#pragma GCC diagnostic pop
+
if (zerr != Z_OK) {
if (zerr == Z_VERSION_ERROR) {
ALOGE("Installed zlib is not compatible with linked version (%s)", ZLIB_VERSION);
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 43822f3..1a601f0 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -359,7 +359,8 @@
# Fix the access permissions and group ownership for 'bt_config.conf'
chmod 0660 /data/misc/bluedroid/bt_config.conf
chown bluetooth net_bt_stack /data/misc/bluedroid/bt_config.conf
- mkdir /data/misc/bluetooth 0770 system system
+ mkdir /data/misc/bluetooth 0770 bluetooth net_bt_stack
+ mkdir /data/misc/bluetooth/logs 0770 bluetooth net_bt_stack
mkdir /data/misc/keystore 0700 keystore keystore
mkdir /data/misc/gatekeeper 0700 system system
mkdir /data/misc/keychain 0771 system system