Skip to contentSkip to conversation

android-tools: Fix, enhance and move from meta-shr

PATCH In review Khem Raj 2 participants 3 messages Mar 31, 2016 – Apr 25, 2016

lore
Share & tools
lore

Khem Raj

author
#0 lore raw

PATCH 1/1 android-tools: Fix, enhance and move from meta-shr

android tools offer filsystem tools for creating sparse images, so package them in package of its own.

Fix src uri to latest

---
 .../android-tools-conf/android-gadget-setup        |    25 +
 .../android-tools/android-tools-conf_1.0.bb        |    13 +
 .../adbd-disable-client-authentication.patch       |    16 +
 .../android-tools/android-tools/add_adbd.patch     | 20218 +++++++++++++++++++
 .../android-tools/android-tools-adbd.service       |    12 +
 .../android-tools/disable-selinux-support.patch    |   137 +
 .../android-tools/reboot-syscall.patch             |    25 +
 .../android-tools/remove-libselinux.patch          |    13 +
 .../android-tools/android-tools_4.2.2.bb           |    82 +
 9 files changed, 20541 insertions(+)
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools/android-tools-adbd.service
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools/disable-selinux-support.patch
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools/reboot-syscall.patch
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools/remove-libselinux.patch
 create mode 100644 meta-oe/recipes-devtools/android-tools/android-tools_4.2.2.bb
meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup new file +25 -0
new file mode 100644
index 0000000..f7d9973
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# TODO enable the lines below once we have support for getprop
+# retrieve the product info from Android
+# manufacturer=$(getprop ro.product.manufacturer Android)
+# model=$(getprop ro.product.model Android)
+# serial=$(getprop ro.serialno 0123456789ABCDEF)
+
+manufacturer="$(cat /system/build.prop | grep -o 'ro.product.manufacturer=.*' | cut -d'=' -f 2)"
+model="$(cat /system/build.prop | grep -o 'ro.product.model=.*' | cut -d'=' -f 2)"
+# get the device serial number from /proc/cmdline directly(since we have no getprop on
+# GNU/Linux)
+serial="$(cat /proc/cmdline | sed 's/.*androidboot.serialno=//' | sed 's/ .*//')"
+
+echo $serial > /sys/class/android_usb/android0/iSerial
+echo $manufacturer > /sys/class/android_usb/android0/iManufacturer
+echo $model > /sys/class/android_usb/android0/iProduct
+
+echo "0" > /sys/class/android_usb/android0/enable
+echo "18d1" > /sys/class/android_usbid_usb/android0/idVendor
+echo "D002" > /sys/class/android_usb/android0/idProduct
+echo "adb" > /sys/class/android_usb/android0/functions
+echo "1" >  /sys/class/android_usb/android0/enable
+
+sleep 4
meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +13 -0
new file mode 100644
index 0000000..af98f92
@@ -0,0 +1,13 @@
+DESCRIPTION = "Different utilities from Android - corressponding configuration files"
+SECTION = "console/utils"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"
+
+SRC_URI = "file://android-gadget-setup"
+
+PACKAGE_ARCH = "${MACHINE_ARCH}"
+
+do_install() {
+    install -d ${D}${bindir}
+    install -m 0755 ${WORKDIR}/android-gadget-setup ${D}${bindir}
+}
meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch new file +16 -0
new file mode 100644
index 0000000..9539160
@@ -0,0 +1,16 @@
+--- android-tools-orig/core/adbd/adb_auth_client.c	2013-07-29 16:24:49.827822956 +0000
++++ android-tools/core/adbd/adb_auth_client.c	2013-07-29 16:25:29.931623038 +0000
+@@ -200,8 +200,11 @@
+         return;
+     }
+ 
+-    fdevent_install(&t->auth_fde, framework_fd, adb_auth_event, t);
+-    fdevent_add(&t->auth_fde, FDE_READ);
++    // fdevent_install(&t->auth_fde, framework_fd, adb_auth_event, t);
++    // fdevent_add(&t->auth_fde, FDE_READ);
++
++    adb_auth_reload_keys();
++    adb_auth_verified(t);
+ }
+ 
+ static void adb_auth_listener(int fd, unsigned events, void *data)
meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch new file +20218 -0

2,946 lines not on this page · raw message

meta-oe/recipes-devtools/android-tools/android-tools/android-tools-adbd.service new file +12 -0
new file mode 100644
index 0000000..88ed687

Lines of this file are not shown. View the raw message.

meta-oe/recipes-devtools/android-tools/android-tools/disable-selinux-support.patch new file +137 -0

137 lines not on this page · raw message

meta-oe/recipes-devtools/android-tools/android-tools/reboot-syscall.patch new file +25 -0
new file mode 100644
index 0000000..0055416

Lines of this file are not shown. View the raw message.

meta-oe/recipes-devtools/android-tools/android-tools/remove-libselinux.patch new file +13 -0
new file mode 100644
index 0000000..24690b2

Lines of this file are not shown. View the raw message.

meta-oe/recipes-devtools/android-tools/android-tools_4.2.2.bb new file +82 -0

82 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
2.7.4

Part of the diff is not shown here. View the raw message.

author
#1 lore raw

ping^1

Quoted 1,978 lines · Khem Raj

android tools offer filsystem tools for creating sparse images, so package them in package of its own.

Fix src uri to latest

---
 .../android-tools-conf/android-gadget-setup        |    25 +
 .../android-tools/android-tools-conf_1.0.bb        |    13 +
 .../adbd-disable-client-authentication.patch       |    16 +
 .../android-tools/android-tools/add_adbd.patch     | 20218
+++++++++++++++++++
 .../android-tools/android-tools-adbd.service       |    12 +
 .../android-tools/disable-selinux-support.patch    |   137 +
 .../android-tools/reboot-syscall.patch             |    25 +
 .../android-tools/remove-libselinux.patch          |    13 +
 .../android-tools/android-tools_4.2.2.bb           |    82 +
 9 files changed, 20541 insertions(+)
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup
 create mode 100644 meta-oe/recipes-devtools/android-tools/
android-tools-conf_1.0.bb
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools/android-tools-adbd.service
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools/disable-selinux-support.patch
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools/reboot-syscall.patch
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools/remove-libselinux.patch
 create mode 100644 meta-oe/recipes-devtools/android-tools/

android-tools_4.2.2.bb

diff --git a/meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup b/meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup new file mode 100644
index 0000000..f7d9973
--- /dev/null
+++
b/meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup

meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup new file +9 -0
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# TODO enable the lines below once we have support for getprop
+# retrieve the product info from Android
+# manufacturer=$(getprop ro.product.manufacturer Android)
+# model=$(getprop ro.product.model Android)
+# serial=$(getprop ro.serialno 0123456789ABCDEF)
+
+manufacturer="$(cat /system/build.prop | grep -o

'ro.product.manufacturer=.*' | cut -d'=' -f 2)"

(quoted diff) +2 -1
+model="$(cat /system/build.prop | grep -o 'ro.product.model=.*' | cut
-d'=' -f 2)"
+# get the device serial number from /proc/cmdline directly(since we have

no getprop on

(quoted diff) +2 -0
+# GNU/Linux)
+serial="$(cat /proc/cmdline | sed 's/.*androidboot.serialno=//' | sed 's/

.*//')"

meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup new file +12 -0
+
+echo $serial > /sys/class/android_usb/android0/iSerial
+echo $manufacturer > /sys/class/android_usb/android0/iManufacturer
+echo $model > /sys/class/android_usb/android0/iProduct
+
+echo "0" > /sys/class/android_usb/android0/enable
+echo "18d1" > /sys/class/android_usbid_usb/android0/idVendor
+echo "D002" > /sys/class/android_usb/android0/idProduct
+echo "adb" > /sys/class/android_usb/android0/functions
+echo "1" >  /sys/class/android_usb/android0/enable
+
+sleep 4
(quoted diff) +0 -0

android-tools-conf_1.0.bb b/meta-oe/recipes-devtools/android-tools/ android-tools-conf_1.0.bb
new file mode 100644
index 0000000..af98f92

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +1 -0
@@ -0,0 +1,13 @@
+DESCRIPTION = "Different utilities from Android - corressponding

configuration files"

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +3 -0
+SECTION = "console/utils"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM =

"file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +9 -0
+
+SRC_URI = "file://android-gadget-setup"
+
+PACKAGE_ARCH = "${MACHINE_ARCH}"
+
+do_install() {
+    install -d ${D}${bindir}
+    install -m 0755 ${WORKDIR}/android-gadget-setup ${D}${bindir}
+}

diff --git a/meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch b/meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch new file mode 100644
index 0000000..9539160
--- /dev/null
+++
b/meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +1 -0
@@ -0,0 +1,16 @@
+--- android-tools-orig/core/adbd/adb_auth_client.c     2013-07-29

16:24:49.827822956 +0000
++++ android-tools/core/adbd/adb_auth_client.c 2013-07-29 16:25:29.931623038 +0000
+@@ -200,8 +200,11 @@

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +13 -0
+         return;
+     }
+
+-    fdevent_install(&t->auth_fde, framework_fd, adb_auth_event, t);
+-    fdevent_add(&t->auth_fde, FDE_READ);
++    // fdevent_install(&t->auth_fde, framework_fd, adb_auth_event, t);
++    // fdevent_add(&t->auth_fde, FDE_READ);
++
++    adb_auth_reload_keys();
++    adb_auth_verified(t);
+ }
+
+ static void adb_auth_listener(int fd, unsigned events, void *data)

diff --git a/meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch b/meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch new file mode 100644
index 0000000..561978f

meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch new file +7 -0
@@ -0,0 +1,20218 @@
+## Description: add some description
+## Origin/Author: add some origin or author
+## Bug: bug URL
+Index: android-tools-4.2.2+git20130218/core/adbd/adb.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb.c    2013-06-18

17:12:17.000000000 -0300
+@@ -0,0 +1,1719 @@
++/*
++ * Copyright (C) 2007 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.
++ */
++
++#define TRACE_TAG TRACE_ADB
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <ctype.h>
++#include <stdarg.h>
++#include <errno.h>
++#include <stddef.h>
++#include <string.h>
++#include <time.h>
++#include <sys/time.h>
++#include <stdint.h>
++
++#include "sysdeps.h"
++#include "adb.h"
++#include "adb_auth.h"
++
++#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
++
++#if !ADB_HOST
++#include "android_filesystem_config.h"
++#include <linux/capability.h>
++#include <linux/prctl.h>
++#include <sys/mount.h>
++#else
++#include "usb_vendors.h"
++#endif
++
++#if ADB_TRACE
++ADB_MUTEX_DEFINE( D_lock );
++#endif
++
++int HOST = 0;
++int gListenAll = 0;
++
++static int auth_enabled = 0;
++
++#if !ADB_HOST
++static const char *adb_device_banner = "device";
++#endif
++
++void fatal(const char *fmt, ...)
++{

++    va_list ap;
++    va_start(ap, fmt);
++    fprintf(stderr, "error: ");
++    vfprintf(stderr, fmt, ap);
++    fprintf(stderr, "\n");
++    va_end(ap);
++    exit(-1);

++}
++
++void fatal_errno(const char *fmt, ...)
++{

++    va_list ap;
++    va_start(ap, fmt);
++    fprintf(stderr, "error: %s: ", strerror(errno));
++    vfprintf(stderr, fmt, ap);
++    fprintf(stderr, "\n");
++    va_end(ap);
++    exit(-1);

++}
++
++int adb_trace_mask;
++
++/* read a comma/space/colum/semi-column separated list of tags ++ * from the ADB_TRACE environment variable and build the trace ++ * mask from it. note that '1' and 'all' are special cases to ++ * enable all tracing
++ */
++void adb_trace_init(void)
++{

++    const char*  p = getenv("ADB_TRACE");
++    const char*  q;

++
++ static const struct {
++ const char* tag;
++ int flag;
++ } tags[] = {

++        { "1", 0 },
++        { "all", 0 },
++        { "adb", TRACE_ADB },
++        { "sockets", TRACE_SOCKETS },
++        { "packets", TRACE_PACKETS },
++        { "rwx", TRACE_RWX },
++        { "usb", TRACE_USB },
++        { "sync", TRACE_SYNC },
++        { "sysdeps", TRACE_SYSDEPS },
++        { "transport", TRACE_TRANSPORT },
++        { "jdwp", TRACE_JDWP },
++        { "services", TRACE_SERVICES },
++        { "auth", TRACE_AUTH },
++        { NULL, 0 }

++ };
++
++ if (p == NULL)
++ return;
++
++ /* use a comma/column/semi-colum/space separated list */
++ while (*p) {
++ int len, tagn;
++
++ q = strpbrk(p, " ,:;");
++ if (q == NULL) {
++ q = p + strlen(p);
++ }
++ len = q - p;
++
++ for (tagn = 0; tags[tagn].tag != NULL; tagn++)
++ {
++ int taglen = strlen(tags[tagn].tag);
++
++ if (len == taglen && !memcmp(tags[tagn].tag, p, len) )
++ {
++ int flag = tags[tagn].flag;
++ if (flag == 0) {
++ adb_trace_mask = ~0;
++ return;

++                }
++                adb_trace_mask |= (1 << flag);
++                break;
++            }
++        }
++        p = q;
++        if (*p)

++ p++;
++ }
++}
++
++#if !ADB_HOST
++/*
++ * Implements ADB tracing inside the emulator.
++ */
++
++#include <stdarg.h>
++
++/*
++ * Redefine open and write for qemu_pipe.h that contains inlined references
++ * to those routines. We will redifine them back after qemu_pipe.h inclusion.
++ */
++
++#undef open
++#undef write
++#define open adb_open
++#define write adb_write
++#include "qemu_pipe.h"
++#undef open
++#undef write
++#define open ___xxx_open
++#define write ___xxx_write
++
++/* A handle to adb-debug qemud service in the emulator. */
++int adb_debug_qemu = -1;
++
++/* Initializes connection with the adb-debug qemud service in the emulator. */
++static int adb_qemu_trace_init(void)
++{
++ char con_name[32];
++
++ if (adb_debug_qemu >= 0) {
++ return 0;
++ }
++

++    /* adb debugging QEMUD service connection request. */
++    snprintf(con_name, sizeof(con_name), "qemud:adb-debug");
++    adb_debug_qemu = qemu_pipe_open(con_name);
++    return (adb_debug_qemu >= 0) ? 0 : -1;

++}
++
++void adb_qemu_trace(const char* fmt, ...)
++{

++    va_list args;
++    va_start(args, fmt);
++    char msg[1024];

++
++ if (adb_debug_qemu >= 0) {
++ vsnprintf(msg, sizeof(msg), fmt, args);
++ adb_write(adb_debug_qemu, msg, strlen(msg));
++ }
++}
++#endif /* !ADB_HOST */
++
++apacket *get_apacket(void)
++{

++    apacket *p = malloc(sizeof(apacket));
++    if(p == 0) fatal("failed to allocate an apacket");
++    memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);
++    return p;

