Commit: 71b34a03e4a6d7be4a246d9e3e5fa5bd61128b38 - system-core (git)

system/core

Commit MetaInfo

• Révision: 71b34a03e4a6d7be4a246d9e3e5fa5bd61128b38 (tree)
• l'heure: 2016-07-20 18:02:24
• Auteur: Chih-Wei Huang <cwhuang@linu...>
• Commiter: Chih-Wei Huang

Message de Log

Merge branch 'android-ia' into marshmallow-x86

Change Summary

• modified: adb/adb.h
• modified: adb/commandline.cpp
• modified: adb/fdevent.cpp
• modified: adb/mutex_list.h
• modified: adb/services.cpp
• modified: adb/sockets.cpp
• modified: adb/sysdeps_win32.cpp
• modified: adb/transport.cpp
• modified: adb/transport_usb.cpp
• modified: fs_mgr/fs_mgr.c
• modified: fs_mgr/fs_mgr_format.c
• modified: fs_mgr/include/fs_mgr.h
• modified: healthd/BatteryMonitor.cpp
• modified: healthd/healthd_mode_charger.cpp
• modified: include/ziparchive/zip_archive.h
• modified: init/init.cpp
• modified: init/property_service.cpp
• modified: init/property_service.h
• modified: libnativebridge/Android.mk
• modified: libnativebridge/native_bridge.cc
• modified: libnativebridge/tests/Android.mk
• add: libnativebridge/tests/CodeCacheStatFail_test.cpp
• modified: libnativebridge/tests/NativeBridgeTest.h
• modified: libziparchive/Android.mk
• modified: libziparchive/zip_archive.cc

Modification

--- a/adb/adb.h
+++ b/adb/adb.h
@@ -85,6 +85,13 @@ struct asocket {
         ** but packets are still queued for delivery
         */
     int    closing;
+        /* flag: set when this socket is running.
+        */
+    int    running;
+        /* flag: force close this socket. if this socket is running, other
+        ** thread set this flag to request close it.
+        */
+    int    force_close;
 
         /* flag: quit adbd when both ends close the
         ** local service socket

--- a/adb/commandline.cpp
+++ b/adb/commandline.cpp
@@ -198,7 +198,10 @@ static void help() {
         "  adb version                  - show version num\n"
         "\n"
         "scripting:\n"
-        "  adb wait-for-device          - block until device is online\n"
+        "  adb wait-for-<transport>-<state>\n"
+        "                               - wait for device to be in the given state:\n"
+        "                                 device, recovery, sideload, or bootloader\n"
+        "                                 Transport is: usb, local or any\n"
         "  adb start-server             - ensure that there is a server running\n"
         "  adb kill-server              - kill the server if it is running\n"
         "  adb get-state                - prints: offline | bootloader | device\n"
@@ -674,19 +677,49 @@ static int ppp(int argc, const char** argv) {
 #endif /* !defined(_WIN32) */
 }
 
+static bool check_wait_for_device_syntax(const char* service) {
+    // TODO: when we have libc++ for Windows, use a regular expression instead.
+    // wait-for-((any|local|usb)-)?(bootloader|device|recovery|sideload)
+
+    char type[20];
+    char state[20];
+    int length = 0;
+    if (sscanf(service, "wait-for-%20[a-z]-%20[a-z]%n", type, state, &length) < 2 ||
+        length != static_cast<int>(strlen(service))) {
+        fprintf(stderr, "adb: couldn't parse 'wait-for' command: %s\n", service);
+        return false;
+    }
+
+    if (strcmp(type, "any") != 0 && strcmp(type, "local") != 0 && strcmp(type, "usb") != 0) {
+        fprintf(stderr, "adb: unknown type %s; expected 'any', 'local', or 'usb'\n", type);
+        return false;
+    }
+    if (strcmp(state, "bootloader") != 0 && strcmp(state, "device") != 0 &&
+        strcmp(state, "recovery") != 0 && strcmp(state, "sideload") != 0) {
+        fprintf(stderr, "adb: unknown state %s; "
+                        "expected 'bootloader', 'device', 'recovery', or 'sideload'\n", state);
+        return false;
+    }
+    return true;
+}
+
 static bool wait_for_device(const char* service, transport_type t, const char* serial) {
     // Was the caller vague about what they'd like us to wait for?
     // If so, check they weren't more specific in their choice of transport type.
     if (strcmp(service, "wait-for-device") == 0) {
         if (t == kTransportUsb) {
-            service = "wait-for-usb";
+            service = "wait-for-usb-device";
         } else if (t == kTransportLocal) {
-            service = "wait-for-local";
+            service = "wait-for-local-device";
         } else {
-            service = "wait-for-any";
+            service = "wait-for-any-device";
         }
     }
 
+    if (!check_wait_for_device_syntax(service)) {
+        return false;
+    }
+
     std::string cmd = format_host_command(service, t, serial);
     std::string error;
     if (adb_command(cmd, &error)) {

--- a/adb/fdevent.cpp
+++ b/adb/fdevent.cpp
@@ -44,6 +44,8 @@
 // of the shell's pseudo-tty master. I.e. force close it.
 int SHELL_EXIT_NOTIFY_FD = -1;
 
+ADB_MUTEX_DEFINE( fdevent_lock );
+
 static void fatal(const char *fn, const char *fmt, ...)
 {
     va_list ap;
@@ -210,6 +212,7 @@ static void fdevent_process()
         exit(1);
     }
 
+    adb_mutex_lock(&fdevent_lock);
     for(i = 0; i < n; i++) {
         struct epoll_event *ev = events + i;
         fde = ev->data.ptr;
@@ -229,6 +232,7 @@ static void fdevent_process()
             fdevent_plist_enqueue(fde);
         }
     }
+    adb_mutex_unlock(&fdevent_lock);
 }
 
 #else /* USE_SELECT */
@@ -364,13 +368,17 @@ static void fdevent_process()
     unsigned events;
     fd_set rfd, wfd, efd;
 
+    adb_mutex_lock(&fdevent_lock);
     memcpy(&rfd, &read_fds, sizeof(fd_set));
     memcpy(&wfd, &write_fds, sizeof(fd_set));
     memcpy(&efd, &error_fds, sizeof(fd_set));
 
     dump_all_fds("pre select()");
+    adb_mutex_unlock(&fdevent_lock);
 
     n = select(select_n, &rfd, &wfd, &efd, NULL);
+
+    adb_mutex_lock(&fdevent_lock);
     int saved_errno = errno;
     D("select() returned n=%d, errno=%d\n", n, n<0?saved_errno:0);
 