++}
++
++void put_apacket(apacket *p)
++{
++ free(p);
++}
++
++void handle_online(atransport *t)
++{
++ D("adb: online\n");
++ t->online = 1;
++}
++
++void handle_offline(atransport *t)
++{

++    D("adb: offline\n");
++    //Close the associated usb
++    t->online = 0;
++    run_transport_disconnects(t);

++}
++
++#if DEBUG_PACKETS
++#define DUMPMAX 32
++void print_packet(const char *label, apacket *p) ++{

++    char *tag;
++    char *x;
++    unsigned count;
++
++    switch(p->msg.command){
++    case A_SYNC: tag = "SYNC"; break;
++    case A_CNXN: tag = "CNXN" ; break;
++    case A_OPEN: tag = "OPEN"; break;
++    case A_OKAY: tag = "OKAY"; break;
++    case A_CLSE: tag = "CLSE"; break;
++    case A_WRTE: tag = "WRTE"; break;
++    case A_AUTH: tag = "AUTH"; break;
++    default: tag = "????"; break;
++    }
++
++    fprintf(stderr, "%s: %s %08x %08x %04x \"",
++            label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
++    count = p->msg.data_length;
++    x = (char*) p->data;
++    if(count > DUMPMAX) {

++ count = DUMPMAX;
++ tag = "\n";
++ } else {
++ tag = "\"\n";
++ }
++ while(count-- > 0){
++ if((*x >= ' ') && (*x < 127)) {
++ fputc(*x, stderr);
++ } else {
++ fputc('.', stderr);
++ }
++ x++;
++ }
++ fputs(tag, stderr);
++}
++#endif
++
++static void send_ready(unsigned local, unsigned remote, atransport *t) ++{

++    D("Calling send_ready \n");
++    apacket *p = get_apacket();
++    p->msg.command = A_OKAY;
++    p->msg.arg0 = local;
++    p->msg.arg1 = remote;
++    send_packet(p, t);

++}
++
++static void send_close(unsigned local, unsigned remote, atransport *t) ++{

++    D("Calling send_close \n");
++    apacket *p = get_apacket();
++    p->msg.command = A_CLSE;
++    p->msg.arg0 = local;
++    p->msg.arg1 = remote;
++    send_packet(p, t);

++}
++
++static size_t fill_connect_data(char *buf, size_t bufsize) ++{
++#if ADB_HOST
++ return snprintf(buf, bufsize, "host::") + 1;
++#else
++ static const char *cnxn_props[] = {

++        "ro.product.name",
++        "ro.product.model",
++        "ro.product.device",
++    };
++    static const int num_cnxn_props = ARRAY_SIZE(cnxn_props);
++    static const char *values[] = {
++        "occam",
++        "Nexus 4",
++        "mako",
++    };
++    int i;
++    size_t remaining = bufsize;
++    size_t len;
++
++    len = snprintf(buf, remaining, "%s::", adb_device_banner);
++    remaining -= len;
++    buf += len;
++    for (i = 0; i < num_cnxn_props; i++) {
++        char value[PROPERTY_VALUE_MAX];
++        //property_get(cnxn_props[i], value, "");
++        len = snprintf(buf, remaining, "%s=%s;", cnxn_props[i],

values[i]);
++ remaining -= len;
++ buf += len;
++ }
++
++ return bufsize - remaining + 1;
++#endif
++}
++
++static void send_connect(atransport *t)
++{

++    D("Calling send_connect \n");
++    apacket *cp = get_apacket();
++    cp->msg.command = A_CNXN;
++    cp->msg.arg0 = A_VERSION;
++    cp->msg.arg1 = MAX_PAYLOAD;
++    cp->msg.data_length = fill_connect_data((char *)cp->data,

++ sizeof(cp->data));
++ send_packet(cp, t);
++}
++
++static void send_auth_request(atransport *t)
++{

++    D("Calling send_auth_request\n");
++    apacket *p;
++    int ret;

++
++ ret = adb_auth_generate_token(t->token, sizeof(t->token));
++ if (ret != sizeof(t->token)) {
++ D("Error generating token ret=%d\n", ret);
++ return;
++ }
++

++    p = get_apacket();
++    memcpy(p->data, t->token, ret);
++    p->msg.command = A_AUTH;
++    p->msg.arg0 = ADB_AUTH_TOKEN;
++    p->msg.data_length = ret;
++    send_packet(p, t);

++}
++
++static void send_auth_response(uint8_t *token, size_t token_size, atransport *t)
++{

++    D("Calling send_auth_response\n");
++    apacket *p = get_apacket();
++    int ret;
++
++    ret = adb_auth_sign(t->key, token, token_size, p->data);
++    if (!ret) {
++        D("Error signing the token\n");
++        put_apacket(p);
++        return;
++    }
++
++    p->msg.command = A_AUTH;
++    p->msg.arg0 = ADB_AUTH_SIGNATURE;
++    p->msg.data_length = ret;
++    send_packet(p, t);

++}
++
++static void send_auth_publickey(atransport *t)
++{

++    D("Calling send_auth_publickey\n");
++    apacket *p = get_apacket();
++    int ret;
++
++    ret = adb_auth_get_userkey(p->data, sizeof(p->data));
++    if (!ret) {
++        D("Failed to get user public key\n");
++        put_apacket(p);
++        return;
++    }
++
++    p->msg.command = A_AUTH;
++    p->msg.arg0 = ADB_AUTH_RSAPUBLICKEY;
++    p->msg.data_length = ret;
++    send_packet(p, t);

++}
++
++void adb_auth_verified(atransport *t)
++{
++ handle_online(t);
++ send_connect(t);
++}
++
++static char *connection_state_name(atransport *t)
++{
++ if (t == NULL) {
++ return "unknown";
++ }
++
++ switch(t->connection_state) {
++ case CS_BOOTLOADER:
++ return "bootloader";
++ case CS_DEVICE:
++ return "device";
++ case CS_OFFLINE:
++ return "offline";
++ default:
++ return "unknown";
++ }
++}
++
++/* qual_overwrite is used to overwrite a qualifier string. dst is a ++ * pointer to a char pointer. It is assumed that if *dst is non-NULL, it ++ * was malloc'ed and needs to freed. *dst will be set to a dup of src. ++ */
++static void qual_overwrite(char **dst, const char *src)
++{
++ if (!dst)
++ return;
++
++ free(*dst);
++ *dst = NULL;
++
++ if (!src || !*src)
++ return;
++
++ *dst = strdup(src);
++}
++
++void parse_banner(char *banner, atransport *t)
++{

++    static const char *prop_seps = ";";
++    static const char key_val_sep = '=';
++    char *cp;
++    char *type;
++
++    D("parse_banner: %s\n", banner);
++    type = banner;
++    cp = strchr(type, ':');
++    if (cp) {
++        *cp++ = 0;
++        /* Nothing is done with second field. */
++        cp = strchr(cp, ':');
++        if (cp) {
++            char *save;
++            char *key;
++            key = adb_strtok_r(cp + 1, prop_seps, &save);
++            while (key) {

++ cp = strchr(key, key_val_sep);
++ if (cp) {
++ *cp++ = '\0';
++ if (!strcmp(key, "ro.product.name"))
++ qual_overwrite(&t->product, cp);
++ else if (!strcmp(key, "ro.product.model"))
++ qual_overwrite(&t->model, cp);
++ else if (!strcmp(key, "ro.product.device"))
++ qual_overwrite(&t->device, cp);
++ }
++ key = adb_strtok_r(NULL, prop_seps, &save);
++ }
++ }
++ }
++
++ if(!strcmp(type, "bootloader")){

++        D("setting connection_state to CS_BOOTLOADER\n");
++        t->connection_state = CS_BOOTLOADER;
++        update_transports();
++        return;
++    }
++
++    if(!strcmp(type, "device")) {
++        D("setting connection_state to CS_DEVICE\n");
++        t->connection_state = CS_DEVICE;
++        update_transports();
++        return;
++    }
++
++    if(!strcmp(type, "recovery")) {
++        D("setting connection_state to CS_RECOVERY\n");
++        t->connection_state = CS_RECOVERY;
++        update_transports();
++        return;
++    }
++
++    if(!strcmp(type, "sideload")) {
++        D("setting connection_state to CS_SIDELOAD\n");
++        t->connection_state = CS_SIDELOAD;
++        update_transports();
++        return;

++ }
++
++ t->connection_state = CS_HOST;
++}
++
++void handle_packet(apacket *p, atransport *t)
++{
++ asocket *s;
++
++ D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0],

++            ((char*) (&(p->msg.command)))[1],
++            ((char*) (&(p->msg.command)))[2],
++            ((char*) (&(p->msg.command)))[3]);

++ print_packet("recv", p);
++
++ switch(p->msg.command){
++ case A_SYNC:
++ if(p->msg.arg0){
++ send_packet(p, t);
++ if(HOST) send_connect(t);
++ } else {

++            t->connection_state = CS_OFFLINE;
++            handle_offline(t);
++            send_packet(p, t);

++ }
++ return;
++
++ case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */
++ /* XXX verify version, etc */
++ if(t->connection_state != CS_OFFLINE) {
++ t->connection_state = CS_OFFLINE;
++ handle_offline(t);
++ }
++
++ parse_banner((char*) p->data, t);
++
++ if (HOST || !auth_enabled) {
++ handle_online(t);
++ if(!HOST) send_connect(t);
++ } else {
++ send_auth_request(t);
++ }
++ break;
++
++ case A_AUTH:
++ if (p->msg.arg0 == ADB_AUTH_TOKEN) {
++ t->key = adb_auth_nextkey(t->key);
++ if (t->key) {
++ send_auth_response(p->data, p->msg.data_length, t);
++ } else {
++ /* No more private keys to try, send the public key */
++ send_auth_publickey(t);
++ }
++ } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) {
++ if (adb_auth_verify(t->token, p->data, p->msg.data_length)) {
++ adb_auth_verified(t);
++ t->failed_auth_attempts = 0;
++ } else {
++ if (t->failed_auth_attempts++ > 10)
++ adb_sleep_ms(1000);
++ send_auth_request(t);
++ }
++ } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) {
++ adb_auth_confirm_key(p->data, p->msg.data_length, t);
++ }
++ break;
++
++ case A_OPEN: /* OPEN(local-id, 0, "destination") */
++ if (t->online) {
++ char *name = (char*) p->data;
++ name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] =
0;
++ s = create_local_service_socket(name);
++ if(s == 0) {
++ send_close(0, p->msg.arg0, t);
++ } else {

++                s->peer = create_remote_socket(p->msg.arg0, t);
++                s->peer->peer = s;
++                send_ready(s->id, s->peer->id, t);
++                s->ready(s);

++ }
++ }
++ break;
++
++ case A_OKAY: /* READY(local-id, remote-id, "") */
++ if (t->online) {
++ if((s = find_local_socket(p->msg.arg1))) {
++ if(s->peer == 0) {
++ s->peer = create_remote_socket(p->msg.arg0, t);
++ s->peer->peer = s;
++ }
++ s->ready(s);
++ }
++ }
++ break;
++
++ case A_CLSE: /* CLOSE(local-id, remote-id, "") */
++ if (t->online) {
++ if((s = find_local_socket(p->msg.arg1))) {
++ s->close(s);
++ }
++ }
++ break;
++
++ case A_WRTE:
++ if (t->online) {
++ if((s = find_local_socket(p->msg.arg1))) {
++ unsigned rid = p->msg.arg0;
++ p->len = p->msg.data_length;
++
++ if(s->enqueue(s, p) == 0) {
++ D("Enqueue the socket\n");
++ send_ready(s->id, rid, t);
++ }
++ return;
++ }
++ }
++ break;
++
++ default:
++ printf("handle_packet: what is %08x?!\n", p->msg.command);
++ }
++
++ put_apacket(p);
++}
++
++alistener listener_list = {
++ .next = &listener_list,
++ .prev = &listener_list,
++};
++
++static void ss_listener_event_func(int _fd, unsigned ev, void *_l) ++{
++ asocket *s;
++
++ if(ev & FDE_READ) {

++        struct sockaddr addr;
++        socklen_t alen;
++        int fd;
++
++        alen = sizeof(addr);
++        fd = adb_socket_accept(_fd, &addr, &alen);
++        if(fd < 0) return;

++
++ adb_socket_setbufsize(fd, CHUNK_SIZE);
++
++ s = create_local_socket(fd);
++ if(s) {
++ connect_to_smartsocket(s);
++ return;
++ }
++
++ adb_close(fd);
++ }
++}
++
++static void listener_event_func(int _fd, unsigned ev, void *_l) ++{
++ alistener *l = _l;
++ asocket *s;
++
++ if(ev & FDE_READ) {

++        struct sockaddr addr;
++        socklen_t alen;
++        int fd;
++
++        alen = sizeof(addr);
++        fd = adb_socket_accept(_fd, &addr, &alen);
++        if(fd < 0) return;
++
++        s = create_local_socket(fd);
++        if(s) {
++            s->transport = l->transport;
++            connect_to_remote(s, l->connect_to);
++            return;

++ }
++
++ adb_close(fd);
++ }
++}
++
++static void free_listener(alistener* l)
++{
++ if (l->next) {

++        l->next->prev = l->prev;
++        l->prev->next = l->next;
++        l->next = l->prev = l;

++ }
++
++ // closes the corresponding fd
++ fdevent_remove(&l->fde);
++
++ if (l->local_name)
++ free((char*)l->local_name);
++
++ if (l->connect_to)
++ free((char*)l->connect_to);
++
++ if (l->transport) {
++ remove_transport_disconnect(l->transport, &l->disconnect);
++ }
++ free(l);
++}
++
++static void listener_disconnect(void* _l, atransport* t) ++{
++ alistener* l = _l;
++
++ free_listener(l);
++}
++
++int local_name_to_fd(const char *name)
++{
++ int port;
++
++ if(!strncmp("tcp:", name, 4)){
++ int ret;
++ port = atoi(name + 4);
++
++ if (gListenAll > 0) {
++ ret = socket_inaddr_any_server(port, SOCK_STREAM);
++ } else {
++ ret = socket_loopback_server(port, SOCK_STREAM);
++ }
++
++ return ret;
++ }
++#ifndef HAVE_WIN32_IPC /* no Unix-domain sockets on Win32 */
++ // It's non-sensical to support the "reserved" space on the adb host
side
++ if(!strncmp(name, "local:", 6)) {
++ return socket_local_server(name + 6,
++ ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
++ } else if(!strncmp(name, "localabstract:", 14)) {
++ return socket_local_server(name + 14,
++ ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
++ } else if(!strncmp(name, "localfilesystem:", 16)) {
++ return socket_local_server(name + 16,
++ ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
++ }
++
++#endif
++ printf("unknown local portname '%s'\n", name);
++ return -1;
++}
++
++// Write a single line describing a listener to a user-provided buffer. ++// Appends a trailing zero, even in case of truncation, but the function ++// returns the full line length.
++// If |buffer| is NULL, does not write but returns required size. ++static int format_listener(alistener* l, char* buffer, size_t buffer_len) {

++    // Format is simply:
++    //
++    //  <device-serial> " " <local-name> " " <remote-name> "\n"
++    //
++    int local_len = strlen(l->local_name);
++    int connect_len = strlen(l->connect_to);
++    int serial_len = strlen(l->transport->serial);

++
++ if (buffer != NULL) {
++ snprintf(buffer, buffer_len, "%s %s %s\n",
++ l->transport->serial, l->local_name, l->connect_to);

++    }
++    // NOTE: snprintf() on Windows returns -1 in case of truncation, so
++    // return the computed line length instead.
++    return local_len + connect_len + serial_len + 3;

++}
++
++// Write the list of current listeners (network redirections) into a ++// user-provided buffer. Appends a trailing zero, even in case of ++// trunctaion, but return the full size in bytes.
++// If |buffer| is NULL, does not write but returns required size. ++static int format_listeners(char* buf, size_t buflen)
++{

++    alistener* l;
++    int result = 0;
++    for (l = listener_list.next; l != &listener_list; l = l->next) {
++        // Ignore special listeners like those for *smartsocket*
++        if (l->connect_to[0] == '*')
++          continue;
++        int len = format_listener(l, buf, buflen);
++        // Ensure there is space for the trailing zero.
++        result += len;
++        if (buf != NULL) {
++          buf += len;
++          buflen -= len;
++          if (buflen <= 0)

++ break;
++ }
++ }
++ return result;
++}
++
++static int remove_listener(const char *local_name, atransport* transport) ++{
++ alistener *l;
++
++ for (l = listener_list.next; l != &listener_list; l = l->next) {
++ if (!strcmp(local_name, l->local_name)) {
++ listener_disconnect(l, l->transport);
++ return 0;
++ }
++ }
++ return -1;
++}
++
++static void remove_all_listeners(void)
++{
++ alistener *l, *l_next;
++ for (l = listener_list.next; l != &listener_list; l = l_next) {

++        l_next = l->next;
++        // Never remove smart sockets.
++        if (l->connect_to[0] == '*')

++ continue;
++ listener_disconnect(l, l->transport);
++ }
++}
++
++// error/status codes for install_listener.
++typedef enum {

++  INSTALL_STATUS_OK = 0,
++  INSTALL_STATUS_INTERNAL_ERROR = -1,
++  INSTALL_STATUS_CANNOT_BIND = -2,
++  INSTALL_STATUS_CANNOT_REBIND = -3,
++} install_status_t;
++
++static install_status_t install_listener(const char *local_name,
++                                         const char *connect_to,
++                                         atransport* transport,
++                                         int no_rebind)

++{
++ alistener *l;
++
++ printf("install_listener('%s','%s')\n", local_name, connect_to);
++
++ for(l = listener_list.next; l != &listener_list; l = l->next){
++ if(strcmp(local_name, l->local_name) == 0) {
++ char *cto;
++
++ /* can't repurpose a smartsocket */
++ if(l->connect_to[0] == '*') {
++ return INSTALL_STATUS_INTERNAL_ERROR;
++ }
++
++ /* can't repurpose a listener if 'no_rebind' is true */
++ if (no_rebind) {
++ return INSTALL_STATUS_CANNOT_REBIND;
++ }
++
++ cto = strdup(connect_to);
++ if(cto == 0) {
++ return INSTALL_STATUS_INTERNAL_ERROR;
++ }
++

++            //printf("rebinding '%s' to '%s'\n", local_name, connect_to);
++            free((void*) l->connect_to);
++            l->connect_to = cto;
++            if (l->transport != transport) {

++ remove_transport_disconnect(l->transport,
&l->disconnect);
++ l->transport = transport;
++ add_transport_disconnect(l->transport, &l->disconnect);
++ }
++ return INSTALL_STATUS_OK;
++ }
++ }
++

++    if((l = calloc(1, sizeof(alistener))) == 0) goto nomem;
++    if((l->local_name = strdup(local_name)) == 0) goto nomem;
++    if((l->connect_to = strdup(connect_to)) == 0) goto nomem;

++
++
++ l->fd = local_name_to_fd(local_name);
++ if(l->fd < 0) {

++        free((void*) l->local_name);
++        free((void*) l->connect_to);
++        free(l);
++        printf("cannot bind '%s'\n", local_name);
++        return -2;

++ }
++
++ close_on_exec(l->fd);
++ if(!strcmp(l->connect_to, "*smartsocket*")) {
++ fdevent_install(&l->fde, l->fd, ss_listener_event_func, l);
++ } else {
++ fdevent_install(&l->fde, l->fd, listener_event_func, l);
++ }
++ fdevent_set(&l->fde, FDE_READ);
++

++    l->next = &listener_list;
++    l->prev = listener_list.prev;
++    l->next->prev = l;
++    l->prev->next = l;
++    l->transport = transport;
++
++    if (transport) {
++        l->disconnect.opaque = l;
++        l->disconnect.func   = listener_disconnect;
++        add_transport_disconnect(transport, &l->disconnect);

++ }
++ return INSTALL_STATUS_OK;
++
++nomem:
++ fatal("cannot allocate listener");
++ return INSTALL_STATUS_INTERNAL_ERROR;
++}
++
++#ifdef HAVE_WIN32_PROC
++static BOOL WINAPI ctrlc_handler(DWORD type)
++{
++ exit(STATUS_CONTROL_C_EXIT);
++ return TRUE;
++}
++#endif
++
++static void adb_cleanup(void)
++{
++ usb_cleanup();
++}
++
++void start_logging(void)
++{
++#ifdef HAVE_WIN32_PROC

++    char    temp[ MAX_PATH ];
++    FILE*   fnul;
++    FILE*   flog;

++
++ GetTempPath( sizeof(temp) - 8, temp );
++ strcat( temp, "adb.log" );
++

++    /* Win32 specific redirections */
++    fnul = fopen( "NUL", "rt" );
++    if (fnul != NULL)

++ stdin[0] = fnul[0];
++
++ flog = fopen( temp, "at" );
++ if (flog == NULL)
++ flog = fnul;
++
++ setvbuf( flog, NULL, _IONBF, 0 );
++

++    stdout[0] = flog[0];
++    stderr[0] = flog[0];
++    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
++#else
++    int fd;
++
++    fd = unix_open("/dev/null", O_RDONLY);
++    dup2(fd, 0);
++    adb_close(fd);

++
++ fd = unix_open("/tmp/adb.log", O_WRONLY | O_CREAT | O_APPEND, 0640);
++ if(fd < 0) {
++ fd = unix_open("/dev/null", O_WRONLY);

++    }
++    dup2(fd, 1);
++    dup2(fd, 2);
++    adb_close(fd);
++    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());

++#endif
++}
++
++#if !ADB_HOST
++void start_device_log(void)
++{

++    int fd;
++    char    path[PATH_MAX];
++    struct tm now;
++    time_t t;
++    char value[PROPERTY_VALUE_MAX];
++
++    // read the trace mask from persistent property
persist.adb.trace_mask
++    // give up if the property is not set or cannot be parsed
++    //property_get("persist.adb.trace_mask", value, "");
++    //if (sscanf(value, "%x", &adb_trace_mask) != 1)
++    return;
++
++    adb_mkdir("/data/adb", 0775);
++    tzset();
++    time(&t);
++    localtime_r(&t, &now);
++    strftime(path, sizeof(path),

++ "/data/adb/adb-%Y-%m-%d-%H-%M-%S.txt",
++ &now);
++ fd = unix_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0640);
++ if (fd < 0)
++ return;
++

++    // redirect stdout and stderr to the log file
++    dup2(fd, 1);
++    dup2(fd, 2);
++    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
++    adb_close(fd);
++
++    fd = unix_open("/dev/null", O_RDONLY);
++    dup2(fd, 0);
++    adb_close(fd);

++}
++#endif
++
++#if ADB_HOST
++int launch_server(int server_port)
++{
++#ifdef HAVE_WIN32_PROC
++ /* we need to start the server in the background
*/
++ /* we create a PIPE that will be used to wait for the server's "OK"
*/
++ /* message since the pipe handles must be inheritable, we use a
*/
++ /* security attribute
*/

++    HANDLE                pipe_read, pipe_write;
++    HANDLE                stdout_handle, stderr_handle;
++    SECURITY_ATTRIBUTES   sa;
++    STARTUPINFO           startup;
++    PROCESS_INFORMATION   pinfo;
++    char                  program_path[ MAX_PATH ];
++    int                   ret;
++
++    sa.nLength = sizeof(sa);
++    sa.lpSecurityDescriptor = NULL;
++    sa.bInheritHandle = TRUE;
++
++    /* create pipe, and ensure its read handle isn't inheritable */
++    ret = CreatePipe( &pipe_read, &pipe_write, &sa, 0 );
++    if (!ret) {

++ fprintf(stderr, "CreatePipe() failure, error %ld\n",
GetLastError() );
++ return -1;
++ }
++
++ SetHandleInformation( pipe_read, HANDLE_FLAG_INHERIT, 0 );
++
++ /* Some programs want to launch an adb command and collect its
output by
++ * calling CreateProcess with inheritable stdout/stderr handles, then
++ * using read() to get its output. When this happens, the
stdout/stderr
++ * handles passed to the adb client process will also be inheritable.
++ * When starting the adb server here, care must be taken to reset
them
++ * to non-inheritable.
++ * Otherwise, something bad happens: even if the adb command
completes,
++ * the calling process is stuck while read()-ing from the
stdout/stderr
++ * descriptors, because they're connected to corresponding handles
in the
++ * adb server process (even if the latter never uses/writes to them).
++ */

++    stdout_handle = GetStdHandle( STD_OUTPUT_HANDLE );
++    stderr_handle = GetStdHandle( STD_ERROR_HANDLE );
++    if (stdout_handle != INVALID_HANDLE_VALUE) {

++ SetHandleInformation( stdout_handle, HANDLE_FLAG_INHERIT, 0 );
++ }
++ if (stderr_handle != INVALID_HANDLE_VALUE) {
++ SetHandleInformation( stderr_handle, HANDLE_FLAG_INHERIT, 0 );
++ }
++

++    ZeroMemory( &startup, sizeof(startup) );
++    startup.cb = sizeof(startup);
++    startup.hStdInput  = GetStdHandle( STD_INPUT_HANDLE );
++    startup.hStdOutput = pipe_write;
++    startup.hStdError  = GetStdHandle( STD_ERROR_HANDLE );
++    startup.dwFlags    = STARTF_USESTDHANDLES;

++
++ ZeroMemory( &pinfo, sizeof(pinfo) );
++
++ /* get path of current program */
++ GetModuleFileName( NULL, program_path, sizeof(program_path) );
++
++ ret = CreateProcess(
++ program_path, /* program path
*/
++ "adb fork-server server",
++ /* the fork-server argument will set
the
++ debug = 2 in the child
*/
++ NULL, /* process handle is not inheritable
*/
++ NULL, /* thread handle is not inheritable
*/
++ TRUE, /* yes, inherit some handles
*/
++ DETACHED_PROCESS, /* the new process doesn't have a console
*/
++ NULL, /* use parent's environment block
*/
++ NULL, /* use parent's starting directory
*/
++ &startup, /* startup info, i.e. std handles
*/
++ &pinfo );
++
++ CloseHandle( pipe_write );
++
++ if (!ret) {
++ fprintf(stderr, "CreateProcess failure, error %ld\n",
GetLastError() );
++ CloseHandle( pipe_read );
++ return -1;
++ }
++
++ CloseHandle( pinfo.hProcess );
++ CloseHandle( pinfo.hThread );
++
++ /* wait for the "OK\n" message */
++ {
++ char temp[3];
++ DWORD count;
++

++        ret = ReadFile( pipe_read, temp, 3, &count, NULL );
++        CloseHandle( pipe_read );
++        if ( !ret ) {

++ fprintf(stderr, "could not read ok from ADB Server, error =
%ld\n", GetLastError() );
++ return -1;
++ }
++ if (count != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] !=
'\n') {
++ fprintf(stderr, "ADB server didn't ACK\n" );
++ return -1;
++ }
++ }
++#elif defined(HAVE_FORKEXEC)

++    char    path[PATH_MAX];
++    int     fd[2];

++
++ // set up a pipe so the child can tell us when it is ready.
++ // fd[0] will be parent's end, and fd[1] will get mapped to stderr
in the child.
++ if (pipe(fd)) {
++ fprintf(stderr, "pipe failed in launch_server, errno: %d\n",
errno);
++ return -1;

++    }
++    get_my_path(path, PATH_MAX);
++    pid_t pid = fork();
++    if(pid < 0) return -1;

++
++ if (pid == 0) {
++ // child side of the fork
++
++ // redirect stderr to the pipe
++ // we use stderr instead of stdout due to stdout's buffering
behavior.

++        adb_close(fd[0]);
++        dup2(fd[1], STDERR_FILENO);
++        adb_close(fd[1]);
++
++        char str_port[30];
++        snprintf(str_port, sizeof(str_port), "%d",  server_port);
++        // child process
++        int result = execl(path, "adb", "-P", str_port, "fork-server",

"server", NULL);
++ // this should not return
++ fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result,
errno);
++ } else {
++ // parent side of the fork
++
++ char temp[3];
++

++        temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';
++        // wait for the "OK\n" message
++        adb_close(fd[1]);
++        int ret = adb_read(fd[0], temp, 3);
++        int saved_errno = errno;
++        adb_close(fd[0]);
++        if (ret < 0) {

++ fprintf(stderr, "could not read ok from ADB Server, errno =
%d\n", saved_errno);
++ return -1;
++ }
++ if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] !=
'\n') {
++ fprintf(stderr, "ADB server didn't ACK\n" );
++ return -1;
++ }
++
++ setsid();
++ }
++#else
++#error "cannot implement background server start on this platform" ++#endif
++ return 0;
++}
++#endif
++
++/* Constructs a local name of form tcp:port.
++ * target_str points to the target string, it's content will be overwritten.
++ * target_size is the capacity of the target string.
++ * server_port is the port number to use for the local name. ++ */
++void build_local_name(char* target_str, size_t target_size, int server_port)
++{
++ snprintf(target_str, target_size, "tcp:%d", server_port); ++}
++
++#if !ADB_HOST
++static int should_drop_privileges() {
++#ifndef ALLOW_ADBD_ROOT
++ return 1;
++#else /* ALLOW_ADBD_ROOT */
++ int secure = 0;
++ char value[PROPERTY_VALUE_MAX];
++
++ return 0;
++ /* run adbd in secure mode if ro.secure is set and
++ ** we are not in the emulator
++ */
++// property_get("ro.kernel.qemu", value, "");
++ if (strcmp(value, "1") != 0) {
++// property_get("ro.secure", value, "1");
++ if (strcmp(value, "1") == 0) {
++ // don't run as root if ro.secure is set...
++ secure = 1;
++
++ // ... except we allow running as root in userdebug builds
if the
++ // service.adb.root property has been set by the "adb root"
command
++// property_get("ro.debuggable", value, "");
++ if (strcmp(value, "1") == 0) {
++// property_get("service.adb.root", value, "");
++ if (strcmp(value, "1") == 0) {
++ secure = 0;
++ }
++ }
++ }
++ }
++ return secure;
++#endif /* ALLOW_ADBD_ROOT */
++}
++#endif /* !ADB_HOST */
++
++int adb_main(int is_daemon, int server_port)
++{
++#if !ADB_HOST
++ int port;
++ char value[PROPERTY_VALUE_MAX];
++
++ umask(000);
++#endif
++
++ atexit(adb_cleanup);
++#ifdef HAVE_WIN32_PROC
++ SetConsoleCtrlHandler( ctrlc_handler, TRUE );
++#elif defined(HAVE_FORKEXEC)
++ // No SIGCHLD. Let the service subproc handle its children.
++ signal(SIGPIPE, SIG_IGN);
++#endif
++
++ init_transport_registration();
++
++#if ADB_HOST

++    HOST = 1;
++    usb_vendors_init();
++    usb_init();
++    local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
++    adb_auth_init();
++
++    char local_name[30];
++    build_local_name(local_name, sizeof(local_name), server_port);
++    if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
++        exit(1);
++    }
++#else
++    //property_get("ro.adb.secure", value, "0");
++    auth_enabled = 0;//!strcmp(value, "1");
++    if (auth_enabled)
++        adb_auth_init();
++
++    // Our external storage path may be different than apps, since
++    // we aren't able to bind mount after dropping root.
++    const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");
++    if (NULL != adb_external_storage) {

++ setenv("EXTERNAL_STORAGE", adb_external_storage, 1);
++ } else {
++ D("Warning: ADB_EXTERNAL_STORAGE is not set. Leaving
EXTERNAL_STORAGE"
++ " unchanged.\n");
++ }
++