@@ -378,7 +386,7 @@ static void fdevent_process()
 
     if(n < 0) {
         switch(saved_errno) {
-        case EINTR: return;
+        case EINTR: goto unlock;
         case EBADF:
             // Can't trust the FD sets after an error.
             FD_ZERO(&wfd);
@@ -387,7 +395,7 @@ static void fdevent_process()
             break;
         default:
             D("Unexpected select() error=%d\n", saved_errno);
-            return;
+            goto unlock;
         }
     }
     if(n <= 0) {
@@ -405,7 +413,9 @@ static void fdevent_process()
         if(events) {
             fde = fd_table[i];
             if(fde == 0)
-              FATAL("missing fde for fd %d\n", i);
+              // run here because the fde was just removed
+              // after rutern from select.
+              continue;
 
             fde->events |= events;
 
@@ -416,6 +426,8 @@ static void fdevent_process()
             fdevent_plist_enqueue(fde);
         }
     }
+unlock:
+    adb_mutex_unlock(&fdevent_lock);
 }
 
 #endif
@@ -500,14 +512,16 @@ static fdevent *fdevent_plist_dequeue(void)
     return node;
 }
 
-static void fdevent_call_fdfunc(fdevent* fde)
+static void fdevent_call_fdfunc_locked(fdevent* fde)
 {
     unsigned events = fde->events;
     fde->events = 0;
     if(!(fde->state & FDE_PENDING)) return;
     fde->state &= (~FDE_PENDING);
     dump_fde(fde, "callback");
+    adb_mutex_unlock(&fdevent_lock);
     fde->func(fde->fd, events, fde->arg);
+    adb_mutex_lock(&fdevent_lock);
 }
 
 static void fdevent_subproc_event_func(int fd, unsigned ev,
@@ -523,6 +537,7 @@ static void fdevent_subproc_event_func(int fd, unsigned ev,
     fdevent *fde = fd_table[fd];
     fdevent_add(fde, FDE_READ);
 
+    adb_mutex_lock(&fdevent_lock);
     if(ev & FDE_READ){
       int subproc_fd;
 
@@ -532,17 +547,17 @@ static void fdevent_subproc_event_func(int fd, unsigned ev,
       if((subproc_fd < 0) || (subproc_fd >= fd_table_max)) {
           D("subproc_fd %d out of range 0, fd_table_max=%d\n",
             subproc_fd, fd_table_max);
-          return;
+          goto unlock;
       }
       fdevent *subproc_fde = fd_table[subproc_fd];
       if(!subproc_fde) {
           D("subproc_fd %d cleared from fd_table\n", subproc_fd);
-          return;
+          goto unlock;
       }
       if(subproc_fde->fd != subproc_fd) {
           // Already reallocated?
           D("subproc_fd %d != fd_table[].fd %d\n", subproc_fd, subproc_fde->fd);
-          return;
+          goto unlock;
       }
 
       subproc_fde->force_eof = 1;
@@ -556,17 +571,19 @@ static void fdevent_subproc_event_func(int fd, unsigned ev,
         // If there is data left, it will show up in the select().
         // This works because there is no other thread reading that
         // data when in this fd_func().
-        return;
+        goto unlock;
       }
 
       D("subproc_fde.state=%04x\n", subproc_fde->state);
       subproc_fde->events |= FDE_READ;
       if(subproc_fde->state & FDE_PENDING) {
-        return;
+        goto unlock;
       }
       subproc_fde->state |= FDE_PENDING;
-      fdevent_call_fdfunc(subproc_fde);
+      fdevent_call_fdfunc_locked(subproc_fde);
     }
+unlock:
+    adb_mutex_unlock(&fdevent_lock);
 }
 
 fdevent *fdevent_create(int fd, fd_func func, void *arg)
@@ -590,6 +607,7 @@ void fdevent_destroy(fdevent *fde)
 
 void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
 {
+    adb_mutex_lock(&fdevent_lock);
     memset(fde, 0, sizeof(fdevent));
     fde->state = FDE_ACTIVE;
     fde->fd = fd;
@@ -604,10 +622,12 @@ void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
     dump_fde(fde, "connect");
     fdevent_connect(fde);
     fde->state |= FDE_ACTIVE;
+    adb_mutex_unlock(&fdevent_lock);
 }
 
 void fdevent_remove(fdevent *fde)
 {
+    adb_mutex_lock(&fdevent_lock);
     if(fde->state & FDE_PENDING) {
         fdevent_plist_remove(fde);
     }
@@ -620,6 +640,7 @@ void fdevent_remove(fdevent *fde)
 
     fde->state = 0;
     fde->events = 0;
+    adb_mutex_unlock(&fdevent_lock);
 }
 
 
@@ -627,7 +648,11 @@ void fdevent_set(fdevent *fde, unsigned events)
 {
     events &= FDE_EVENTMASK;
 
-    if((fde->state & FDE_EVENTMASK) == events) return;
+    adb_mutex_lock(&fdevent_lock);
+    if((fde->state & FDE_EVENTMASK) == events) {
+        adb_mutex_unlock(&fdevent_lock);
+        return;
+    }
 
     if(fde->state & FDE_ACTIVE) {
         fdevent_update(fde, events);
@@ -647,6 +672,7 @@ void fdevent_set(fdevent *fde, unsigned events)
             fde->state &= (~FDE_PENDING);
         }
     }
+    adb_mutex_unlock(&fdevent_lock);
 }
 
 void fdevent_add(fdevent *fde, unsigned events)
@@ -688,8 +714,10 @@ void fdevent_loop()
 
         fdevent_process();
 
+        adb_mutex_lock(&fdevent_lock);
         while((fde = fdevent_plist_dequeue())) {
-            fdevent_call_fdfunc(fde);
+            fdevent_call_fdfunc_locked(fde);
         }
+        adb_mutex_unlock(&fdevent_lock);
     }
 }

--- a/adb/mutex_list.h
+++ b/adb/mutex_list.h
@@ -8,6 +8,7 @@
 #endif
 ADB_MUTEX(socket_list_lock)
 ADB_MUTEX(transport_lock)
+ADB_MUTEX(fdevent_lock)
 #if ADB_HOST
 ADB_MUTEX(local_transports_lock)
 #endif

--- a/adb/services.cpp
+++ b/adb/services.cpp
@@ -517,27 +517,55 @@ struct state_info {
     transport_type transport;
     char* serial;
     int state;
+    fdevent fde;
+    bool abort;
 };
 