++    /* don't listen on a port (default 5037) if running in secure mode */
++    /* don't run as root if we are running in secure mode */
++    if (should_drop_privileges()) {

++ struct __user_cap_header_struct header;
++ struct __user_cap_data_struct cap[2];
++
++ if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) != 0) {
++ exit(1);
++ }
++

++        /* add extra groups:
++        ** AID_ADB to access the USB driver
++        ** AID_LOG to read system logs (adb logcat)
++        ** AID_INPUT to diagnose input issues (getevent)
++        ** AID_INET to diagnose network issues (netcfg, ping)
++        ** AID_GRAPHICS to access the frame buffer
++        ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth
(hcidump)
++        ** AID_SDCARD_R to allow reading from the SD card
++        ** AID_SDCARD_RW to allow writing to the SD card
++        ** AID_MOUNT to allow unmounting the SD card before rebooting
++        ** AID_NET_BW_STATS to read out qtaguid statistics
++        */
++        gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET,

AID_GRAPHICS,
++ AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R,
AID_SDCARD_RW,
++ AID_MOUNT, AID_NET_BW_STATS };
++ if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {
++ exit(1);
++ }
++
++ /* then switch user and group to "shell" */
++ if (setgid(AID_SHELL) != 0) {
++ exit(1);
++ }
++ if (setuid(AID_SHELL) != 0) {
++ exit(1);
++ }
++
++ memset(&header, 0, sizeof(header));
++ memset(cap, 0, sizeof(cap));
++

++        /* set CAP_SYS_BOOT capability, so "adb reboot" will succeed */
++        header.version = _LINUX_CAPABILITY_VERSION_3;
++        header.pid = 0;
++        cap[CAP_TO_INDEX(CAP_SYS_BOOT)].effective |=

CAP_TO_MASK(CAP_SYS_BOOT);
++ cap[CAP_TO_INDEX(CAP_SYS_BOOT)].permitted |=
CAP_TO_MASK(CAP_SYS_BOOT);
++ capset(&header, cap);
++
++ D("Local port disabled\n");
++ } else {

++        char local_name[30];
++        build_local_name(local_name, sizeof(local_name), server_port);
++        if(install_listener(local_name, "*smartsocket*", NULL, 0)) {

++ exit(1);
++ }
++ }
++
++ int usb = 0;
++ if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK)
== 0) {

++        // listen on USB
++        usb_init();
++        usb = 1;
++    }
++
++    // If one of these properties is set, also listen on that port
++    // If one of the properties isn't set and we couldn't listen on usb,
++    // listen on the default port.
++    //property_get("service.adb.tcp.port", value, "");
++    //if (!value[0]) {
++        //property_get("persist.adb.tcp.port", value, "");
++    //}
++    //if (sscanf(value, "%d", &port) == 1 && port > 0) {
++    //    printf("using port=%d\n", port);
++        // listen on TCP port specified by service.adb.tcp.port property
++    //    local_init(port);
++    //} else
++    if (!usb) {
++        printf("Using USB\n");
++        // listen on default port
++        local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
++    }
++
++    D("adb_main(): pre init_jdwp()\n");
++    init_jdwp();
++    D("adb_main(): post init_jdwp()\n");