+void wait_for_state_fd_func(int fd, unsigned ev, void *userdata)
+{
+    state_info* sinfo = reinterpret_cast<state_info*>(userdata);
+
+    if (ev & FDE_WRITE) {
+        /* don't care this event */
+        fdevent_del(&sinfo->fde, FDE_WRITE);
+    }
+
+    if (ev & (FDE_READ | FDE_ERROR)) {
+        D("client exited, stop waiting\n");
+        sinfo->abort = true;
+        fdevent_del(&sinfo->fde, FDE_READ | FDE_ERROR);
+    }
+}
+
 static void wait_for_state(int fd, void* cookie)
 {
     state_info* sinfo = reinterpret_cast<state_info*>(cookie);
+    atransport* t = NULL;
 
     D("wait_for_state %d\n", sinfo->state);
+    sinfo->abort = false;
+    fdevent_install(&sinfo->fde, fd, wait_for_state_fd_func, cookie);
+    fdevent_add(&sinfo->fde, FDE_READ | FDE_ERROR);
 
     std::string error_msg = "unknown error";
-    atransport* t = acquire_one_transport(sinfo->state, sinfo->transport, sinfo->serial, &error_msg);
+    while (!sinfo->abort) {
+        t = acquire_one_transport(sinfo->state, sinfo->transport, sinfo->serial, &error_msg);
+        if (t || (sinfo->state == CS_ANY))
+            break;
+        adb_sleep_ms(1000);
+    }
     if (t != 0) {
         SendOkay(fd);
     } else {
         SendFail(fd, error_msg);
     }
 
+    fdevent_remove(&sinfo->fde);
+
+    D("wait_for_state %s\n", sinfo->abort ? "aborted" : "done");
     if (sinfo->serial)
         free(sinfo->serial);
     free(sinfo);
-    adb_close(fd);
-    D("wait_for_state is done\n");
 }
 
 static void connect_device(const std::string& host, std::string* response) {
@@ -649,11 +677,13 @@ asocket*  host_service_to_socket(const char*  name, const char *serial)
 {
     if (!strcmp(name,"track-devices")) {
         return create_device_tracker();
-    } else if (!strncmp(name, "wait-for-", strlen("wait-for-"))) {
-        auto sinfo = reinterpret_cast<state_info*>(malloc(sizeof(state_info)));
+    } else if (android::base::StartsWith(name, "wait-for-")) {
+        name += strlen("wait-for-");
+
+        std::unique_ptr<state_info> sinfo(new state_info);
         if (sinfo == nullptr) {
             fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno));
-            return NULL;
+            return nullptr;
         }
 
         if (serial)
@@ -661,29 +691,38 @@ asocket*  host_service_to_socket(const char*  name, const char *serial)
         else
             sinfo->serial = NULL;
 
-        name += strlen("wait-for-");
-
-        if (!strncmp(name, "local", strlen("local"))) {
+        if (android::base::StartsWith(name, "local")) {
+            name += strlen("local");
             sinfo->transport = kTransportLocal;
-            sinfo->state = CS_DEVICE;
-        } else if (!strncmp(name, "usb", strlen("usb"))) {
+        } else if (android::base::StartsWith(name, "usb")) {
+            name += strlen("usb");
             sinfo->transport = kTransportUsb;
-            sinfo->state = CS_DEVICE;
-        } else if (!strncmp(name, "any", strlen("any"))) {
+        } else if (android::base::StartsWith(name, "any")) {
+            name += strlen("any");
             sinfo->transport = kTransportAny;
+        } else {
+            return nullptr;
+        }
+
+        if (!strcmp(name, "-device")) {
             sinfo->state = CS_DEVICE;
+        } else if (!strcmp(name, "-recovery")) {
+            sinfo->state = CS_RECOVERY;
+        } else if (!strcmp(name, "-sideload")) {
+            sinfo->state = CS_SIDELOAD;
+        } else if (!strcmp(name, "-bootloader")) {
+            sinfo->state = CS_BOOTLOADER;
         } else {
-            free(sinfo);
-            return NULL;
+            return nullptr;
         }
 
-        int fd = create_service_thread(wait_for_state, sinfo);
+        int fd = create_service_thread(wait_for_state, sinfo.release());
         return create_local_socket(fd);
     } else if (!strncmp(name, "connect:", 8)) {
         const char *host = name + 8;
         int fd = create_service_thread(connect_service, (void *)host);
         return create_local_socket(fd);
     }
-    return NULL;
+    return nullptr;
 }
 #endif /* ADB_HOST */

--- a/adb/sockets.cpp
+++ b/adb/sockets.cpp
@@ -53,16 +53,13 @@ static asocket local_socket_closing_list = {
     .prev = &local_socket_closing_list,
 };
 
-// Parse the global list of sockets to find one with id |local_id|.
-// If |peer_id| is not 0, also check that it is connected to a peer
-// with id |peer_id|. Returns an asocket handle on success, NULL on failure.
-asocket *find_local_socket(unsigned local_id, unsigned peer_id)
+static asocket *
+find_socket_in_list(asocket *list, unsigned local_id, unsigned peer_id)
 {
     asocket *s;
     asocket *result = NULL;
 
-    adb_mutex_lock(&socket_list_lock);
-    for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
+    for (s = list->next; s != list; s = s->next) {
         if (s->id != local_id)
             continue;
         if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) {
@@ -70,11 +67,24 @@ asocket *find_local_socket(unsigned local_id, unsigned peer_id)
         }
         break;
     }
-    adb_mutex_unlock(&socket_list_lock);
 
     return result;
 }
 
+
+// Parse the global list of sockets to find one with id |local_id|.
+// If |peer_id| is not 0, also check that it is connected to a peer
+// with id |peer_id|. Returns an asocket handle on success, NULL on failure.
+asocket *find_local_socket(unsigned local_id, unsigned peer_id)
+{
+    asocket *result = NULL;
+
+    adb_mutex_lock(&socket_list_lock);
+    result = find_socket_in_list(&local_socket_list, local_id, peer_id);
+    adb_mutex_unlock(&socket_list_lock);
+    return result;
+}
+
 static void
 insert_local_socket(asocket*  s, asocket*  list)
 {
@@ -113,10 +123,14 @@ void remove_socket(asocket *s)
     }
 }
 
+// Note: after return, all sockets refer to transport @t should be closed.
+// (Because the atransport is going to removed.)
+// force_close && running flag are to implement this.
 void close_all_sockets(atransport *t)
 {
     asocket *s;
 
+    D("close all sockets of transport %p\n", t);
         /* this is a little gross, but since s->close() *will* modify
         ** the list out from under you, your options are limited.
         */
@@ -124,7 +138,17 @@ void close_all_sockets(atransport *t)
 restart:
     for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
         if(s->transport == t || (s->peer && s->peer->transport == t)) {
-            local_socket_close_locked(s);
+            // set force_close flag since transport is going to be removed.
+            // we need ensure the socket is closed after we return.
+            s->force_close = 1;
+            // avoid race condition with pending fdevent
+            if (s->running) {
+                // unlock to give a chance to close socket after running
+                adb_mutex_unlock(&socket_list_lock);
+                adb_sleep_ms(10); // sleep to relax cpu
+                adb_mutex_lock(&socket_list_lock);
+            } else
+                local_socket_close_locked(s);
             goto restart;
         }
     }