++#endif
++
++ if (is_daemon)
++ {
++ // inform our parent that we are up and running.
++#ifdef HAVE_WIN32_PROC
++ DWORD count;
++ WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count,
NULL );
++#elif defined(HAVE_FORKEXEC)
++ fprintf(stderr, "OK\n");
++#endif
++ start_logging();
++ }
++ D("Event loop starting\n");
++
++ fdevent_loop();
++
++ usb_cleanup();
++
++ return 0;
++}
++
++#if ADB_HOST
++void connect_device(char* host, char* buffer, int buffer_size) ++{

++    int port, fd;
++    char* portstr = strchr(host, ':');
++    char hostbuf[100];
++    char serial[100];

++
++ strncpy(hostbuf, host, sizeof(hostbuf) - 1);
++ if (portstr) {
++ if (portstr - host >= (ptrdiff_t)sizeof(hostbuf)) {
++ snprintf(buffer, buffer_size, "bad host name %s", host);
++ return;

++        }
++        // zero terminate the host at the point we found the colon
++        hostbuf[portstr - host] = 0;
++        if (sscanf(portstr + 1, "%d", &port) == 0) {

++ snprintf(buffer, buffer_size, "bad port number %s", portstr);
++ return;
++ }
++ } else {
++ port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
++ }
++
++ snprintf(serial, sizeof(serial), "%s:%d", hostbuf, port);
++ if (find_transport(serial)) {
++ snprintf(buffer, buffer_size, "already connected to %s", serial);
++ return;
++ }
++
++ fd = socket_network_client(hostbuf, port, SOCK_STREAM);
++ if (fd < 0) {
++ snprintf(buffer, buffer_size, "unable to connect to %s:%d",
host, port);
++ return;
++ }
++

++    D("client: connected on remote on fd %d\n", fd);
++    close_on_exec(fd);
++    disable_tcp_nagle(fd);
++    register_socket_transport(fd, serial, port, 0);
++    snprintf(buffer, buffer_size, "connected to %s", serial);

++}
++
++void connect_emulator(char* port_spec, char* buffer, int buffer_size) ++{
++ char* port_separator = strchr(port_spec, ',');
++ if (!port_separator) {
++ snprintf(buffer, buffer_size,
++ "unable to parse '%s' as <console port>,<adb port>",
++ port_spec);
++ return;
++ }
++
++ // Zero-terminate console port and make port_separator point to 2nd
port.

++    *port_separator++ = 0;
++    int console_port = strtol(port_spec, NULL, 0);
++    int adb_port = strtol(port_separator, NULL, 0);
++    if (!(console_port > 0 && adb_port > 0)) {

++ *(port_separator - 1) = ',';
++ snprintf(buffer, buffer_size,
++ "Invalid port numbers: Expected positive numbers, got
'%s'",
++ port_spec);
++ return;
++ }
++
++ /* Check if the emulator is already known.
++ * Note: There's a small but harmless race condition here: An
emulator not

++     * present just yet could be registered by another invocation right
++     * after doing this check here. However, local_connect protects
++     * against double-registration too. From here, a better error message
++     * can be produced. In the case of the race condition, the very

specific
++ * error message won't be shown, but the data doesn't get corrupted.
*/
++ atransport* known_emulator =
find_emulator_transport_by_adb_port(adb_port);
++ if (known_emulator != NULL) {
++ snprintf(buffer, buffer_size,
++ "Emulator on port %d already registered.", adb_port);
++ return;
++ }
++
++ /* Check if more emulators can be registered. Similar unproblematic
++ * race condition as above. */
++ int candidate_slot = get_available_local_transport_index();
++ if (candidate_slot < 0) {
++ snprintf(buffer, buffer_size, "Cannot accept more emulators.");
++ return;
++ }
++
++ /* Preconditions met, try to connect to the emulator. */
++ if (!local_connect_arbitrary_ports(console_port, adb_port)) {
++ snprintf(buffer, buffer_size,
++ "Connected to emulator on ports %d,%d", console_port,
adb_port);
++ } else {
++ snprintf(buffer, buffer_size,
++ "Could not connect to emulator on ports %d,%d",
++ console_port, adb_port);
++ }
++}
++#endif
++
++int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s)
++{
++ atransport *transport = NULL;
++ char buf[4096];
++
++ if(!strcmp(service, "kill")) {

++        fprintf(stderr,"adb server killed by remote request\n");
++        fflush(stdout);
++        adb_write(reply_fd, "OKAY", 4);
++        usb_cleanup();
++        exit(0);

++ }
++
++#if ADB_HOST
++ // "transport:" is used for switching transport with a specified
serial number
++ // "transport-usb:" is used for switching transport to the only USB
transport
++ // "transport-local:" is used for switching transport to the only
local transport
++ // "transport-any:" is used for switching transport to the only
transport
++ if (!strncmp(service, "transport", strlen("transport"))) {
++ char* error_string = "unknown failure";
++ transport_type type = kTransportAny;
++
++ if (!strncmp(service, "transport-usb", strlen("transport-usb")))
{
++ type = kTransportUsb;
++ } else if (!strncmp(service, "transport-local",
strlen("transport-local"))) {
++ type = kTransportLocal;
++ } else if (!strncmp(service, "transport-any",
strlen("transport-any"))) {
++ type = kTransportAny;
++ } else if (!strncmp(service, "transport:",
strlen("transport:"))) {
++ service += strlen("transport:");
++ serial = service;
++ }
++
++ transport = acquire_one_transport(CS_ANY, type, serial,
&error_string);
++
++ if (transport) {
++ s->transport = transport;
++ adb_write(reply_fd, "OKAY", 4);
++ } else {
++ sendfailmsg(reply_fd, error_string);
++ }
++ return 1;
++ }
++
++ // return a list of all connected devices
++ if (!strncmp(service, "devices", 7)) {

++        char buffer[4096];
++        int use_long = !strcmp(service+7, "-l");
++        if (use_long || service[7] == 0) {
++            memset(buf, 0, sizeof(buf));
++            memset(buffer, 0, sizeof(buffer));
++            D("Getting device list \n");
++            list_transports(buffer, sizeof(buffer), use_long);
++            snprintf(buf, sizeof(buf),
"OKAY%04x%s",(unsigned)strlen(buffer),buffer);
++            D("Wrote device list \n");
++            writex(reply_fd, buf, strlen(buf));
++            return 0;

++ }
++ }
++
++ // add a new TCP transport, device or emulator
++ if (!strncmp(service, "connect:", 8)) {

++        char buffer[4096];
++        char* host = service + 8;
++        if (!strncmp(host, "emu:", 4)) {
++            connect_emulator(host + 4, buffer, sizeof(buffer));
++        } else {
++            connect_device(host, buffer, sizeof(buffer));
++        }
++        // Send response for emulator and device
++        snprintf(buf, sizeof(buf),

"OKAY%04x%s",(unsigned)strlen(buffer), buffer);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++
++ // remove TCP transport
++ if (!strncmp(service, "disconnect:", 11)) {

++        char buffer[4096];
++        memset(buffer, 0, sizeof(buffer));
++        char* serial = service + 11;
++        if (serial[0] == 0) {
++            // disconnect from all TCP devices
++            unregister_all_tcp_transports();
++        } else {
++            char hostbuf[100];
++            // assume port 5555 if no port is specified
++            if (!strchr(serial, ':')) {

++ snprintf(hostbuf, sizeof(hostbuf) - 1, "%s:5555",
serial);
++ serial = hostbuf;
++ }
++ atransport *t = find_transport(serial);
++
++ if (t) {
++ unregister_transport(t);
++ } else {
++ snprintf(buffer, sizeof(buffer), "No such device %s",
serial);
++ }
++ }
++
++ snprintf(buf, sizeof(buf),
"OKAY%04x%s",(unsigned)strlen(buffer), buffer);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++
++ // returns our value for ADB_SERVER_VERSION
++ if (!strcmp(service, "version")) {

++        char version[12];
++        snprintf(version, sizeof version, "%04x", ADB_SERVER_VERSION);
++        snprintf(buf, sizeof buf, "OKAY%04x%s",

(unsigned)strlen(version), version);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++
++ if(!strncmp(service,"get-serialno",strlen("get-serialno"))) {
++ char *out = "unknown";
++ transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
++ if (transport && transport->serial) {
++ out = transport->serial;
++ }
++ snprintf(buf, sizeof buf,
"OKAY%04x%s",(unsigned)strlen(out),out);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++ if(!strncmp(service,"get-devpath",strlen("get-devpath"))) {
++ char *out = "unknown";
++ transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
++ if (transport && transport->devpath) {
++ out = transport->devpath;
++ }
++ snprintf(buf, sizeof buf,
"OKAY%04x%s",(unsigned)strlen(out),out);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;

++    }
++    // indicates a new emulator instance has started
++    if (!strncmp(service,"emulator:",9)) {
++        int  port = atoi(service+9);
++        local_connect(port);
++        /* we don't even need to send a reply */
++        return 0;

++ }
++#endif // ADB_HOST
++
++ if(!strcmp(service,"list-forward")) {

++        // Create the list of forward redirections.
++        char header[9];
++        int buffer_size = format_listeners(NULL, 0);
++        // Add one byte for the trailing zero.
++        char* buffer = malloc(buffer_size+1);
++        (void) format_listeners(buffer, buffer_size+1);
++        snprintf(header, sizeof header, "OKAY%04x", buffer_size);
++        writex(reply_fd, header, 8);
++        writex(reply_fd, buffer, buffer_size);
++        free(buffer);
++        return 0;
++    }
++
++    if (!strcmp(service,"killforward-all")) {
++        remove_all_listeners();
++        adb_write(reply_fd, "OKAYOKAY", 8);
++        return 0;

++ }
++
++ if(!strncmp(service,"forward:",8) ||
++ !strncmp(service,"killforward:",12)) {

++        char *local, *remote, *err;
++        int r;
++        atransport *transport;

++
++ int createForward = strncmp(service,"kill",4);
++ int no_rebind = 0;
++
++ local = strchr(service, ':') + 1;
++
++ // Handle forward:norebind:<local>... here
++ if (createForward && !strncmp(local, "norebind:", 9)) {
++ no_rebind = 1;
++ local = strchr(local, ':') + 1;
++ }
++
++ remote = strchr(local,';');
++
++ if (createForward) {
++ // Check forward: parameter format: '<local>;<remote>'
++ if(remote == 0) {
++ sendfailmsg(reply_fd, "malformed forward spec");
++ return 0;
++ }
++
++ *remote++ = 0;
++ if((local[0] == 0) || (remote[0] == 0) || (remote[0] ==
'*')){
++ sendfailmsg(reply_fd, "malformed forward spec");
++ return 0;
++ }
++ } else {
++ // Check killforward: parameter format: '<local>'
++ if (local[0] == 0) {
++ sendfailmsg(reply_fd, "malformed forward spec");
++ return 0;
++ }
++ }
++
++ transport = acquire_one_transport(CS_ANY, ttype, serial, &err);
++ if (!transport) {
++ sendfailmsg(reply_fd, err);
++ return 0;
++ }
++
++ if (createForward) {
++ r = install_listener(local, remote, transport, no_rebind);
++ } else {
++ r = remove_listener(local, transport);
++ }
++ if(r == 0) {
++ /* 1st OKAY is connect, 2nd OKAY is status */
++ writex(reply_fd, "OKAYOKAY", 8);
++ return 0;
++ }
++
++ if (createForward) {
++ const char* message;
++ switch (r) {
++ case INSTALL_STATUS_CANNOT_BIND:
++ message = "cannot bind to socket";
++ break;
++ case INSTALL_STATUS_CANNOT_REBIND:
++ message = "cannot rebind existing socket";
++ break;
++ default:
++ message = "internal error";
++ }
++ sendfailmsg(reply_fd, message);
++ } else {
++ sendfailmsg(reply_fd, "cannot remove listener");
++ }
++ return 0;
++ }
++
++ if(!strncmp(service,"get-state",strlen("get-state"))) {

++        transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
++        char *state = connection_state_name(transport);
++        snprintf(buf, sizeof buf,

"OKAY%04x%s",(unsigned)strlen(state),state);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++ return -1;
++}
++
++#if !ADB_HOST
++int recovery_mode = 0;
++#endif
++
++int main(int argc, char **argv)
++{
++#if ADB_HOST

++    adb_sysdeps_init();
++    adb_trace_init();
++    D("Handling commandline()\n");
++    return adb_commandline(argc - 1, argv + 1);

++#else
++ /* If adbd runs inside the emulator this will enable adb tracing via
++ * adb-debug qemud service in the emulator. */
++ adb_qemu_trace_init();
++ if((argc > 1) && (!strcmp(argv[1],"recovery"))) {
++ adb_device_banner = "recovery";
++ recovery_mode = 1;
++ }
++

++    start_device_log();
++    D("Handling main()\n");
++    return adb_main(0, DEFAULT_ADB_PORT);
++#endif
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/adb.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb.h    2013-06-18

17:12:17.000000000 -0300
+@@ -0,0 +1,491 @@
++/*
++ * Copyright (C) 2007 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 __ADB_H
++#define __ADB_H
++
++#include <limits.h>
++
++#include "transport.h" /* readx(), writex() */
++
++#define MAX_PAYLOAD 4096
++
++#define A_SYNC 0x434e5953
++#define A_CNXN 0x4e584e43
++#define A_OPEN 0x4e45

#2 lore raw

What was broken in the version in SHR? It builds fine here.

Quoted 2,027 lines · Khem Raj

ping^1

Quoted 6 lines · Khem Raj

android tools offer filsystem tools for creating sparse images, so package them in package of its own.

Fix src uri to latest

Quoted 14 lines
---
 .../android-tools-conf/android-gadget-setup        |    25 +
 .../android-tools/android-tools-conf_1.0.bb        |    13 +
 .../adbd-disable-client-authentication.patch       |    16 +
 .../android-tools/android-tools/add_adbd.patch     | 20218
+++++++++++++++++++
 .../android-tools/android-tools-adbd.service       |    12 +
 .../android-tools/disable-selinux-support.patch    |   137 +
 .../android-tools/reboot-syscall.patch             |    25 +
 .../android-tools/remove-libselinux.patch          |    13 +
 .../android-tools/android-tools_4.2.2.bb           |    82 +
 9 files changed, 20541 insertions(+)
 create mode 100644

meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup

Quoted 4 lines
 create mode 100644 meta-oe/recipes-devtools/android-tools/
android-tools-conf_1.0.bb
 create mode 100644

meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch

Quoted 4 lines
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch
 create mode 100644

meta-oe/recipes-devtools/android-tools/android-tools/android-tools-adbd.service

Quoted 2 lines
 create mode 100644

meta-oe/recipes-devtools/android-tools/android-tools/disable-selinux-support.patch

Quoted 4 lines
 create mode 100644
meta-oe/recipes-devtools/android-tools/android-tools/reboot-syscall.patch
 create mode 100644

meta-oe/recipes-devtools/android-tools/android-tools/remove-libselinux.patch

Quoted 5 lines
 create mode 100644 meta-oe/recipes-devtools/android-tools/

android-tools_4.2.2.bb

diff --git

a/meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup

Quoted 1 line

b/meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup

Quoted 5 lines

new file mode 100644
index 0000000..f7d9973
--- /dev/null
+++

b/meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup

Quoted 15 lines
meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup new file +9 -0
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# TODO enable the lines below once we have support for getprop
+# retrieve the product info from Android
+# manufacturer=$(getprop ro.product.manufacturer Android)
+# model=$(getprop ro.product.model Android)
+# serial=$(getprop ro.serialno 0123456789ABCDEF)
+
+manufacturer="$(cat /system/build.prop | grep -o

'ro.product.manufacturer=.*' | cut -d'=' -f 2)"

(quoted diff) +2 -1
+model="$(cat /system/build.prop | grep -o 'ro.product.model=.*' | cut
-d'=' -f 2)"
+# get the device serial number from /proc/cmdline directly(since we have

no getprop on

Review

Quoted 2 lines
(quoted diff) +2 -0
+# GNU/Linux)
+serial="$(cat /proc/cmdline | sed 's/.*androidboot.serialno=//' | sed

's/

Quoted 36 lines

.*//')"

meta-oe/recipes-devtools/android-tools/android-tools-conf/android-gadget-setup new file +12 -0
+
+echo $serial > /sys/class/android_usb/android0/iSerial
+echo $manufacturer > /sys/class/android_usb/android0/iManufacturer
+echo $model > /sys/class/android_usb/android0/iProduct
+
+echo "0" > /sys/class/android_usb/android0/enable
+echo "18d1" > /sys/class/android_usbid_usb/android0/idVendor
+echo "D002" > /sys/class/android_usb/android0/idProduct
+echo "adb" > /sys/class/android_usb/android0/functions
+echo "1" >  /sys/class/android_usb/android0/enable
+
+sleep 4
(quoted diff) +0 -0

android-tools-conf_1.0.bb b/meta-oe/recipes-devtools/android-tools/ android-tools-conf_1.0.bb
new file mode 100644
index 0000000..af98f92

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +1 -0
@@ -0,0 +1,13 @@
+DESCRIPTION = "Different utilities from Android - corressponding

configuration files"

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +3 -0
+SECTION = "console/utils"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM =

"file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +9 -0
+
+SRC_URI = "file://android-gadget-setup"
+
+PACKAGE_ARCH = "${MACHINE_ARCH}"
+
+do_install() {
+    install -d ${D}${bindir}
+    install -m 0755 ${WORKDIR}/android-gadget-setup ${D}${bindir}
+}
Quoted 2 lines

diff --git

a/meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch

Quoted 1 line

b/meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch

Quoted 5 lines

new file mode 100644
index 0000000..9539160
--- /dev/null
+++

b/meta-oe/recipes-devtools/android-tools/android-tools/adbd-disable-client-authentication.patch

Quoted 451 lines
meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +1 -0
@@ -0,0 +1,16 @@
+--- android-tools-orig/core/adbd/adb_auth_client.c     2013-07-29

16:24:49.827822956 +0000
++++ android-tools/core/adbd/adb_auth_client.c 2013-07-29 16:25:29.931623038 +0000
+@@ -200,8 +200,11 @@

meta-oe/recipes-devtools/android-tools/android-tools-conf_1.0.bb new file +13 -0
+         return;
+     }
+
+-    fdevent_install(&t->auth_fde, framework_fd, adb_auth_event, t);
+-    fdevent_add(&t->auth_fde, FDE_READ);
++    // fdevent_install(&t->auth_fde, framework_fd, adb_auth_event, t);
++    // fdevent_add(&t->auth_fde, FDE_READ);
++
++    adb_auth_reload_keys();
++    adb_auth_verified(t);
+ }
+
+ static void adb_auth_listener(int fd, unsigned events, void *data)

diff --git a/meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch b/meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch new file mode 100644
index 0000000..561978f

meta-oe/recipes-devtools/android-tools/android-tools/add_adbd.patch new file +7 -0
@@ -0,0 +1,20218 @@
+## Description: add some description
+## Origin/Author: add some origin or author
+## Bug: bug URL
+Index: android-tools-4.2.2+git20130218/core/adbd/adb.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb.c    2013-06-18

17:12:17.000000000 -0300
+@@ -0,0 +1,1719 @@
++/*
++ * Copyright (C) 2007 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.
++ */
++
++#define TRACE_TAG TRACE_ADB
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <ctype.h>
++#include <stdarg.h>
++#include <errno.h>
++#include <stddef.h>
++#include <string.h>
++#include <time.h>
++#include <sys/time.h>
++#include <stdint.h>
++
++#include "sysdeps.h"
++#include "adb.h"
++#include "adb_auth.h"
++
++#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
++
++#if !ADB_HOST
++#include "android_filesystem_config.h"
++#include <linux/capability.h>
++#include <linux/prctl.h>
++#include <sys/mount.h>
++#else
++#include "usb_vendors.h"
++#endif
++
++#if ADB_TRACE
++ADB_MUTEX_DEFINE( D_lock );
++#endif
++
++int HOST = 0;
++int gListenAll = 0;
++
++static int auth_enabled = 0;
++
++#if !ADB_HOST
++static const char *adb_device_banner = "device";
++#endif
++
++void fatal(const char *fmt, ...)
++{

++    va_list ap;
++    va_start(ap, fmt);
++    fprintf(stderr, "error: ");
++    vfprintf(stderr, fmt, ap);
++    fprintf(stderr, "\n");
++    va_end(ap);
++    exit(-1);

++}
++
++void fatal_errno(const char *fmt, ...)
++{

++    va_list ap;
++    va_start(ap, fmt);
++    fprintf(stderr, "error: %s: ", strerror(errno));
++    vfprintf(stderr, fmt, ap);
++    fprintf(stderr, "\n");
++    va_end(ap);
++    exit(-1);

++}
++
++int adb_trace_mask;
++
++/* read a comma/space/colum/semi-column separated list of tags ++ * from the ADB_TRACE environment variable and build the trace ++ * mask from it. note that '1' and 'all' are special cases to ++ * enable all tracing
++ */
++void adb_trace_init(void)
++{

++    const char*  p = getenv("ADB_TRACE");
++    const char*  q;

++
++ static const struct {
++ const char* tag;
++ int flag;
++ } tags[] = {

++        { "1", 0 },
++        { "all", 0 },
++        { "adb", TRACE_ADB },
++        { "sockets", TRACE_SOCKETS },
++        { "packets", TRACE_PACKETS },
++        { "rwx", TRACE_RWX },
++        { "usb", TRACE_USB },
++        { "sync", TRACE_SYNC },
++        { "sysdeps", TRACE_SYSDEPS },
++        { "transport", TRACE_TRANSPORT },
++        { "jdwp", TRACE_JDWP },
++        { "services", TRACE_SERVICES },
++        { "auth", TRACE_AUTH },
++        { NULL, 0 }

++ };
++
++ if (p == NULL)
++ return;
++
++ /* use a comma/column/semi-colum/space separated list */
++ while (*p) {
++ int len, tagn;
++
++ q = strpbrk(p, " ,:;");
++ if (q == NULL) {
++ q = p + strlen(p);
++ }
++ len = q - p;
++
++ for (tagn = 0; tags[tagn].tag != NULL; tagn++)
++ {
++ int taglen = strlen(tags[tagn].tag);
++
++ if (len == taglen && !memcmp(tags[tagn].tag, p, len) )
++ {
++ int flag = tags[tagn].flag;
++ if (flag == 0) {
++ adb_trace_mask = ~0;
++ return;

++                }
++                adb_trace_mask |= (1 << flag);
++                break;
++            }
++        }
++        p = q;
++        if (*p)

++ p++;
++ }
++}
++
++#if !ADB_HOST
++/*
++ * Implements ADB tracing inside the emulator.
++ */
++
++#include <stdarg.h>
++
++/*
++ * Redefine open and write for qemu_pipe.h that contains inlined references
++ * to those routines. We will redifine them back after qemu_pipe.h inclusion.
++ */
++
++#undef open
++#undef write
++#define open adb_open
++#define write adb_write
++#include "qemu_pipe.h"
++#undef open
++#undef write
++#define open ___xxx_open
++#define write ___xxx_write
++
++/* A handle to adb-debug qemud service in the emulator. */
++int adb_debug_qemu = -1;
++
++/* Initializes connection with the adb-debug qemud service in the emulator. */
++static int adb_qemu_trace_init(void)
++{
++ char con_name[32];
++
++ if (adb_debug_qemu >= 0) {
++ return 0;
++ }
++

++    /* adb debugging QEMUD service connection request. */
++    snprintf(con_name, sizeof(con_name), "qemud:adb-debug");
++    adb_debug_qemu = qemu_pipe_open(con_name);
++    return (adb_debug_qemu >= 0) ? 0 : -1;

++}
++
++void adb_qemu_trace(const char* fmt, ...)
++{

++    va_list args;
++    va_start(args, fmt);
++    char msg[1024];

++
++ if (adb_debug_qemu >= 0) {
++ vsnprintf(msg, sizeof(msg), fmt, args);
++ adb_write(adb_debug_qemu, msg, strlen(msg));
++ }
++}
++#endif /* !ADB_HOST */
++
++apacket *get_apacket(void)
++{

++    apacket *p = malloc(sizeof(apacket));
++    if(p == 0) fatal("failed to allocate an apacket");
++    memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);
++    return p;

++}
++
++void put_apacket(apacket *p)
++{
++ free(p);
++}
++
++void handle_online(atransport *t)
++{
++ D("adb: online\n");
++ t->online = 1;
++}
++
++void handle_offline(atransport *t)
++{

++    D("adb: offline\n");
++    //Close the associated usb
++    t->online = 0;
++    run_transport_disconnects(t);

++}
++
++#if DEBUG_PACKETS
++#define DUMPMAX 32
++void print_packet(const char *label, apacket *p) ++{

++    char *tag;
++    char *x;
++    unsigned count;
++
++    switch(p->msg.command){
++    case A_SYNC: tag = "SYNC"; break;
++    case A_CNXN: tag = "CNXN" ; break;
++    case A_OPEN: tag = "OPEN"; break;
++    case A_OKAY: tag = "OKAY"; break;
++    case A_CLSE: tag = "CLSE"; break;
++    case A_WRTE: tag = "WRTE"; break;
++    case A_AUTH: tag = "AUTH"; break;
++    default: tag = "????"; break;
++    }
++
++    fprintf(stderr, "%s: %s %08x %08x %04x \"",
++            label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
++    count = p->msg.data_length;
++    x = (char*) p->data;
++    if(count > DUMPMAX) {

++ count = DUMPMAX;
++ tag = "\n";
++ } else {
++ tag = "\"\n";
++ }
++ while(count-- > 0){
++ if((*x >= ' ') && (*x < 127)) {
++ fputc(*x, stderr);
++ } else {
++ fputc('.', stderr);
++ }
++ x++;
++ }
++ fputs(tag, stderr);
++}
++#endif
++
++static void send_ready(unsigned local, unsigned remote, atransport *t) ++{

++    D("Calling send_ready \n");
++    apacket *p = get_apacket();
++    p->msg.command = A_OKAY;
++    p->msg.arg0 = local;
++    p->msg.arg1 = remote;
++    send_packet(p, t);

++}
++
++static void send_close(unsigned local, unsigned remote, atransport *t) ++{

++    D("Calling send_close \n");
++    apacket *p = get_apacket();
++    p->msg.command = A_CLSE;
++    p->msg.arg0 = local;
++    p->msg.arg1 = remote;
++    send_packet(p, t);

++}
++
++static size_t fill_connect_data(char *buf, size_t bufsize) ++{
++#if ADB_HOST
++ return snprintf(buf, bufsize, "host::") + 1;
++#else
++ static const char *cnxn_props[] = {

++        "ro.product.name",
++        "ro.product.model",
++        "ro.product.device",
++    };
++    static const int num_cnxn_props = ARRAY_SIZE(cnxn_props);
++    static const char *values[] = {
++        "occam",
++        "Nexus 4",
++        "mako",
++    };
++    int i;
++    size_t remaining = bufsize;
++    size_t len;
++
++    len = snprintf(buf, remaining, "%s::", adb_device_banner);
++    remaining -= len;
++    buf += len;
++    for (i = 0; i < num_cnxn_props; i++) {
++        char value[PROPERTY_VALUE_MAX];
++        //property_get(cnxn_props[i], value, "");
++        len = snprintf(buf, remaining, "%s=%s;", cnxn_props[i],

values[i]);
++ remaining -= len;
++ buf += len;
++ }
++
++ return bufsize - remaining + 1;
++#endif
++}
++
++static void send_connect(atransport *t)
++{

++    D("Calling send_connect \n");
++    apacket *cp = get_apacket();
++    cp->msg.command = A_CNXN;
++    cp->msg.arg0 = A_VERSION;
++    cp->msg.arg1 = MAX_PAYLOAD;
++    cp->msg.data_length = fill_connect_data((char *)cp->data,

++ sizeof(cp->data));
++ send_packet(cp, t);
++}
++
++static void send_auth_request(atransport *t)
++{

++    D("Calling send_auth_request\n");
++    apacket *p;
++    int ret;

++
++ ret = adb_auth_generate_token(t->token, sizeof(t->token));
++ if (ret != sizeof(t->token)) {
++ D("Error generating token ret=%d\n", ret);
++ return;
++ }
++

++    p = get_apacket();
++    memcpy(p->data, t->token, ret);
++    p->msg.command = A_AUTH;
++    p->msg.arg0 = ADB_AUTH_TOKEN;
++    p->msg.data_length = ret;
++    send_packet(p, t);

++}
++
++static void send_auth_response(uint8_t *token, size_t token_size, atransport *t)
++{

++    D("Calling send_auth_response\n");
++    apacket *p = get_apacket();
++    int ret;
++
++    ret = adb_auth_sign(t->key, token, token_size, p->data);
++    if (!ret) {
++        D("Error signing the token\n");
++        put_apacket(p);
++        return;
++    }
++
++    p->msg.command = A_AUTH;
++    p->msg.arg0 = ADB_AUTH_SIGNATURE;
++    p->msg.data_length = ret;
++    send_packet(p, t);

++}
++
++static void send_auth_publickey(atransport *t)
++{

++    D("Calling send_auth_publickey\n");
++    apacket *p = get_apacket();
++    int ret;
++
++    ret = adb_auth_get_userkey(p->data, sizeof(p->data));
++    if (!ret) {
++        D("Failed to get user public key\n");
++        put_apacket(p);
++        return;
++    }
++
++    p->msg.command = A_AUTH;
++    p->msg.arg0 = ADB_AUTH_RSAPUBLICKEY;
++    p->msg.data_length = ret;
++    send_packet(p, t);

++}
++
++void adb_auth_verified(atransport *t)
++{
++ handle_online(t);
++ send_connect(t);
++}
++
++static char *connection_state_name(atransport *t) ++{
++ if (t == NULL) {
++ return "unknown";
++ }
++
++ switch(t->connection_state) {
++ case CS_BOOTLOADER:
++ return "bootloader";
++ case CS_DEVICE:
++ return "device";
++ case CS_OFFLINE:

Quoted 8 lines

++ return "offline";
++ default:
++ return "unknown";
++ }
++}
++
++/* qual_overwrite is used to overwrite a qualifier string. dst is a ++ * pointer to a char pointer. It is assumed that if *dst is non-NULL,

it

Quoted 123 lines

++ * was malloc'ed and needs to freed. *dst will be set to a dup of src. ++ */
++static void qual_overwrite(char **dst, const char *src)
++{
++ if (!dst)
++ return;
++
++ free(*dst);
++ *dst = NULL;
++
++ if (!src || !*src)
++ return;
++
++ *dst = strdup(src);
++}
++
++void parse_banner(char *banner, atransport *t)
++{

++    static const char *prop_seps = ";";
++    static const char key_val_sep = '=';
++    char *cp;
++    char *type;
++
++    D("parse_banner: %s\n", banner);
++    type = banner;
++    cp = strchr(type, ':');
++    if (cp) {
++        *cp++ = 0;
++        /* Nothing is done with second field. */
++        cp = strchr(cp, ':');
++        if (cp) {
++            char *save;
++            char *key;
++            key = adb_strtok_r(cp + 1, prop_seps, &save);
++            while (key) {

++ cp = strchr(key, key_val_sep);
++ if (cp) {
++ *cp++ = '\0';
++ if (!strcmp(key, "ro.product.name"))
++ qual_overwrite(&t->product, cp);
++ else if (!strcmp(key, "ro.product.model"))
++ qual_overwrite(&t->model, cp);
++ else if (!strcmp(key, "ro.product.device"))
++ qual_overwrite(&t->device, cp);
++ }
++ key = adb_strtok_r(NULL, prop_seps, &save);
++ }
++ }
++ }
++
++ if(!strcmp(type, "bootloader")){

++        D("setting connection_state to CS_BOOTLOADER\n");
++        t->connection_state = CS_BOOTLOADER;
++        update_transports();
++        return;
++    }
++
++    if(!strcmp(type, "device")) {
++        D("setting connection_state to CS_DEVICE\n");
++        t->connection_state = CS_DEVICE;
++        update_transports();
++        return;
++    }
++
++    if(!strcmp(type, "recovery")) {
++        D("setting connection_state to CS_RECOVERY\n");
++        t->connection_state = CS_RECOVERY;
++        update_transports();
++        return;
++    }
++
++    if(!strcmp(type, "sideload")) {
++        D("setting connection_state to CS_SIDELOAD\n");
++        t->connection_state = CS_SIDELOAD;
++        update_transports();
++        return;

++ }
++
++ t->connection_state = CS_HOST;
++}
++
++void handle_packet(apacket *p, atransport *t)
++{
++ asocket *s;
++
++ D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0],

++            ((char*) (&(p->msg.command)))[1],
++            ((char*) (&(p->msg.command)))[2],
++            ((char*) (&(p->msg.command)))[3]);

++ print_packet("recv", p);
++
++ switch(p->msg.command){
++ case A_SYNC:
++ if(p->msg.arg0){
++ send_packet(p, t);
++ if(HOST) send_connect(t);
++ } else {

++            t->connection_state = CS_OFFLINE;
++            handle_offline(t);
++            send_packet(p, t);

++ }
++ return;
++
++ case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */
++ /* XXX verify version, etc */
++ if(t->connection_state != CS_OFFLINE) {
++ t->connection_state = CS_OFFLINE;
++ handle_offline(t);
++ }
++
++ parse_banner((char*) p->data, t);
++
++ if (HOST || !auth_enabled) {
++ handle_online(t);
++ if(!HOST) send_connect(t);
++ } else {
++ send_auth_request(t);
++ }
++ break;
++
++ case A_AUTH:
++ if (p->msg.arg0 == ADB_AUTH_TOKEN) {
++ t->key = adb_auth_nextkey(t->key);

Quoted 8 lines

++ if (t->key) {
++ send_auth_response(p->data, p->msg.data_length, t);
++ } else {
++ /* No more private keys to try, send the public key */
++ send_auth_publickey(t);
++ }
++ } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) {
++ if (adb_auth_verify(t->token, p->data,

p->msg.data_length)) {

Quoted 166 lines

++ adb_auth_verified(t);
++ t->failed_auth_attempts = 0;
++ } else {
++ if (t->failed_auth_attempts++ > 10)
++ adb_sleep_ms(1000);
++ send_auth_request(t);
++ }
++ } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) {
++ adb_auth_confirm_key(p->data, p->msg.data_length, t);
++ }
++ break;
++
++ case A_OPEN: /* OPEN(local-id, 0, "destination") */
++ if (t->online) {
++ char *name = (char*) p->data;
++ name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] =
0;
++ s = create_local_service_socket(name);
++ if(s == 0) {
++ send_close(0, p->msg.arg0, t);
++ } else {

++                s->peer = create_remote_socket(p->msg.arg0, t);
++                s->peer->peer = s;
++                send_ready(s->id, s->peer->id, t);
++                s->ready(s);

++ }
++ }
++ break;
++
++ case A_OKAY: /* READY(local-id, remote-id, "") */
++ if (t->online) {
++ if((s = find_local_socket(p->msg.arg1))) {
++ if(s->peer == 0) {
++ s->peer = create_remote_socket(p->msg.arg0, t);
++ s->peer->peer = s;
++ }
++ s->ready(s);
++ }
++ }
++ break;
++
++ case A_CLSE: /* CLOSE(local-id, remote-id, "") */
++ if (t->online) {
++ if((s = find_local_socket(p->msg.arg1))) {
++ s->close(s);
++ }
++ }
++ break;
++
++ case A_WRTE:
++ if (t->online) {
++ if((s = find_local_socket(p->msg.arg1))) {
++ unsigned rid = p->msg.arg0;
++ p->len = p->msg.data_length;
++
++ if(s->enqueue(s, p) == 0) {
++ D("Enqueue the socket\n");
++ send_ready(s->id, rid, t);
++ }
++ return;
++ }
++ }
++ break;
++
++ default:
++ printf("handle_packet: what is %08x?!\n", p->msg.command);
++ }
++
++ put_apacket(p);
++}
++
++alistener listener_list = {
++ .next = &listener_list,
++ .prev = &listener_list,
++};
++
++static void ss_listener_event_func(int _fd, unsigned ev, void *_l) ++{
++ asocket *s;
++
++ if(ev & FDE_READ) {

++        struct sockaddr addr;
++        socklen_t alen;
++        int fd;
++
++        alen = sizeof(addr);
++        fd = adb_socket_accept(_fd, &addr, &alen);
++        if(fd < 0) return;

++
++ adb_socket_setbufsize(fd, CHUNK_SIZE);
++
++ s = create_local_socket(fd);
++ if(s) {
++ connect_to_smartsocket(s);
++ return;
++ }
++
++ adb_close(fd);
++ }
++}
++
++static void listener_event_func(int _fd, unsigned ev, void *_l) ++{
++ alistener *l = _l;
++ asocket *s;
++
++ if(ev & FDE_READ) {

++        struct sockaddr addr;
++        socklen_t alen;
++        int fd;
++
++        alen = sizeof(addr);
++        fd = adb_socket_accept(_fd, &addr, &alen);
++        if(fd < 0) return;
++
++        s = create_local_socket(fd);
++        if(s) {
++            s->transport = l->transport;
++            connect_to_remote(s, l->connect_to);
++            return;

++ }
++
++ adb_close(fd);
++ }
++}
++
++static void free_listener(alistener* l)
++{
++ if (l->next) {

++        l->next->prev = l->prev;
++        l->prev->next = l->next;
++        l->next = l->prev = l;

++ }
++
++ // closes the corresponding fd
++ fdevent_remove(&l->fde);
++
++ if (l->local_name)
++ free((char*)l->local_name);
++
++ if (l->connect_to)
++ free((char*)l->connect_to);
++
++ if (l->transport) {
++ remove_transport_disconnect(l->transport, &l->disconnect);
++ }
++ free(l);
++}
++
++static void listener_disconnect(void* _l, atransport* t) ++{
++ alistener* l = _l;
++
++ free_listener(l);
++}
++
++int local_name_to_fd(const char *name)
++{
++ int port;
++
++ if(!strncmp("tcp:", name, 4)){
++ int ret;
++ port = atoi(name + 4);
++
++ if (gListenAll > 0) {
++ ret = socket_inaddr_any_server(port, SOCK_STREAM);

Quoted 8 lines

++ } else {
++ ret = socket_loopback_server(port, SOCK_STREAM);
++ }
++
++ return ret;
++ }
++#ifndef HAVE_WIN32_IPC /* no Unix-domain sockets on Win32 */
++ // It's non-sensical to support the "reserved" space on the adb

host

Quoted 11 lines

side
++ if(!strncmp(name, "local:", 6)) {
++ return socket_local_server(name + 6,
++ ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
++ } else if(!strncmp(name, "localabstract:", 14)) {
++ return socket_local_server(name + 14,
++ ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
++ } else if(!strncmp(name, "localfilesystem:", 16)) {
++ return socket_local_server(name + 16,
++ ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
++ }

Quoted 8 lines

++
++#endif
++ printf("unknown local portname '%s'\n", name);
++ return -1;
++}
++
++// Write a single line describing a listener to a user-provided buffer. ++// Appends a trailing zero, even in case of truncation, but the

function

Quoted 40 lines

++// returns the full line length.
++// If |buffer| is NULL, does not write but returns required size. ++static int format_listener(alistener* l, char* buffer, size_t buffer_len) {

++    // Format is simply:
++    //
++    //  <device-serial> " " <local-name> " " <remote-name> "\n"
++    //
++    int local_len = strlen(l->local_name);
++    int connect_len = strlen(l->connect_to);
++    int serial_len = strlen(l->transport->serial);

++
++ if (buffer != NULL) {
++ snprintf(buffer, buffer_len, "%s %s %s\n",
++ l->transport->serial, l->local_name, l->connect_to);

++    }
++    // NOTE: snprintf() on Windows returns -1 in case of truncation, so
++    // return the computed line length instead.
++    return local_len + connect_len + serial_len + 3;

++}
++
++// Write the list of current listeners (network redirections) into a ++// user-provided buffer. Appends a trailing zero, even in case of ++// trunctaion, but return the full size in bytes.
++// If |buffer| is NULL, does not write but returns required size. ++static int format_listeners(char* buf, size_t buflen)
++{

++    alistener* l;
++    int result = 0;
++    for (l = listener_list.next; l != &listener_list; l = l->next) {
++        // Ignore special listeners like those for *smartsocket*
++        if (l->connect_to[0] == '*')
++          continue;
++        int len = format_listener(l, buf, buflen);
++        // Ensure there is space for the trailing zero.
++        result += len;
++        if (buf != NULL) {
++          buf += len;
++          buflen -= len;
++          if (buflen <= 0)
Quoted 7 lines

++ break;
++ }
++ }
++ return result;
++}
++
++static int remove_listener(const char *local_name, atransport*

transport)

Quoted 53 lines

++{
++ alistener *l;
++
++ for (l = listener_list.next; l != &listener_list; l = l->next) {
++ if (!strcmp(local_name, l->local_name)) {
++ listener_disconnect(l, l->transport);
++ return 0;
++ }
++ }
++ return -1;
++}
++
++static void remove_all_listeners(void)
++{
++ alistener *l, *l_next;
++ for (l = listener_list.next; l != &listener_list; l = l_next) {

++        l_next = l->next;
++        // Never remove smart sockets.
++        if (l->connect_to[0] == '*')

++ continue;
++ listener_disconnect(l, l->transport);
++ }
++}
++
++// error/status codes for install_listener.
++typedef enum {

++  INSTALL_STATUS_OK = 0,
++  INSTALL_STATUS_INTERNAL_ERROR = -1,
++  INSTALL_STATUS_CANNOT_BIND = -2,
++  INSTALL_STATUS_CANNOT_REBIND = -3,
++} install_status_t;
++
++static install_status_t install_listener(const char *local_name,
++                                         const char *connect_to,
++                                         atransport* transport,
++                                         int no_rebind)

++{
++ alistener *l;
++
++ printf("install_listener('%s','%s')\n", local_name, connect_to);
++
++ for(l = listener_list.next; l != &listener_list; l = l->next){
++ if(strcmp(local_name, l->local_name) == 0) {
++ char *cto;
++
++ /* can't repurpose a smartsocket */
++ if(l->connect_to[0] == '*') {
++ return INSTALL_STATUS_INTERNAL_ERROR;
++ }
++
++ /* can't repurpose a listener if 'no_rebind' is true */
++ if (no_rebind) {
++ return INSTALL_STATUS_CANNOT_REBIND;

Quoted 8 lines

++ }
++
++ cto = strdup(connect_to);
++ if(cto == 0) {
++ return INSTALL_STATUS_INTERNAL_ERROR;
++ }
++
++ //printf("rebinding '%s' to '%s'\n", local_name,

connect_to);

Quoted 95 lines
++            free((void*) l->connect_to);
++            l->connect_to = cto;
++            if (l->transport != transport) {

++ remove_transport_disconnect(l->transport,
&l->disconnect);
++ l->transport = transport;
++ add_transport_disconnect(l->transport, &l->disconnect);
++ }
++ return INSTALL_STATUS_OK;
++ }
++ }
++

++    if((l = calloc(1, sizeof(alistener))) == 0) goto nomem;
++    if((l->local_name = strdup(local_name)) == 0) goto nomem;
++    if((l->connect_to = strdup(connect_to)) == 0) goto nomem;

++
++
++ l->fd = local_name_to_fd(local_name);
++ if(l->fd < 0) {

++        free((void*) l->local_name);
++        free((void*) l->connect_to);
++        free(l);
++        printf("cannot bind '%s'\n", local_name);
++        return -2;

++ }
++
++ close_on_exec(l->fd);
++ if(!strcmp(l->connect_to, "*smartsocket*")) {
++ fdevent_install(&l->fde, l->fd, ss_listener_event_func, l);
++ } else {
++ fdevent_install(&l->fde, l->fd, listener_event_func, l);
++ }
++ fdevent_set(&l->fde, FDE_READ);
++

++    l->next = &listener_list;
++    l->prev = listener_list.prev;
++    l->next->prev = l;
++    l->prev->next = l;
++    l->transport = transport;
++
++    if (transport) {
++        l->disconnect.opaque = l;
++        l->disconnect.func   = listener_disconnect;
++        add_transport_disconnect(transport, &l->disconnect);

++ }
++ return INSTALL_STATUS_OK;
++
++nomem:
++ fatal("cannot allocate listener");
++ return INSTALL_STATUS_INTERNAL_ERROR;
++}
++
++#ifdef HAVE_WIN32_PROC
++static BOOL WINAPI ctrlc_handler(DWORD type)
++{
++ exit(STATUS_CONTROL_C_EXIT);
++ return TRUE;
++}
++#endif
++
++static void adb_cleanup(void)
++{
++ usb_cleanup();
++}
++
++void start_logging(void)
++{
++#ifdef HAVE_WIN32_PROC

++    char    temp[ MAX_PATH ];
++    FILE*   fnul;
++    FILE*   flog;

++
++ GetTempPath( sizeof(temp) - 8, temp );
++ strcat( temp, "adb.log" );
++

++    /* Win32 specific redirections */
++    fnul = fopen( "NUL", "rt" );
++    if (fnul != NULL)

++ stdin[0] = fnul[0];
++
++ flog = fopen( temp, "at" );
++ if (flog == NULL)
++ flog = fnul;
++
++ setvbuf( flog, NULL, _IONBF, 0 );
++

++    stdout[0] = flog[0];
++    stderr[0] = flog[0];
++    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
++#else
++    int fd;
++
++    fd = unix_open("/dev/null", O_RDONLY);
++    dup2(fd, 0);
++    adb_close(fd);
Quoted 2 lines

++
++ fd = unix_open("/tmp/adb.log", O_WRONLY | O_CREAT | O_APPEND,

0640);

Quoted 76 lines

++ if(fd < 0) {
++ fd = unix_open("/dev/null", O_WRONLY);

++    }
++    dup2(fd, 1);
++    dup2(fd, 2);
++    adb_close(fd);
++    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());

++#endif
++}
++
++#if !ADB_HOST
++void start_device_log(void)
++{

++    int fd;
++    char    path[PATH_MAX];
++    struct tm now;
++    time_t t;
++    char value[PROPERTY_VALUE_MAX];
++
++    // read the trace mask from persistent property
persist.adb.trace_mask
++    // give up if the property is not set or cannot be parsed
++    //property_get("persist.adb.trace_mask", value, "");
++    //if (sscanf(value, "%x", &adb_trace_mask) != 1)
++    return;
++
++    adb_mkdir("/data/adb", 0775);
++    tzset();
++    time(&t);
++    localtime_r(&t, &now);
++    strftime(path, sizeof(path),

++ "/data/adb/adb-%Y-%m-%d-%H-%M-%S.txt",
++ &now);
++ fd = unix_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0640);
++ if (fd < 0)
++ return;
++

++    // redirect stdout and stderr to the log file
++    dup2(fd, 1);
++    dup2(fd, 2);
++    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
++    adb_close(fd);
++
++    fd = unix_open("/dev/null", O_RDONLY);
++    dup2(fd, 0);
++    adb_close(fd);

++}
++#endif
++
++#if ADB_HOST
++int launch_server(int server_port)
++{
++#ifdef HAVE_WIN32_PROC
++ /* we need to start the server in the background
*/
++ /* we create a PIPE that will be used to wait for the server's "OK"
*/
++ /* message since the pipe handles must be inheritable, we use a
*/
++ /* security attribute
*/

++    HANDLE                pipe_read, pipe_write;
++    HANDLE                stdout_handle, stderr_handle;
++    SECURITY_ATTRIBUTES   sa;
++    STARTUPINFO           startup;
++    PROCESS_INFORMATION   pinfo;
++    char                  program_path[ MAX_PATH ];
++    int                   ret;
++
++    sa.nLength = sizeof(sa);
++    sa.lpSecurityDescriptor = NULL;
++    sa.bInheritHandle = TRUE;
++
++    /* create pipe, and ensure its read handle isn't inheritable */
++    ret = CreatePipe( &pipe_read, &pipe_write, &sa, 0 );
++    if (!ret) {
Quoted 10 lines

++ fprintf(stderr, "CreatePipe() failure, error %ld\n",
GetLastError() );
++ return -1;
++ }
++
++ SetHandleInformation( pipe_read, HANDLE_FLAG_INHERIT, 0 );
++
++ /* Some programs want to launch an adb command and collect its
output by
++ * calling CreateProcess with inheritable stdout/stderr handles,

then

Quoted 3 lines

++ * using read() to get its output. When this happens, the
stdout/stderr
++ * handles passed to the adb client process will also be

inheritable.

Quoted 10 lines

++ * When starting the adb server here, care must be taken to reset
them
++ * to non-inheritable.
++ * Otherwise, something bad happens: even if the adb command
completes,
++ * the calling process is stuck while read()-ing from the
stdout/stderr
++ * descriptors, because they're connected to corresponding handles
in the
++ * adb server process (even if the latter never uses/writes to

them).

Quoted 16 lines

++ */

++    stdout_handle = GetStdHandle( STD_OUTPUT_HANDLE );
++    stderr_handle = GetStdHandle( STD_ERROR_HANDLE );
++    if (stdout_handle != INVALID_HANDLE_VALUE) {

++ SetHandleInformation( stdout_handle, HANDLE_FLAG_INHERIT, 0 );
++ }
++ if (stderr_handle != INVALID_HANDLE_VALUE) {
++ SetHandleInformation( stderr_handle, HANDLE_FLAG_INHERIT, 0 );
++ }
++

++    ZeroMemory( &startup, sizeof(startup) );
++    startup.cb = sizeof(startup);
++    startup.hStdInput  = GetStdHandle( STD_INPUT_HANDLE );
++    startup.hStdOutput = pipe_write;
++    startup.hStdError  = GetStdHandle( STD_ERROR_HANDLE );
++    startup.dwFlags    = STARTF_USESTDHANDLES;
Quoted 11 lines

++
++ ZeroMemory( &pinfo, sizeof(pinfo) );
++
++ /* get path of current program */
++ GetModuleFileName( NULL, program_path, sizeof(program_path) );
++
++ ret = CreateProcess(
++ program_path, /* program path
*/
++ "adb fork-server server",
++ /* the fork-server argument will

set

Quoted 4 lines

the
++ debug = 2 in the child
*/
++ NULL, /* process handle is not

inheritable

Quoted 2 lines

*/
++ NULL, /* thread handle is not

inheritable

Quoted 30 lines

*/
++ TRUE, /* yes, inherit some handles
*/
++ DETACHED_PROCESS, /* the new process doesn't have a console
*/
++ NULL, /* use parent's environment block
*/
++ NULL, /* use parent's starting directory
*/
++ &startup, /* startup info, i.e. std handles
*/
++ &pinfo );
++
++ CloseHandle( pipe_write );
++
++ if (!ret) {
++ fprintf(stderr, "CreateProcess failure, error %ld\n",
GetLastError() );
++ CloseHandle( pipe_read );
++ return -1;
++ }
++
++ CloseHandle( pinfo.hProcess );
++ CloseHandle( pinfo.hThread );
++
++ /* wait for the "OK\n" message */
++ {
++ char temp[3];
++ DWORD count;
++

Quoted 8 lines
++        ret = ReadFile( pipe_read, temp, 3, &count, NULL );
++        CloseHandle( pipe_read );
++        if ( !ret ) {

++ fprintf(stderr, "could not read ok from ADB Server, error =
%ld\n", GetLastError() );
++ return -1;
++ }
++ if (count != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2]

!=

Quoted 160 lines

'\n') {
++ fprintf(stderr, "ADB server didn't ACK\n" );
++ return -1;
++ }
++ }
++#elif defined(HAVE_FORKEXEC)

++    char    path[PATH_MAX];
++    int     fd[2];

++
++ // set up a pipe so the child can tell us when it is ready.
++ // fd[0] will be parent's end, and fd[1] will get mapped to stderr
in the child.
++ if (pipe(fd)) {
++ fprintf(stderr, "pipe failed in launch_server, errno: %d\n",
errno);
++ return -1;

++    }
++    get_my_path(path, PATH_MAX);
++    pid_t pid = fork();
++    if(pid < 0) return -1;

++
++ if (pid == 0) {
++ // child side of the fork
++
++ // redirect stderr to the pipe
++ // we use stderr instead of stdout due to stdout's buffering
behavior.

++        adb_close(fd[0]);
++        dup2(fd[1], STDERR_FILENO);
++        adb_close(fd[1]);
++
++        char str_port[30];
++        snprintf(str_port, sizeof(str_port), "%d",  server_port);
++        // child process
++        int result = execl(path, "adb", "-P", str_port, "fork-server",

"server", NULL);
++ // this should not return
++ fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result,
errno);
++ } else {
++ // parent side of the fork
++
++ char temp[3];
++

++        temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';
++        // wait for the "OK\n" message
++        adb_close(fd[1]);
++        int ret = adb_read(fd[0], temp, 3);
++        int saved_errno = errno;
++        adb_close(fd[0]);
++        if (ret < 0) {

++ fprintf(stderr, "could not read ok from ADB Server, errno =
%d\n", saved_errno);
++ return -1;
++ }
++ if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] !=
'\n') {
++ fprintf(stderr, "ADB server didn't ACK\n" );
++ return -1;
++ }
++
++ setsid();
++ }
++#else
++#error "cannot implement background server start on this platform" ++#endif
++ return 0;
++}
++#endif
++
++/* Constructs a local name of form tcp:port.
++ * target_str points to the target string, it's content will be overwritten.
++ * target_size is the capacity of the target string.
++ * server_port is the port number to use for the local name. ++ */
++void build_local_name(char* target_str, size_t target_size, int server_port)
++{
++ snprintf(target_str, target_size, "tcp:%d", server_port); ++}
++
++#if !ADB_HOST
++static int should_drop_privileges() {
++#ifndef ALLOW_ADBD_ROOT
++ return 1;
++#else /* ALLOW_ADBD_ROOT */
++ int secure = 0;
++ char value[PROPERTY_VALUE_MAX];
++
++ return 0;
++ /* run adbd in secure mode if ro.secure is set and
++ ** we are not in the emulator
++ */
++// property_get("ro.kernel.qemu", value, "");
++ if (strcmp(value, "1") != 0) {
++// property_get("ro.secure", value, "1");
++ if (strcmp(value, "1") == 0) {
++ // don't run as root if ro.secure is set...
++ secure = 1;
++
++ // ... except we allow running as root in userdebug builds
if the
++ // service.adb.root property has been set by the "adb root"
command
++// property_get("ro.debuggable", value, "");
++ if (strcmp(value, "1") == 0) {
++// property_get("service.adb.root", value, "");
++ if (strcmp(value, "1") == 0) {
++ secure = 0;
++ }
++ }
++ }
++ }
++ return secure;
++#endif /* ALLOW_ADBD_ROOT */
++}
++#endif /* !ADB_HOST */
++
++int adb_main(int is_daemon, int server_port)
++{
++#if !ADB_HOST
++ int port;
++ char value[PROPERTY_VALUE_MAX];
++
++ umask(000);
++#endif
++
++ atexit(adb_cleanup);
++#ifdef HAVE_WIN32_PROC
++ SetConsoleCtrlHandler( ctrlc_handler, TRUE );
++#elif defined(HAVE_FORKEXEC)
++ // No SIGCHLD. Let the service subproc handle its children.
++ signal(SIGPIPE, SIG_IGN);
++#endif
++
++ init_transport_registration();
++
++#if ADB_HOST

++    HOST = 1;
++    usb_vendors_init();
++    usb_init();
++    local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
++    adb_auth_init();
++
++    char local_name[30];
++    build_local_name(local_name, sizeof(local_name), server_port);
++    if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
++        exit(1);
++    }
++#else
++    //property_get("ro.adb.secure", value, "0");
++    auth_enabled = 0;//!strcmp(value, "1");
++    if (auth_enabled)
++        adb_auth_init();
++
++    // Our external storage path may be different than apps, since
++    // we aren't able to bind mount after dropping root.
++    const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");
++    if (NULL != adb_external_storage) {
Quoted 8 lines

++ setenv("EXTERNAL_STORAGE", adb_external_storage, 1);
++ } else {
++ D("Warning: ADB_EXTERNAL_STORAGE is not set. Leaving
EXTERNAL_STORAGE"
++ " unchanged.\n");
++ }
++
++ /* don't listen on a port (default 5037) if running in secure mode

*/