@@ -193,8 +217,18 @@ static void local_socket_ready(asocket *s)
 
 static void local_socket_close(asocket *s)
 {
+    unsigned local_id = s->id;
+    unsigned peer_id = s->peer ? s->peer->id : 0;
+    asocket *sk;
+
     adb_mutex_lock(&socket_list_lock);
-    local_socket_close_locked(s);
+    // we may race with close_all_sockets (called by input-thread),
+    // so need to check if socket already destoried.
+    sk = find_socket_in_list(&local_socket_list, local_id, peer_id);
+    if (!sk)
+        sk = find_socket_in_list(&local_socket_closing_list, local_id, peer_id);
+    if (sk)
+        local_socket_close_locked(s);
     adb_mutex_unlock(&socket_list_lock);
 }
 
@@ -250,9 +284,10 @@ static void local_socket_close_locked(asocket *s)
     }
 
         /* If we are already closing, or if there are no
-        ** pending packets, destroy immediately
+        ** pending packets, or need force close it, then
+        ** destroy immediately.
         */
-    if (s->closing || s->pkt_first == NULL) {
+    if (s->closing || s->force_close || s->pkt_first == NULL) {
         int   id = s->id;
         local_socket_destroy(s);
         D("LS(%d): closed\n", id);
@@ -272,8 +307,12 @@ static void local_socket_close_locked(asocket *s)
 static void local_socket_event_func(int fd, unsigned ev, void* _s)
 {
     asocket* s = reinterpret_cast<asocket*>(_s);
+    s->running = 1;
     D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
 
+    if (s->force_close)
+        goto out;
+
     /* put the FDE_WRITE processing before the FDE_READ
     ** in order to simplify the code.
     */
@@ -287,7 +326,7 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s)
                     ** be processed in the next iteration loop
                     */
                     if (errno == EAGAIN) {
-                        return;
+                        goto out;
                     }
                 } else if (r > 0) {
                     p->ptr += r;
@@ -296,6 +335,7 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s)
                 }
 
                 D(" closing after write because r=%d and errno is %d\n", r, errno);
+                s->running = 0;
                 s->close(s);
                 return;
             }
@@ -314,6 +354,7 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s)
         */
         if (s->closing) {
             D(" closing because 'closing' is set after write\n");
+            s->running = 0;
             s->close(s);
             return;
         }
@@ -372,7 +413,7 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s)
                     ** this handler function will be called again
                     ** to process FDE_WRITE events.
                     */
-                return;
+                goto out;
             }
 
             if (r > 0) {
@@ -387,7 +428,9 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s)
         if ((s->fde.force_eof && !r) || is_eof) {
             D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n",
               is_eof, r, s->fde.force_eof);
+            s->running = 0;
             s->close(s);
+            return;
         }
     }
 
@@ -398,7 +441,13 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s)
             */
         D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
 
-        return;
+        goto out;
+    }
+out:
+    s->running = 0;
+    if (s->force_close) {
+        D("LS(%d): force closing (fd=%d)\n", s->id, s->fd);
+        s->close(s);
     }
 }
 