Quoted 56 lines

++ /* don't run as root if we are running in secure mode */
++ if (should_drop_privileges()) {
++ struct __user_cap_header_struct header;
++ struct __user_cap_data_struct cap[2];
++
++ if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) != 0) {
++ exit(1);
++ }
++

++        /* add extra groups:
++        ** AID_ADB to access the USB driver
++        ** AID_LOG to read system logs (adb logcat)
++        ** AID_INPUT to diagnose input issues (getevent)
++        ** AID_INET to diagnose network issues (netcfg, ping)
++        ** AID_GRAPHICS to access the frame buffer
++        ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth
(hcidump)
++        ** AID_SDCARD_R to allow reading from the SD card
++        ** AID_SDCARD_RW to allow writing to the SD card
++        ** AID_MOUNT to allow unmounting the SD card before rebooting
++        ** AID_NET_BW_STATS to read out qtaguid statistics
++        */
++        gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET,

AID_GRAPHICS,
++ AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R,
AID_SDCARD_RW,
++ AID_MOUNT, AID_NET_BW_STATS };
++ if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {
++ exit(1);
++ }
++
++ /* then switch user and group to "shell" */
++ if (setgid(AID_SHELL) != 0) {
++ exit(1);
++ }
++ if (setuid(AID_SHELL) != 0) {
++ exit(1);
++ }
++
++ memset(&header, 0, sizeof(header));
++ memset(cap, 0, sizeof(cap));
++

++        /* set CAP_SYS_BOOT capability, so "adb reboot" will succeed */
++        header.version = _LINUX_CAPABILITY_VERSION_3;
++        header.pid = 0;
++        cap[CAP_TO_INDEX(CAP_SYS_BOOT)].effective |=

CAP_TO_MASK(CAP_SYS_BOOT);
++ cap[CAP_TO_INDEX(CAP_SYS_BOOT)].permitted |=
CAP_TO_MASK(CAP_SYS_BOOT);
++ capset(&header, cap);
++
++ D("Local port disabled\n");
++ } else {

++        char local_name[30];
++        build_local_name(local_name, sizeof(local_name), server_port);
++        if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
Quoted 6 lines

++ exit(1);
++ }
++ }
++
++ int usb = 0;
++ if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0,

F_OK)

Quoted 8 lines

== 0) {

++        // listen on USB
++        usb_init();
++        usb = 1;

++ }
++
++ // If one of these properties is set, also listen on that port
++ // If one of the properties isn't set and we couldn't listen on

usb,

Quoted 8 lines
++    // listen on the default port.
++    //property_get("service.adb.tcp.port", value, "");
++    //if (!value[0]) {
++        //property_get("persist.adb.tcp.port", value, "");
++    //}
++    //if (sscanf(value, "%d", &port) == 1 && port > 0) {
++    //    printf("using port=%d\n", port);

++ // listen on TCP port specified by service.adb.tcp.port

property

Quoted 11 lines
++    //    local_init(port);
++    //} else
++    if (!usb) {
++        printf("Using USB\n");
++        // listen on default port
++        local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
++    }
++
++    D("adb_main(): pre init_jdwp()\n");
++    init_jdwp();
++    D("adb_main(): post init_jdwp()\n");
Quoted 8 lines

++#endif
++
++ if (is_daemon)
++ {
++ // inform our parent that we are up and running.
++#ifdef HAVE_WIN32_PROC
++ DWORD count;
++ WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3,

&count,

Quoted 28 lines

NULL );
++#elif defined(HAVE_FORKEXEC)
++ fprintf(stderr, "OK\n");
++#endif
++ start_logging();
++ }
++ D("Event loop starting\n");
++
++ fdevent_loop();
++
++ usb_cleanup();
++
++ return 0;
++}
++
++#if ADB_HOST
++void connect_device(char* host, char* buffer, int buffer_size) ++{

++    int port, fd;
++    char* portstr = strchr(host, ':');
++    char hostbuf[100];
++    char serial[100];

++
++ strncpy(hostbuf, host, sizeof(hostbuf) - 1);
++ if (portstr) {
++ if (portstr - host >= (ptrdiff_t)sizeof(hostbuf)) {
++ snprintf(buffer, buffer_size, "bad host name %s", host);
++ return;

Quoted 5 lines
++        }
++        // zero terminate the host at the point we found the colon
++        hostbuf[portstr - host] = 0;
++        if (sscanf(portstr + 1, "%d", &port) == 0) {

++ snprintf(buffer, buffer_size, "bad port number %s",

portstr);

Quoted 9 lines

++ return;
++ }
++ } else {
++ port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
++ }
++
++ snprintf(serial, sizeof(serial), "%s:%d", hostbuf, port);
++ if (find_transport(serial)) {
++ snprintf(buffer, buffer_size, "already connected to %s",

serial);

Quoted 44 lines

++ return;
++ }
++
++ fd = socket_network_client(hostbuf, port, SOCK_STREAM);
++ if (fd < 0) {
++ snprintf(buffer, buffer_size, "unable to connect to %s:%d",
host, port);
++ return;
++ }
++

++    D("client: connected on remote on fd %d\n", fd);
++    close_on_exec(fd);
++    disable_tcp_nagle(fd);
++    register_socket_transport(fd, serial, port, 0);
++    snprintf(buffer, buffer_size, "connected to %s", serial);

++}
++
++void connect_emulator(char* port_spec, char* buffer, int buffer_size) ++{
++ char* port_separator = strchr(port_spec, ',');
++ if (!port_separator) {
++ snprintf(buffer, buffer_size,
++ "unable to parse '%s' as <console port>,<adb port>",
++ port_spec);
++ return;
++ }
++
++ // Zero-terminate console port and make port_separator point to 2nd
port.

++    *port_separator++ = 0;
++    int console_port = strtol(port_spec, NULL, 0);
++    int adb_port = strtol(port_separator, NULL, 0);
++    if (!(console_port > 0 && adb_port > 0)) {

++ *(port_separator - 1) = ',';
++ snprintf(buffer, buffer_size,
++ "Invalid port numbers: Expected positive numbers, got
'%s'",
++ port_spec);
++ return;
++ }
++
++ /* Check if the emulator is already known.
++ * Note: There's a small but harmless race condition here: An
emulator not

Quoted 3 lines
++     * present just yet could be registered by another invocation right
++     * after doing this check here. However, local_connect protects
++     * against double-registration too. From here, a better error

message

Quoted 3 lines

++ * can be produced. In the case of the race condition, the very
specific
++ * error message won't be shown, but the data doesn't get

corrupted.

Quoted 42 lines

*/
++ atransport* known_emulator =
find_emulator_transport_by_adb_port(adb_port);
++ if (known_emulator != NULL) {
++ snprintf(buffer, buffer_size,
++ "Emulator on port %d already registered.", adb_port);
++ return;
++ }
++
++ /* Check if more emulators can be registered. Similar unproblematic
++ * race condition as above. */
++ int candidate_slot = get_available_local_transport_index();
++ if (candidate_slot < 0) {
++ snprintf(buffer, buffer_size, "Cannot accept more emulators.");
++ return;
++ }
++
++ /* Preconditions met, try to connect to the emulator. */
++ if (!local_connect_arbitrary_ports(console_port, adb_port)) {
++ snprintf(buffer, buffer_size,
++ "Connected to emulator on ports %d,%d", console_port,
adb_port);
++ } else {
++ snprintf(buffer, buffer_size,
++ "Could not connect to emulator on ports %d,%d",
++ console_port, adb_port);
++ }
++}
++#endif
++
++int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s)
++{
++ atransport *transport = NULL;
++ char buf[4096];
++
++ if(!strcmp(service, "kill")) {

++        fprintf(stderr,"adb server killed by remote request\n");
++        fflush(stdout);
++        adb_write(reply_fd, "OKAY", 4);
++        usb_cleanup();
++        exit(0);
Quoted 16 lines

++ }
++
++#if ADB_HOST
++ // "transport:" is used for switching transport with a specified
serial number
++ // "transport-usb:" is used for switching transport to the only USB
transport
++ // "transport-local:" is used for switching transport to the only
local transport
++ // "transport-any:" is used for switching transport to the only
transport
++ if (!strncmp(service, "transport", strlen("transport"))) {
++ char* error_string = "unknown failure";
++ transport_type type = kTransportAny;
++
++ if (!strncmp(service, "transport-usb",

strlen("transport-usb")))

Quoted 96 lines

{
++ type = kTransportUsb;
++ } else if (!strncmp(service, "transport-local",
strlen("transport-local"))) {
++ type = kTransportLocal;
++ } else if (!strncmp(service, "transport-any",
strlen("transport-any"))) {
++ type = kTransportAny;
++ } else if (!strncmp(service, "transport:",
strlen("transport:"))) {
++ service += strlen("transport:");
++ serial = service;
++ }
++
++ transport = acquire_one_transport(CS_ANY, type, serial,
&error_string);
++
++ if (transport) {
++ s->transport = transport;
++ adb_write(reply_fd, "OKAY", 4);
++ } else {
++ sendfailmsg(reply_fd, error_string);
++ }
++ return 1;
++ }
++
++ // return a list of all connected devices
++ if (!strncmp(service, "devices", 7)) {

++        char buffer[4096];
++        int use_long = !strcmp(service+7, "-l");
++        if (use_long || service[7] == 0) {
++            memset(buf, 0, sizeof(buf));
++            memset(buffer, 0, sizeof(buffer));
++            D("Getting device list \n");
++            list_transports(buffer, sizeof(buffer), use_long);
++            snprintf(buf, sizeof(buf),
"OKAY%04x%s",(unsigned)strlen(buffer),buffer);
++            D("Wrote device list \n");
++            writex(reply_fd, buf, strlen(buf));
++            return 0;

++ }
++ }
++
++ // add a new TCP transport, device or emulator
++ if (!strncmp(service, "connect:", 8)) {

++        char buffer[4096];
++        char* host = service + 8;
++        if (!strncmp(host, "emu:", 4)) {
++            connect_emulator(host + 4, buffer, sizeof(buffer));
++        } else {
++            connect_device(host, buffer, sizeof(buffer));
++        }
++        // Send response for emulator and device
++        snprintf(buf, sizeof(buf),

"OKAY%04x%s",(unsigned)strlen(buffer), buffer);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++
++ // remove TCP transport
++ if (!strncmp(service, "disconnect:", 11)) {

++        char buffer[4096];
++        memset(buffer, 0, sizeof(buffer));
++        char* serial = service + 11;
++        if (serial[0] == 0) {
++            // disconnect from all TCP devices
++            unregister_all_tcp_transports();
++        } else {
++            char hostbuf[100];
++            // assume port 5555 if no port is specified
++            if (!strchr(serial, ':')) {

++ snprintf(hostbuf, sizeof(hostbuf) - 1, "%s:5555",
serial);
++ serial = hostbuf;
++ }
++ atransport *t = find_transport(serial);
++
++ if (t) {
++ unregister_transport(t);
++ } else {
++ snprintf(buffer, sizeof(buffer), "No such device %s",
serial);
++ }
++ }
++
++ snprintf(buf, sizeof(buf),
"OKAY%04x%s",(unsigned)strlen(buffer), buffer);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++
++ // returns our value for ADB_SERVER_VERSION
++ if (!strcmp(service, "version")) {

++        char version[12];
++        snprintf(version, sizeof version, "%04x", ADB_SERVER_VERSION);
++        snprintf(buf, sizeof buf, "OKAY%04x%s",
Quoted 8 lines

(unsigned)strlen(version), version);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++
++ if(!strncmp(service,"get-serialno",strlen("get-serialno"))) {
++ char *out = "unknown";
++ transport = acquire_one_transport(CS_ANY, ttype, serial,

NULL);

Quoted 11 lines

++ if (transport && transport->serial) {
++ out = transport->serial;
++ }
++ snprintf(buf, sizeof buf,
"OKAY%04x%s",(unsigned)strlen(out),out);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++ if(!strncmp(service,"get-devpath",strlen("get-devpath"))) {
++ char *out = "unknown";
++ transport = acquire_one_transport(CS_ANY, ttype, serial,

NULL);

Quoted 131 lines

++ if (transport && transport->devpath) {
++ out = transport->devpath;
++ }
++ snprintf(buf, sizeof buf,
"OKAY%04x%s",(unsigned)strlen(out),out);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;

++    }
++    // indicates a new emulator instance has started
++    if (!strncmp(service,"emulator:",9)) {
++        int  port = atoi(service+9);
++        local_connect(port);
++        /* we don't even need to send a reply */
++        return 0;

++ }
++#endif // ADB_HOST
++
++ if(!strcmp(service,"list-forward")) {

++        // Create the list of forward redirections.
++        char header[9];
++        int buffer_size = format_listeners(NULL, 0);
++        // Add one byte for the trailing zero.
++        char* buffer = malloc(buffer_size+1);
++        (void) format_listeners(buffer, buffer_size+1);
++        snprintf(header, sizeof header, "OKAY%04x", buffer_size);
++        writex(reply_fd, header, 8);
++        writex(reply_fd, buffer, buffer_size);
++        free(buffer);
++        return 0;
++    }
++
++    if (!strcmp(service,"killforward-all")) {
++        remove_all_listeners();
++        adb_write(reply_fd, "OKAYOKAY", 8);
++        return 0;

++ }
++
++ if(!strncmp(service,"forward:",8) ||
++ !strncmp(service,"killforward:",12)) {

++        char *local, *remote, *err;
++        int r;
++        atransport *transport;

++
++ int createForward = strncmp(service,"kill",4);
++ int no_rebind = 0;
++
++ local = strchr(service, ':') + 1;
++
++ // Handle forward:norebind:<local>... here
++ if (createForward && !strncmp(local, "norebind:", 9)) {
++ no_rebind = 1;
++ local = strchr(local, ':') + 1;
++ }
++
++ remote = strchr(local,';');
++
++ if (createForward) {
++ // Check forward: parameter format: '<local>;<remote>'
++ if(remote == 0) {
++ sendfailmsg(reply_fd, "malformed forward spec");
++ return 0;
++ }
++
++ *remote++ = 0;
++ if((local[0] == 0) || (remote[0] == 0) || (remote[0] ==
'*')){
++ sendfailmsg(reply_fd, "malformed forward spec");
++ return 0;
++ }
++ } else {
++ // Check killforward: parameter format: '<local>'
++ if (local[0] == 0) {
++ sendfailmsg(reply_fd, "malformed forward spec");
++ return 0;
++ }
++ }
++
++ transport = acquire_one_transport(CS_ANY, ttype, serial, &err);
++ if (!transport) {
++ sendfailmsg(reply_fd, err);
++ return 0;
++ }
++
++ if (createForward) {
++ r = install_listener(local, remote, transport, no_rebind);
++ } else {
++ r = remove_listener(local, transport);
++ }
++ if(r == 0) {
++ /* 1st OKAY is connect, 2nd OKAY is status */
++ writex(reply_fd, "OKAYOKAY", 8);
++ return 0;
++ }
++
++ if (createForward) {
++ const char* message;
++ switch (r) {
++ case INSTALL_STATUS_CANNOT_BIND:
++ message = "cannot bind to socket";
++ break;
++ case INSTALL_STATUS_CANNOT_REBIND:
++ message = "cannot rebind existing socket";
++ break;
++ default:
++ message = "internal error";
++ }
++ sendfailmsg(reply_fd, message);
++ } else {
++ sendfailmsg(reply_fd, "cannot remove listener");
++ }
++ return 0;
++ }
++
++ if(!strncmp(service,"get-state",strlen("get-state"))) {

++        transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
++        char *state = connection_state_name(transport);
++        snprintf(buf, sizeof buf,

"OKAY%04x%s",(unsigned)strlen(state),state);
++ writex(reply_fd, buf, strlen(buf));
++ return 0;
++ }
++ return -1;
++}
++
++#if !ADB_HOST
++int recovery_mode = 0;
++#endif
++
++int main(int argc, char **argv)
++{
++#if ADB_HOST

Quoted 6 lines
++    adb_sysdeps_init();
++    adb_trace_init();
++    D("Handling commandline()\n");
++    return adb_commandline(argc - 1, argv + 1);

++#else
++ /* If adbd runs inside the emulator this will enable adb tracing

via

Quoted 39 lines

++ * adb-debug qemud service in the emulator. */
++ adb_qemu_trace_init();
++ if((argc > 1) && (!strcmp(argv[1],"recovery"))) {
++ adb_device_banner = "recovery";
++ recovery_mode = 1;
++ }
++

++    start_device_log();
++    D("Handling main()\n");
++    return adb_main(0, DEFAULT_ADB_PORT);
++#endif
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/adb.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb.h    2013-06-18

17:12:17.000000000 -0300
+@@ -0,0 +1,491 @@
++/*
++ * Copyright (C) 2007 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 __ADB_H
++#define __ADB_H
++
++#include <limits.h>

Quoted 8 lines

++
++#include "transport.h" /* readx(), writex() */
++
++#define MAX_PAYLOAD 4096
++
++#define A_SYNC 0x434e5953
++#define A_CNXN 0x4e584e43
++#define A_OPEN 0x4e45

--
_______________________________________________
Openembedded-devel mailing list
[email protected]
http://lists.openembedded.org/mailman/listinfo/openembedded-devel