@@ -406,6 +455,7 @@ asocket *create_local_socket(int fd)
 {
     asocket *s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
     if (s == NULL) fatal("cannot allocate socket");
+    memset(s, 0, sizeof(asocket));
     s->fd = fd;
     s->enqueue = local_socket_enqueue;
     s->ready = local_socket_ready;
@@ -551,6 +601,7 @@ asocket *create_remote_socket(unsigned id, atransport *t)
     adisconnect* dis = &reinterpret_cast<aremotesocket*>(s)->disconnect;
 
     if (s == NULL) fatal("cannot allocate socket");
+    memset(s, 0, sizeof(asocket));
     s->id = id;
     s->enqueue = remote_socket_enqueue;
     s->ready = remote_socket_ready;
@@ -883,6 +934,7 @@ static asocket *create_smart_socket(void)
     D("Creating smart socket \n");
     asocket *s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
     if (s == NULL) fatal("cannot allocate socket");
+    memset(s, 0, sizeof(asocket));
     s->enqueue = smart_socket_enqueue;
     s->ready = smart_socket_ready;
     s->shutdown = NULL;

--- a/adb/sysdeps_win32.cpp
+++ b/adb/sysdeps_win32.cpp
@@ -27,6 +27,9 @@
 
 #include "adb.h"
 
+/* TODO: implemente fdevent synchronization for Windows platform. */
+ADB_MUTEX_DEFINE( fdevent_lock );
+
 extern void fatal(const char *fmt, ...);
 
 /* forward declarations */

--- a/adb/transport.cpp
+++ b/adb/transport.cpp
@@ -747,7 +747,6 @@ atransport* acquire_one_transport(int state, transport_type ttype,
     atransport *result = NULL;
     int ambiguous = 0;
 
-retry:
     if (error_out) *error_out = android::base::StringPrintf("device '%s' not found", serial);
 
     adb_mutex_lock(&transport_lock);
@@ -831,9 +830,6 @@ retry:
     if (result) {
         /* found one that we can take */
         if (error_out) *error_out = "success";
-    } else if (state != CS_ANY && (serial || !ambiguous)) {
-        adb_sleep_ms(1000);
-        goto retry;
     }
 
     return result;

--- a/adb/transport_usb.cpp
+++ b/adb/transport_usb.cpp
@@ -25,31 +25,51 @@
 
 #include "adb.h"
 
+#if !ADB_HOST
+#include <syslog.h>
+#endif
+
+#define MAX_CONSECUTIVE_USB_ISSUES	3
+
 static int remote_read(apacket *p, atransport *t)
 {
+    static int consecutives_errors_count = 0;
     if(usb_read(t->usb, &p->msg, sizeof(amessage))){
         D("remote usb: read terminated (message)\n");
-        return -1;
+        goto err;
     }
 
     if(check_header(p)) {
         D("remote usb: check_header failed\n");
-        return -1;
+        goto err;
     }
 
     if(p->msg.data_length) {
         if(usb_read(t->usb, p->data, p->msg.data_length)){
             D("remote usb: terminated (data)\n");
-            return -1;
+            goto err;
         }
     }
 
     if(check_data(p)) {
         D("remote usb: check_data failed\n");
-        return -1;
+        goto err;
     }
 
+    consecutives_errors_count = 0;
     return 0;
+err:
+    if (++consecutives_errors_count > MAX_CONSECUTIVE_USB_ISSUES) {
+#if !ADB_HOST
+        /* Make sure we log the exit on the target */
+        syslog(LOG_CRIT, "%s:%d - remote usb: too many consecutives usb errors(%d), exits the process\n", __FILE__, __LINE__,  consecutives_errors_count);
+#else
+        fatal("%s:%d - remote usb: too many consecutives usb errors(%d), exits the process\n", __FILE__, __LINE__,  consecutives_errors_count);
+#endif
+        /* no need to generate a coredump or generate a crash here, the pb is functionnal */
+        exit(-1);
+    }
+    return -1;
 }
 
 static int remote_write(apacket *p, atransport *t)

--- a/fs_mgr/fs_mgr.c
+++ b/fs_mgr/fs_mgr.c
@@ -577,6 +577,7 @@ int fs_mgr_mount_all(struct fstab *fstab)
 
         /* mount(2) returned an error, handle the encryptable/formattable case */
         bool wiped = partition_wiped(fstab->recs[top_idx].blk_device);
+        bool crypt_footer = false;
         if (mret && mount_errno != EBUSY && mount_errno != EACCES &&
             fs_mgr_is_formattable(&fstab->recs[top_idx]) && wiped) {
             /* top_idx and attempted_idx point at the same partition, but sometimes
@@ -597,8 +598,11 @@ int fs_mgr_mount_all(struct fstab *fstab)
                     ERROR("%s(): %s wouldn't open (%s)\n", __func__,
                           fstab->recs[top_idx].key_loc, strerror(errno));
                 }
+            } else if (fs_mgr_is_encryptable(&fstab->recs[top_idx]) &&
+                !strcmp(fstab->recs[top_idx].key_loc, KEY_IN_FOOTER)) {
+                crypt_footer = true;
             }
-            if (fs_mgr_do_format(&fstab->recs[top_idx]) == 0) {
+            if (fs_mgr_do_format(&fstab->recs[top_idx], crypt_footer) == 0) {
                 /* Let's replay the mount actions. */
                 i = top_idx - 1;
                 continue;

--- a/fs_mgr/fs_mgr_format.c
+++ b/fs_mgr/fs_mgr_format.c
@@ -27,11 +27,12 @@
 #include "ext4.h"
 #include "make_ext4fs.h"
 #include "fs_mgr_priv.h"
+#include "cryptfs.h"
 
 extern struct fs_info info;     /* magic global from ext4_utils */
 extern void reset_ext4fs_info();
 
-static int format_ext4(char *fs_blkdev, char *fs_mnt_point)
+static int format_ext4(char *fs_blkdev, char *fs_mnt_point, bool crypt_footer)
 {
     unsigned int nr_sec;
     int fd, rc = 0;
@@ -50,6 +51,9 @@ static int format_ext4(char *fs_blkdev, char *fs_mnt_point)
     /* Format the partition using the calculated length */
     reset_ext4fs_info();
     info.len = ((off64_t)nr_sec * 512);
+    if (crypt_footer) {
+        info.len -= CRYPT_FOOTER_OFFSET;
+    }
 
     /* Use make_ext4fs_internal to avoid wiping an already-wiped partition. */
     rc = make_ext4fs_internal(fd, NULL, NULL, fs_mnt_point, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
@@ -101,7 +105,7 @@ static int format_f2fs(char *fs_blkdev)
     return rc;
 }
 
-int fs_mgr_do_format(struct fstab_rec *fstab)
+int fs_mgr_do_format(struct fstab_rec *fstab, bool crypt_footer)
 {
     int rc = -EINVAL;
 
@@ -110,7 +114,7 @@ int fs_mgr_do_format(struct fstab_rec *fstab)
     if (!strncmp(fstab->fs_type, "f2fs", 4)) {
         rc = format_f2fs(fstab->blk_device);
     } else if (!strncmp(fstab->fs_type, "ext4", 4)) {
-        rc = format_ext4(fstab->blk_device, fstab->mount_point);
+        rc = format_ext4(fstab->blk_device, fstab->mount_point, crypt_footer);
     } else {
         ERROR("File system type '%s' is not supported\n", fstab->fs_type);
     }

--- a/fs_mgr/include/fs_mgr.h
+++ b/fs_mgr/include/fs_mgr.h
@@ -18,6 +18,7 @@
 #define __CORE_FS_MGR_H
 
 #include <stdint.h>
+#include <stdbool.h>
 #include <linux/dm-ioctl.h>
 
 // Magic number at start of verity metadata
@@ -107,7 +108,7 @@ int fs_mgr_is_notrim(struct fstab_rec *fstab);
 int fs_mgr_is_formattable(struct fstab_rec *fstab);
 int fs_mgr_swapon_all(struct fstab *fstab);
 
-int fs_mgr_do_format(struct fstab_rec *fstab);
+int fs_mgr_do_format(struct fstab_rec *fstab, bool reserve_footer);
 
 #ifdef __cplusplus
 }

--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -137,6 +137,7 @@ BatteryMonitor::PowerSupplyType BatteryMonitor::readPowerSupplyType(const String
             { "USB_DCP", ANDROID_POWER_SUPPLY_TYPE_AC },
             { "USB_CDP", ANDROID_POWER_SUPPLY_TYPE_AC },
             { "USB_ACA", ANDROID_POWER_SUPPLY_TYPE_AC },
+            { "USB_TYPEC", ANDROID_POWER_SUPPLY_TYPE_AC },
             { "Wireless", ANDROID_POWER_SUPPLY_TYPE_WIRELESS },
             { NULL, 0 },
     };

--- a/healthd/healthd_mode_charger.cpp
+++ b/healthd/healthd_mode_charger.cpp
@@ -570,9 +570,10 @@ static void handle_power_supply_state(struct charger *charger, int64_t now)
         /* Last cycle would have stopped at the extreme top of battery-icon
          * Need to show the correct level corresponding to capacity.
          */
-        kick_animation(charger->batt_anim);
         request_suspend(false);
         if (charger->next_pwr_check == -1) {
+            /* only kick animation once for charger unplug case. */
+            kick_animation(charger->batt_anim);
             charger->next_pwr_check = now + UNPLUGGED_SHUTDOWN_TIME;
             LOGW("[%" PRId64 "] device unplugged: shutting down in %" PRId64 " (@ %" PRId64 ")\n",
                  now, (int64_t)UNPLUGGED_SHUTDOWN_TIME, charger->next_pwr_check);

--- a/include/ziparchive/zip_archive.h
+++ b/include/ziparchive/zip_archive.h
@@ -165,6 +165,10 @@ int32_t StartIteration(ZipArchiveHandle handle, void** cookie_ptr,
  */
 int32_t Next(void* cookie, ZipEntry* data, ZipEntryName *name);
 
+#ifdef ZIP_NO_INTEGRITY
+int32_t NextNoIntegrity(void* cookie, ZipEntry* data, ZipEntryName *name);
+#endif
+
 /*
  * End iteration over all entries of a zip file and frees the memory allocated
  * in StartIteration.

--- a/init/init.cpp
+++ b/init/init.cpp
@@ -943,7 +943,16 @@ int selinux_reload_policy(void)
 }
 
 static int audit_callback(void *data, security_class_t /*cls*/, char *buf, size_t len) {
-    snprintf(buf, len, "property=%s", !data ? "NULL" : (char *)data);
+
+    property_audit_data *d = reinterpret_cast<property_audit_data*>(data);
+
+    if (!d || !d->name || !d->cr) {
+        ERROR("audit_callback invoked with null data arguments!");
+        return 0;
+    }
+
+    snprintf(buf, len, "property=%s pid=%d uid=%d gid=%d", d->name,
+            d->cr->pid, d->cr->uid, d->cr->gid);
     return 0;
 }
 

--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -90,13 +90,14 @@ void property_init() {
     }
 }
 
-static int check_mac_perms(const char *name, char *sctx)
+static int check_mac_perms(const char *name, char *sctx, struct ucred *cr)
 {
     if (is_selinux_enabled() <= 0)
         return 1;
 
     char *tctx = NULL;
     int result = 0;
+    property_audit_data audit_data;
 
     if (!sctx)
         goto err;
@@ -107,7 +108,10 @@ static int check_mac_perms(const char *name, char *sctx)
     if (selabel_lookup(sehandle_prop, &tctx, name, 1) != 0)
         goto err;
 
-    if (selinux_check_access(sctx, tctx, "property_service", "set", (void*) name) == 0)
+    audit_data.name = name;
+    audit_data.cr = cr;
+
+    if (selinux_check_access(sctx, tctx, "property_service", "set", reinterpret_cast<void*>(&audit_data)) == 0)
         result = 1;
 
     freecon(tctx);
@@ -115,7 +119,7 @@ static int check_mac_perms(const char *name, char *sctx)
     return result;
 }
 
-static int check_control_mac_perms(const char *name, char *sctx)
+static int check_control_mac_perms(const char *name, char *sctx, struct ucred *cr)
 {
     /*
      *  Create a name prefix out of ctl.<service name>
@@ -129,19 +133,19 @@ static int check_control_mac_perms(const char *name, char *sctx)
     if (ret < 0 || (size_t) ret >= sizeof(ctl_name))
         return 0;
 
-    return check_mac_perms(ctl_name, sctx);
+    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)
+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);
+    return check_mac_perms(name, sctx, cr);
 }
 
 int __property_get(const char *name, char *value)
@@ -323,14 +327,14 @@ static void handle_property_set_fd()
             // Keep the old close-socket-early behavior when handling
             // ctl.* properties.
             close(s);
-            if (check_control_mac_perms(msg.value, source_ctx)) {
+            if (check_control_mac_perms(msg.value, source_ctx, &cr)) {
                 handle_control_message((char*) msg.name + 4, (char*) msg.value);
             } else {
                 ERROR("sys_prop: Unable to %s service ctl [%s] uid:%d gid:%d pid:%d\n",
                         msg.name + 4, msg.value, cr.uid, cr.gid, cr.pid);
             }
         } else {
-            if (check_perms(msg.name, source_ctx)) {
+            if (check_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",

--- a/init/property_service.h
+++ b/init/property_service.h
@@ -18,8 +18,14 @@
 #define _INIT_PROPERTY_H
 
 #include <stddef.h>
+#include <sys/socket.h>
 #include <sys/system_properties.h>
 
+struct property_audit_data {
+    ucred *cr;
+    const char* name;
+};
+
 extern void property_init(void);
 extern void property_load_boot_defaults(void);
 extern int load_properties_from_file(const char *fn, const char *);

--- a/libnativebridge/Android.mk
+++ b/libnativebridge/Android.mk
@@ -14,6 +14,9 @@ LOCAL_SHARED_LIBRARIES := liblog
 LOCAL_CLANG := true
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_CFLAGS += -Werror -Wall
+ifeq ($(COMPATIBILITY_ENHANCEMENT_PACKAGE), true)
+    LOCAL_CFLAGS += -D_COMPATIBILITY_ENHANCEMENT_PACKAGE_
+endif
 LOCAL_CPPFLAGS := -std=gnu++11 -fvisibility=protected
 LOCAL_LDFLAGS := -ldl
 LOCAL_MULTILIB := both

--- a/libnativebridge/native_bridge.cc
+++ b/libnativebridge/native_bridge.cc
@@ -98,6 +98,10 @@ static constexpr const char* kCodeCacheDir = "code_cache";
 
 static constexpr uint32_t kLibNativeBridgeVersion = 2;
 
+#ifdef _COMPATIBILITY_ENHANCEMENT_PACKAGE_
+static bool null_instruction_set = false;
+#endif
+
 // Characters allowed in a native bridge filename. The first character must
 // be in [a-zA-Z] (expected 'l' for "libx"). The rest must be in [a-zA-Z0-9._-].
 static bool CharacterAllowed(char c, bool first) {
@@ -109,6 +113,13 @@ static bool CharacterAllowed(char c, bool first) {
   }
 }
 
+static void ReleaseAppCodeCacheDir() {
+  if (app_code_cache_dir != nullptr) {
+    delete[] app_code_cache_dir;
+    app_code_cache_dir = nullptr;
+  }
+}
+
 // We only allow simple names for the library. It is supposed to be a file in
 // /system/lib or /vendor/lib. Only allow a small range of characters, that is
 // names consisting of [a-zA-Z0-9._-] and starting with [a-zA-Z].
@@ -162,8 +173,7 @@ static bool VersionCheck(const NativeBridgeCallbacks* cb) {
 static void CloseNativeBridge(bool with_error) {
   state = NativeBridgeState::kClosed;
   had_error |= with_error;
-  delete[] app_code_cache_dir;
-  app_code_cache_dir = nullptr;
+  ReleaseAppCodeCacheDir();
 }
 
 bool LoadNativeBridge(const char* nb_library_filename,
@@ -238,8 +248,14 @@ static const char* kRuntimeISA = "unknown";
 
 bool NeedsNativeBridge(const char* instruction_set) {
   if (instruction_set == nullptr) {
+
+#ifdef _COMPATIBILITY_ENHANCEMENT_PACKAGE_
+    null_instruction_set = true;
+    return true;
+#else
     ALOGE("Null instruction set in NeedsNativeBridge.");
     return false;
+#endif
   }
   return strncmp(instruction_set, kRuntimeISA, strlen(kRuntimeISA) + 1) != 0;
 }
@@ -255,6 +271,15 @@ bool PreInitializeNativeBridge(const char* app_data_dir_in, const char* instruct
     return false;
   }
 
+#ifdef _COMPATIBILITY_ENHANCEMENT_PACKAGE_
+  if (app_data_dir_in != nullptr) {
+    // Create the path to the application code cache directory.
+    // The memory will be release after Initialization or when the native bridge is closed.
+    const size_t len = strlen(app_data_dir_in) + strlen(kCodeCacheDir) + 2; // '\0' + '/'
+    app_code_cache_dir = new char[len];
+    snprintf(app_code_cache_dir, len, "%s/%s", app_data_dir_in, kCodeCacheDir);
+  }
+#else
   if (app_data_dir_in == nullptr) {
     ALOGE("Application private directory cannot be null.");
     CloseNativeBridge(true);
@@ -266,13 +291,18 @@ bool PreInitializeNativeBridge(const char* app_data_dir_in, const char* instruct
   const size_t len = strlen(app_data_dir_in) + strlen(kCodeCacheDir) + 2; // '\0' + '/'
   app_code_cache_dir = new char[len];
   snprintf(app_code_cache_dir, len, "%s/%s", app_data_dir_in, kCodeCacheDir);
+#endif
 
   // Bind-mount /system/lib{,64}/<isa>/cpuinfo to /proc/cpuinfo.
   // Failure is not fatal and will keep the native bridge in kPreInitialized.
   state = NativeBridgeState::kPreInitialized;
 
 #ifndef __APPLE__
+#ifdef _COMPATIBILITY_ENHANCEMENT_PACKAGE_
+  if (null_instruction_set || instruction_set == nullptr || app_data_dir_in == nullptr) {
+#else
   if (instruction_set == nullptr) {
+#endif
     return true;
   }
   size_t isa_len = strlen(instruction_set);
@@ -401,31 +431,42 @@ bool InitializeNativeBridge(JNIEnv* env, const char* instruction_set) {
   // point we are not multi-threaded, so we do not need locking here.
 
   if (state == NativeBridgeState::kPreInitialized) {
+#ifdef _COMPATIBILITY_ENHANCEMENT_PACKAGE_
+    if (app_code_cache_dir != nullptr) {
+#endif
     // Check for code cache: if it doesn't exist try to create it.
     struct stat st;
     if (stat(app_code_cache_dir, &st) == -1) {
       if (errno == ENOENT) {
         if (mkdir(app_code_cache_dir, S_IRWXU | S_IRWXG | S_IXOTH) == -1) {
-          ALOGE("Cannot create code cache directory %s: %s.", app_code_cache_dir, strerror(errno));
-          CloseNativeBridge(true);
+          ALOGW("Cannot create code cache directory %s: %s.", app_code_cache_dir, strerror(errno));
+          ReleaseAppCodeCacheDir();
         }
       } else {
-        ALOGE("Cannot stat code cache directory %s: %s.", app_code_cache_dir, strerror(errno));
-        CloseNativeBridge(true);
+        ALOGW("Cannot stat code cache directory %s: %s.", app_code_cache_dir, strerror(errno));
+        ReleaseAppCodeCacheDir();
       }
     } else if (!S_ISDIR(st.st_mode)) {
-      ALOGE("Code cache is not a directory %s.", app_code_cache_dir);
-      CloseNativeBridge(true);
+      ALOGW("Code cache is not a directory %s.", app_code_cache_dir);
+      ReleaseAppCodeCacheDir();
     }
+#ifdef _COMPATIBILITY_ENHANCEMENT_PACKAGE_
+    }
+#endif
 
     // If we're still PreInitialized (dind't fail the code cache checks) try to initialize.
     if (state == NativeBridgeState::kPreInitialized) {
       if (callbacks->initialize(runtime_callbacks, app_code_cache_dir, instruction_set)) {
+#ifdef _COMPATIBILITY_ENHANCEMENT_PACKAGE_
+        if (!null_instruction_set) {
+          SetupEnvironment(callbacks, env, instruction_set);
+        }
+#else
         SetupEnvironment(callbacks, env, instruction_set);
+#endif
         state = NativeBridgeState::kInitialized;
         // We no longer need the code cache path, release the memory.
-        delete[] app_code_cache_dir;
-        app_code_cache_dir = nullptr;
+        ReleaseAppCodeCacheDir();
       } else {
         // Unload the library.
         dlclose(native_bridge_handle);

--- a/libnativebridge/tests/Android.mk
+++ b/libnativebridge/tests/Android.mk
@@ -9,6 +9,7 @@ include $(CLEAR_VARS)
 test_src_files := \
     CodeCacheCreate_test.cpp \
     CodeCacheExists_test.cpp \
+    CodeCacheStatFail_test.cpp \
     CompleteFlow_test.cpp \
     InvalidCharsNativeBridge_test.cpp \
     NativeBridge2Signal_test.cpp \

--- /dev/null
+++ b/libnativebridge/tests/CodeCacheStatFail_test.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2014 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 "NativeBridgeTest.h"
+
+#include <errno.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+namespace android {
+
+// Tests that the bridge is initialized without errors if the code_cache is
+// existed as a file.
+TEST_F(NativeBridgeTest, CodeCacheStatFail) {
+    int fd = creat(kCodeCache, O_RDWR);
+    ASSERT_NE(-1, fd);
+    close(fd);
+
+    struct stat st;
+    ASSERT_EQ(-1, stat(kCodeCacheStatFail, &st));
+    ASSERT_EQ(ENOTDIR, errno);
+
+    // Init
+    ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary, nullptr));
+    ASSERT_TRUE(PreInitializeNativeBridge(kCodeCacheStatFail, "isa"));
+    ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr));
+    ASSERT_TRUE(NativeBridgeAvailable());
+    ASSERT_FALSE(NativeBridgeError());
+
+    // Clean up
+    UnloadNativeBridge();
+
+    ASSERT_FALSE(NativeBridgeError());
+    unlink(kCodeCache);
+}
+
+}  // namespace android

--- a/libnativebridge/tests/NativeBridgeTest.h
+++ b/libnativebridge/tests/NativeBridgeTest.h
@@ -24,6 +24,7 @@
 
 constexpr const char* kNativeBridgeLibrary = "libnativebridge-dummy.so";
 constexpr const char* kCodeCache = "./code_cache";
+constexpr const char* kCodeCacheStatFail = "./code_cache/temp";
 
 namespace android {
 

--- a/libziparchive/Android.mk
+++ b/libziparchive/Android.mk
@@ -24,6 +24,9 @@ LOCAL_STATIC_LIBRARIES := libz
 LOCAL_SHARED_LIBRARIES := libutils libbase
 LOCAL_MODULE:= libziparchive
 LOCAL_CFLAGS := -Werror -Wall
+ifeq ($(ZIP_OPTIMIZATION_NO_INTEGRITY),true)
+    LOCAL_CFLAGS += -DZIP_NO_INTEGRITY
+endif
 LOCAL_CPPFLAGS := -Wold-style-cast
 include $(BUILD_STATIC_LIBRARY)
 
@@ -34,7 +37,10 @@ LOCAL_STATIC_LIBRARIES := libz libutils libbase
 LOCAL_MODULE:= libziparchive-host
 LOCAL_CFLAGS := -Werror
 ifneq ($(strip $(USE_MINGW)),)
-	LOCAL_CFLAGS += -mno-ms-bitfields
+    LOCAL_CFLAGS += -mno-ms-bitfields
+endif
+ifeq ($(ZIP_OPTIMIZATION_NO_INTEGRITY),true)
+    LOCAL_CFLAGS += -DZIP_NO_INTEGRITY
 endif
 LOCAL_MULTILIB := both
 include $(BUILD_HOST_STATIC_LIBRARY)
@@ -46,6 +52,9 @@ LOCAL_STATIC_LIBRARIES := libz libutils
 LOCAL_SHARED_LIBRARIES := liblog libbase
 LOCAL_MODULE:= libziparchive-host
 LOCAL_CFLAGS := -Werror
+ifeq ($(ZIP_OPTIMIZATION_NO_INTEGRITY),true)
+    LOCAL_CFLAGS += -DZIP_NO_INTEGRITY
+endif
 LOCAL_MULTILIB := both
 include $(BUILD_HOST_SHARED_LIBRARY)
 
@@ -54,6 +63,9 @@ include $(CLEAR_VARS)
 LOCAL_MODULE := ziparchive-tests
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_CFLAGS := -Werror
+ifeq ($(ZIP_OPTIMIZATION_NO_INTEGRITY),true)
+    LOCAL_CFLAGS += -DZIP_NO_INTEGRITY
+endif
 LOCAL_SRC_FILES := zip_archive_test.cc entry_name_utils_test.cc
 LOCAL_SHARED_LIBRARIES := liblog libbase
 LOCAL_STATIC_LIBRARIES := libziparchive libz libutils
@@ -65,6 +77,9 @@ LOCAL_CPP_EXTENSION := .cc
 LOCAL_CFLAGS += \
     -Werror \
     -Wno-unnamed-type-template-args
+ifeq ($(ZIP_OPTIMIZATION_NO_INTEGRITY),true)
+    LOCAL_CFLAGS += -DZIP_NO_INTEGRITY
+endif
 LOCAL_SRC_FILES := zip_archive_test.cc entry_name_utils_test.cc
 LOCAL_SHARED_LIBRARIES := libziparchive-host liblog libbase
 LOCAL_STATIC_LIBRARIES := \

--- a/libziparchive/zip_archive.cc
+++ b/libziparchive/zip_archive.cc
@@ -712,6 +712,57 @@ static inline ssize_t ReadAtOffset(int fd, uint8_t* buf, size_t len,
 #endif
 }
 
+#ifdef ZIP_NO_INTEGRITY
+static int32_t FindEntryNoIntegrity(const ZipArchive* archive, const int ent,
+                         ZipEntry* data) {
+  const uint16_t nameLen = archive->hash_table[ent].name_length;
+
+  // Recover the start of the central directory entry from the filename
+  // pointer.  The filename is the first entry past the fixed-size data,
+  // so we can just subtract back from that.
+  const uint8_t* ptr = archive->hash_table[ent].name;
+  ptr -= sizeof(CentralDirectoryRecord);
+
+  // This is the base of our mmapped region, we have to sanity check that
+  // the name that's in the hash table is a pointer to a location within
+  // this mapped region.
+  const uint8_t* base_ptr = reinterpret_cast<const uint8_t*>(
+    archive->directory_map.getDataPtr());
+  if (ptr < base_ptr || ptr > base_ptr + archive->directory_map.getDataLength()) {
+    ALOGW("Zip: Invalid entry pointer");
+    return kInvalidOffset;
+  }
+
+  const CentralDirectoryRecord *cdr =
+      reinterpret_cast<const CentralDirectoryRecord*>(ptr);
+
+  // The offset of the start of the central directory in the zipfile.
+  // We keep this lying around so that we can sanity check all our lengths
+  // and our per-file structures.
+  const off64_t cd_offset = archive->directory_offset;
+
+  // Fill out the compression method, modification time, crc32
+  // and other interesting attributes from the central directory. These
+  // will later be compared against values from the local file header.
+  data->method = cdr->compression_method;
+  data->mod_time = cdr->last_mod_time;
+  data->crc32 = cdr->crc32;
+  data->compressed_length = cdr->compressed_size;
+  data->uncompressed_length = cdr->uncompressed_size;
+
+  // Figure out the local header offset from the central directory. The
+  // actual file data will begin after the local header and the name /
+  // extra comments.
+  const off64_t local_header_offset = cdr->local_file_header_offset;
+  if (local_header_offset + static_cast<off64_t>(sizeof(LocalFileHeader)) >= cd_offset) {
+    ALOGW("Zip: bad local hdr offset in zip");
+    return kInvalidOffset;
+  }
+
+  return 0;
+}
+#endif
+
 static int32_t FindEntry(const ZipArchive* archive, const int ent,
                          ZipEntry* data) {
   const uint16_t nameLen = archive->hash_table[ent].name_length;
@@ -881,6 +932,49 @@ struct IterationHandle {
   }
 };
 
+#ifdef ZIP_NO_INTEGRITY
+int32_t NextNoIntegrity(void* cookie, ZipEntry* data, ZipEntryName* name) {
+  IterationHandle* handle = reinterpret_cast<IterationHandle*>(cookie);
+  if (handle == NULL) {
+    return kInvalidHandle;
+  }
+
+  ZipArchive* archive = handle->archive;
+  if (archive == NULL || archive->hash_table == NULL) {
+    ALOGW("Zip: Invalid ZipArchiveHandle");
+    return kInvalidHandle;
+  }
+
+  const uint32_t currentOffset = handle->position;
+  const uint32_t hash_table_length = archive->hash_table_size;
+  const ZipEntryName *hash_table = archive->hash_table;
+
+  for (uint32_t i = currentOffset; i < hash_table_length; ++i) {
+    if (hash_table[i].name != NULL &&
+        (handle->prefix_len == 0 ||
+         (hash_table[i].name_length >= handle->prefix_len &&
+          memcmp(handle->prefix, hash_table[i].name, handle->prefix_len) == 0)) &&
+        (handle->suffix_len == 0 ||
+         (hash_table[i].name_length >= handle->suffix_len &&
+          memcmp(handle->suffix,
+                 hash_table[i].name + hash_table[i].name_length - handle->suffix_len,
+                 handle->suffix_len) == 0))) {
+      handle->position = (i + 1);
+      const int error = FindEntryNoIntegrity(archive, i, data);
+      if (!error) {
+        name->name = hash_table[i].name;
+        name->name_length = hash_table[i].name_length;
+      }
+
+      return error;
+    }
+  }
+
+  handle->position = 0;
+  return kIterationEnd;
+}
+#endif
+
 int32_t StartIteration(ZipArchiveHandle handle, void** cookie_ptr,
                        const ZipEntryName* optional_prefix,
                        const ZipEntryName* optional_suffix) {