--- /dev/null
+## 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 0x4e45504f
++#define A_OKAY 0x59414b4f
++#define A_CLSE 0x45534c43
++#define A_WRTE 0x45545257
++#define A_AUTH 0x48545541
++
++#define A_VERSION 0x01000000 // ADB protocol version
++
++#define ADB_VERSION_MAJOR 1 // Used for help/version information
++#define ADB_VERSION_MINOR 0 // Used for help/version information
++
++#define ADB_SERVER_VERSION 31 // Increment this when we want to force users to start a new adb server
++
++typedef struct amessage amessage;
++typedef struct apacket apacket;
++typedef struct asocket asocket;
++typedef struct alistener alistener;
++typedef struct aservice aservice;
++typedef struct atransport atransport;
++typedef struct adisconnect adisconnect;
++typedef struct usb_handle usb_handle;
++
++struct amessage {
++ unsigned command; /* command identifier constant */
++ unsigned arg0; /* first argument */
++ unsigned arg1; /* second argument */
++ unsigned data_length; /* length of payload (0 is allowed) */
++ unsigned data_check; /* checksum of data payload */
++ unsigned magic; /* command ^ 0xffffffff */
++};
++
++struct apacket
++{
++ apacket *next;
++
++ unsigned len;
++ unsigned char *ptr;
++
++ amessage msg;
++ unsigned char data[MAX_PAYLOAD];
++};
++
++/* An asocket represents one half of a connection between a local and
++** remote entity. A local asocket is bound to a file descriptor. A
++** remote asocket is bound to the protocol engine.
++*/
++struct asocket {
++ /* chain pointers for the local/remote list of
++ ** asockets that this asocket lives in
++ */
++ asocket *next;
++ asocket *prev;
++
++ /* the unique identifier for this asocket
++ */
++ unsigned id;
++
++ /* flag: set when the socket's peer has closed
++ ** but packets are still queued for delivery
++ */
++ int closing;
++
++ /* flag: quit adbd when both ends close the
++ ** local service socket
++ */
++ int exit_on_close;
++
++ /* the asocket we are connected to
++ */
++
++ asocket *peer;
++
++ /* For local asockets, the fde is used to bind
++ ** us to our fd event system. For remote asockets
++ ** these fields are not used.
++ */
++ fdevent fde;
++ int fd;
++
++ /* queue of apackets waiting to be written
++ */
++ apacket *pkt_first;
++ apacket *pkt_last;
++
++ /* enqueue is called by our peer when it has data
++ ** for us. It should return 0 if we can accept more
++ ** data or 1 if not. If we return 1, we must call
++ ** peer->ready() when we once again are ready to
++ ** receive data.
++ */
++ int (*enqueue)(asocket *s, apacket *pkt);
++
++ /* ready is called by the peer when it is ready for
++ ** us to send data via enqueue again
++ */
++ void (*ready)(asocket *s);
++
++ /* close is called by the peer when it has gone away.
++ ** we are not allowed to make any further calls on the
++ ** peer once our close method is called.
++ */
++ void (*close)(asocket *s);
++
++ /* socket-type-specific extradata */
++ void *extra;
++
++ /* A socket is bound to atransport */
++ atransport *transport;
++};
++
++
++/* the adisconnect structure is used to record a callback that
++** will be called whenever a transport is disconnected (e.g. by the user)
++** this should be used to cleanup objects that depend on the
++** transport (e.g. remote sockets, listeners, etc...)
++*/
++struct adisconnect
++{
++ void (*func)(void* opaque, atransport* t);
++ void* opaque;
++ adisconnect* next;
++ adisconnect* prev;
++};
++
++
++/* a transport object models the connection to a remote device or emulator
++** there is one transport per connected device/emulator. a "local transport"
++** connects through TCP (for the emulator), while a "usb transport" through
++** USB (for real devices)
++**
++** note that kTransportHost doesn't really correspond to a real transport
++** object, it's a special value used to indicate that a client wants to
++** connect to a service implemented within the ADB server itself.
++*/
++typedef enum transport_type {
++ kTransportUsb,
++ kTransportLocal,
++ kTransportAny,
++ kTransportHost,
++} transport_type;
++
++#define TOKEN_SIZE 20
++
++struct atransport
++{
++ atransport *next;
++ atransport *prev;
++
++ int (*read_from_remote)(apacket *p, atransport *t);
++ int (*write_to_remote)(apacket *p, atransport *t);
++ void (*close)(atransport *t);
++ void (*kick)(atransport *t);
++
++ int fd;
++ int transport_socket;
++ fdevent transport_fde;
++ int ref_count;
++ unsigned sync_token;
++ int connection_state;
++ int online;
++ transport_type type;
++
++ /* usb handle or socket fd as needed */
++ usb_handle *usb;
++ int sfd;
++
++ /* used to identify transports for clients */
++ char *serial;
++ char *product;
++ char *model;
++ char *device;
++ char *devpath;
++ int adb_port; // Use for emulators (local transport)
++
++ /* a list of adisconnect callbacks called when the transport is kicked */
++ int kicked;
++ adisconnect disconnects;
++
++ void *key;
++ unsigned char token[TOKEN_SIZE];
++ fdevent auth_fde;
++ unsigned failed_auth_attempts;
++};
++
++
++/* A listener is an entity which binds to a local port
++** and, upon receiving a connection on that port, creates
++** an asocket to connect the new local connection to a
++** specific remote service.
++**
++** TODO: some listeners read from the new connection to
++** determine what exact service to connect to on the far
++** side.
++*/
++struct alistener
++{
++ alistener *next;
++ alistener *prev;
++
++ fdevent fde;
++ int fd;
++
++ const char *local_name;
++ const char *connect_to;
++ atransport *transport;
++ adisconnect disconnect;
++};
++
++
++void print_packet(const char *label, apacket *p);
++
++asocket *find_local_socket(unsigned id);
++void install_local_socket(asocket *s);
++void remove_socket(asocket *s);
++void close_all_sockets(atransport *t);
++
++#define LOCAL_CLIENT_PREFIX "emulator-"
++
++asocket *create_local_socket(int fd);
++asocket *create_local_service_socket(const char *destination);
++
++asocket *create_remote_socket(unsigned id, atransport *t);
++void connect_to_remote(asocket *s, const char *destination);
++void connect_to_smartsocket(asocket *s);
++
++void fatal(const char *fmt, ...);
++void fatal_errno(const char *fmt, ...);
++
++void handle_packet(apacket *p, atransport *t);
++void send_packet(apacket *p, atransport *t);
++
++void get_my_path(char *s, size_t maxLen);
++int launch_server(int server_port);
++int adb_main(int is_daemon, int server_port);
++
++
++/* transports are ref-counted
++** get_device_transport does an acquire on your behalf before returning
++*/
++void init_transport_registration(void);
++int list_transports(char *buf, size_t bufsize, int long_listing);
++void update_transports(void);
++
++asocket* create_device_tracker(void);
++
++/* Obtain a transport from the available transports.
++** If state is != CS_ANY, only transports in that state are considered.
++** If serial is non-NULL then only the device with that serial will be chosen.
++** If no suitable transport is found, error is set.
++*/
++atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char **error_out);
++void add_transport_disconnect( atransport* t, adisconnect* dis );
++void remove_transport_disconnect( atransport* t, adisconnect* dis );
++void run_transport_disconnects( atransport* t );
++void kick_transport( atransport* t );
++
++/* initialize a transport object's func pointers and state */
++#if ADB_HOST
++int get_available_local_transport_index();
++#endif
++int init_socket_transport(atransport *t, int s, int port, int local);
++void init_usb_transport(atransport *t, usb_handle *usb, int state);
++
++/* for MacOS X cleanup */
++void close_usb_devices();
++
++/* cause new transports to be init'd and added to the list */
++void register_socket_transport(int s, const char *serial, int port, int local);
++
++/* these should only be used for the "adb disconnect" command */
++void unregister_transport(atransport *t);
++void unregister_all_tcp_transports();
++
++void register_usb_transport(usb_handle *h, const char *serial, const char *devpath, unsigned writeable);
++
++/* this should only be used for transports with connection_state == CS_NOPERM */
++void unregister_usb_transport(usb_handle *usb);
++
++atransport *find_transport(const char *serial);
++#if ADB_HOST
++atransport* find_emulator_transport_by_adb_port(int adb_port);
++#endif
++
++int service_to_fd(const char *name);
++#if ADB_HOST
++asocket *host_service_to_socket(const char* name, const char *serial);
++#endif
++
++#if !ADB_HOST
++int init_jdwp(void);
++asocket* create_jdwp_service_socket();
++asocket* create_jdwp_tracker_service_socket();
++int create_jdwp_connection_fd(int jdwp_pid);
++#endif
++
++#if !ADB_HOST
++typedef enum {
++ BACKUP,
++ RESTORE
++} BackupOperation;
++int backup_service(BackupOperation operation, char* args);
++void framebuffer_service(int fd, void *cookie);
++void log_service(int fd, void *cookie);
++void remount_service(int fd, void *cookie);
++char * get_log_file_path(const char * log_name);
++#endif
++
++/* packet allocator */
++apacket *get_apacket(void);
++void put_apacket(apacket *p);
++
++int check_header(apacket *p);
++int check_data(apacket *p);
++
++/* define ADB_TRACE to 1 to enable tracing support, or 0 to disable it */
++
++#define ADB_TRACE 1
++
++/* IMPORTANT: if you change the following list, don't
++ * forget to update the corresponding 'tags' table in
++ * the adb_trace_init() function implemented in adb.c
++ */
++typedef enum {
++ TRACE_ADB = 0, /* 0x001 */
++ TRACE_SOCKETS,
++ TRACE_PACKETS,
++ TRACE_TRANSPORT,
++ TRACE_RWX, /* 0x010 */
++ TRACE_USB,
++ TRACE_SYNC,
++ TRACE_SYSDEPS,
++ TRACE_JDWP, /* 0x100 */
++ TRACE_SERVICES,
++ TRACE_AUTH,
++} AdbTrace;
++
++#if ADB_TRACE
++
++#if !ADB_HOST
++/*
++ * When running inside the emulator, guest's adbd can connect to 'adb-debug'
++ * qemud service that can display adb trace messages (on condition that emulator
++ * has been started with '-debug adb' option).
++ */
++
++/* Delivers a trace message to the emulator via QEMU pipe. */
++void adb_qemu_trace(const char* fmt, ...);
++/* Macro to use to send ADB trace messages to the emulator. */
++#define DQ(...) adb_qemu_trace(__VA_ARGS__)
++#else
++#define DQ(...) ((void)0)
++#endif /* !ADB_HOST */
++
++ extern int adb_trace_mask;
++ extern unsigned char adb_trace_output_count;
++ void adb_trace_init(void);
++
++# define ADB_TRACING ((adb_trace_mask & (1 << TRACE_TAG)) != 0)
++
++ /* you must define TRACE_TAG before using this macro */
++# define D(...) \
++ do { \
++ if (ADB_TRACING) { \
++ int save_errno = errno; \
++ adb_mutex_lock(&D_lock); \
++ fprintf(stderr, "%s::%s():", \
++ __FILE__, __FUNCTION__); \
++ errno = save_errno; \
++ fprintf(stderr, __VA_ARGS__ ); \
++ fflush(stderr); \
++ adb_mutex_unlock(&D_lock); \
++ errno = save_errno; \
++ } \
++ } while (0)
++# define DR(...) \
++ do { \
++ if (ADB_TRACING) { \
++ int save_errno = errno; \
++ adb_mutex_lock(&D_lock); \
++ errno = save_errno; \
++ fprintf(stderr, __VA_ARGS__ ); \
++ fflush(stderr); \
++ adb_mutex_unlock(&D_lock); \
++ errno = save_errno; \
++ } \
++ } while (0)
++#else
++# define D(...) ((void)0)
++# define DR(...) ((void)0)
++# define ADB_TRACING 0
++#endif
++
++
++#if !DEBUG_PACKETS
++#define print_packet(tag,p) do {} while (0)
++#endif
++
++#if ADB_HOST_ON_TARGET
++/* adb and adbd are coexisting on the target, so use 5038 for adb
++ * to avoid conflicting with adbd's usage of 5037
++ */
++# define DEFAULT_ADB_PORT 5038
++#else
++# define DEFAULT_ADB_PORT 5037
++#endif
++
++#define DEFAULT_ADB_LOCAL_TRANSPORT_PORT 5555
++
++#define ADB_CLASS 0xff
++#define ADB_SUBCLASS 0x42
++#define ADB_PROTOCOL 0x1
++
++
++void local_init(int port);
++int local_connect(int port);
++int local_connect_arbitrary_ports(int console_port, int adb_port);
++
++/* usb host/client interface */
++void usb_init();
++void usb_cleanup();
++int usb_write(usb_handle *h, const void *data, int len);
++int usb_read(usb_handle *h, void *data, int len);
++int usb_close(usb_handle *h);
++void usb_kick(usb_handle *h);
++
++/* used for USB device detection */
++#if ADB_HOST
++int is_adb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol);
++#endif
++
++unsigned host_to_le32(unsigned n);
++int adb_commandline(int argc, char **argv);
++
++int connection_state(atransport *t);
++
++#define CS_ANY -1
++#define CS_OFFLINE 0
++#define CS_BOOTLOADER 1
++#define CS_DEVICE 2
++#define CS_HOST 3
++#define CS_RECOVERY 4
++#define CS_NOPERM 5 /* Insufficient permissions to communicate with the device */
++#define CS_SIDELOAD 6
++
++extern int HOST;
++extern int SHELL_EXIT_NOTIFY_FD;
++
++#define CHUNK_SIZE (64*1024)
++
++#if !ADB_HOST
++#define USB_ADB_PATH "/dev/android_adb"
++
++#define USB_FFS_ADB_PATH "/dev/usb-ffs/adb/"
++#define USB_FFS_ADB_EP(x) USB_FFS_ADB_PATH#x
++
++#define USB_FFS_ADB_EP0 USB_FFS_ADB_EP(ep0)
++#define USB_FFS_ADB_OUT USB_FFS_ADB_EP(ep1)
++#define USB_FFS_ADB_IN USB_FFS_ADB_EP(ep2)
++#endif
++
++int sendfailmsg(int fd, const char *reason);
++int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s);
++
++#endif
+Index: android-tools-4.2.2+git20130218/core/adbd/adb_auth.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb_auth.h 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,54 @@
++/*
++ * Copyright (C) 2012 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_AUTH_H
++#define __ADB_AUTH_H
++
++void adb_auth_init(void);
++void adb_auth_verified(atransport *t);
++
++/* AUTH packets first argument */
++/* Request */
++#define ADB_AUTH_TOKEN 1
++/* Response */
++#define ADB_AUTH_SIGNATURE 2
++#define ADB_AUTH_RSAPUBLICKEY 3
++
++#if ADB_HOST
++
++int adb_auth_sign(void *key, void *token, size_t token_size, void *sig);
++void *adb_auth_nextkey(void *current);
++int adb_auth_get_userkey(unsigned char *data, size_t len);
++
++static inline int adb_auth_generate_token(void *token, size_t token_size) { return 0; }
++static inline int adb_auth_verify(void *token, void *sig, int siglen) { return 0; }
++static inline void adb_auth_confirm_key(unsigned char *data, size_t len, atransport *t) { }
++static inline void adb_auth_reload_keys(void) { }
++
++#else // !ADB_HOST
++
++static inline int adb_auth_sign(void* key, void *token, size_t token_size, void *sig) { return 0; }
++static inline void *adb_auth_nextkey(void *current) { return NULL; }
++static inline int adb_auth_get_userkey(unsigned char *data, size_t len) { return 0; }
++
++int adb_auth_generate_token(void *token, size_t token_size);
++int adb_auth_verify(void *token, void *sig, int siglen);
++void adb_auth_confirm_key(unsigned char *data, size_t len, atransport *t);
++void adb_auth_reload_keys(void);
++
++#endif // ADB_HOST
++
++#endif // __ADB_AUTH_H
+Index: android-tools-4.2.2+git20130218/core/adbd/adb_auth_client.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb_auth_client.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,245 @@
++/*
++ * Copyright (C) 2012 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#include <stdio.h>
++#include <string.h>
++#include <resolv.h>
++#include <cutils/list.h>
++#include <cutils/sockets.h>
++
++#include "sysdeps.h"
++#include "adb.h"
++#include "adb_auth.h"
++#include "fdevent.h"
++#include "mincrypt/rsa.h"
++
++#define TRACE_TAG TRACE_AUTH
++
++
++struct adb_public_key {
++ struct listnode node;
++ RSAPublicKey key;
++};
++
++static struct listnode key_list;
++
++static char *key_paths[] = {
++ "/adb_keys",
++ "/data/misc/adb/adb_keys",
++ NULL
++};
++
++static fdevent listener_fde;
++static int framework_fd = -1;
++
++
++static void read_keys(const char *file, struct listnode *list)
++{
++ struct adb_public_key *key;
++ FILE *f;
++ char buf[MAX_PAYLOAD];
++ char *sep;
++ int ret;
++
++ f = fopen(file, "r");
++ if (!f) {
++ D("Can't open '%s'\n", file);
++ return;
++ }
++
++ while (fgets(buf, sizeof(buf), f)) {
++ /* Allocate 4 extra bytes to decode the base64 data in-place */
++ key = calloc(1, sizeof(*key) + 4);
++ if (!key) {
++ D("Can't malloc key\n");
++ break;
++ }
++
++ sep = strpbrk(buf, " \t");
++ if (sep)
++ *sep = '\0';
++
++ ret = __b64_pton(buf, (u_char *)&key->key, sizeof(key->key) + 4);
++ if (ret != sizeof(key->key)) {
++ D("%s: Invalid base64 data ret=%d\n", file, ret);
++ free(key);
++ continue;
++ }
++
++ if (key->key.len != RSANUMWORDS) {
++ D("%s: Invalid key len %d\n", file, key->key.len);
++ free(key);
++ continue;
++ }
++
++ list_add_tail(list, &key->node);
++ }
++
++ fclose(f);
++}
++
++static void free_keys(struct listnode *list)
++{
++ struct listnode *item;
++
++ while (!list_empty(list)) {
++ item = list_head(list);
++ list_remove(item);
++ free(node_to_item(item, struct adb_public_key, node));
++ }
++}
++
++void adb_auth_reload_keys(void)
++{
++ char *path;
++ char **paths = key_paths;
++ struct stat buf;
++
++ free_keys(&key_list);
++
++ while ((path = *paths++)) {
++ if (!stat(path, &buf)) {
++ D("Loading keys from '%s'\n", path);
++ read_keys(path, &key_list);
++ }
++ }
++}
++
++int adb_auth_generate_token(void *token, size_t token_size)
++{
++ FILE *f;
++ int ret;
++
++ f = fopen("/dev/urandom", "r");
++ if (!f)
++ return 0;
++
++ ret = fread(token, token_size, 1, f);
++
++ fclose(f);
++ return ret * token_size;
++}
++
++int adb_auth_verify(void *token, void *sig, int siglen)
++{
++ struct listnode *item;
++ struct adb_public_key *key;
++ int ret;
++
++ if (siglen != RSANUMBYTES)
++ return 0;
++
++ list_for_each(item, &key_list) {
++ key = node_to_item(item, struct adb_public_key, node);
++ ret = RSA_verify(&key->key, sig, siglen, token);
++ if (ret)
++ return 1;
++ }
++
++ return 0;
++}
++
++static void adb_auth_event(int fd, unsigned events, void *data)
++{
++ atransport *t = data;
++ char response[2];
++ int ret;
++
++ if (events & FDE_READ) {
++ ret = unix_read(fd, response, sizeof(response));
++ if (ret < 0) {
++ D("Disconnect");
++ fdevent_remove(&t->auth_fde);
++ framework_fd = -1;
++ }
++ else if (ret == 2 && response[0] == 'O' && response[1] == 'K') {
++ adb_auth_reload_keys();
++ adb_auth_verified(t);
++ }
++ }
++}
++
++void adb_auth_confirm_key(unsigned char *key, size_t len, atransport *t)
++{
++ char msg[MAX_PAYLOAD];
++ int ret;
++
++ if (framework_fd < 0) {
++ D("Client not connected\n");
++ return;
++ }
++
++ if (key[len - 1] != '\0') {
++ D("Key must be a null-terminated string\n");
++ return;
++ }
++
++ ret = snprintf(msg, sizeof(msg), "PK%s", key);
++ if (ret >= (signed)sizeof(msg)) {
++ D("Key too long. ret=%d", ret);
++ return;
++ }
++ D("Sending '%s'\n", msg);
++
++ ret = unix_write(framework_fd, msg, ret);
++ if (ret < 0) {
++ D("Failed to write PK, errno=%d\n", errno);
++ return;
++ }
++
++ fdevent_install(&t->auth_fde, framework_fd, adb_auth_event, t);
++ fdevent_add(&t->auth_fde, FDE_READ);
++}
++
++static void adb_auth_listener(int fd, unsigned events, void *data)
++{
++ struct sockaddr addr;
++ socklen_t alen;
++ int s;
++
++ alen = sizeof(addr);
++
++ s = adb_socket_accept(fd, &addr, &alen);
++ if (s < 0) {
++ D("Failed to accept: errno=%d\n", errno);
++ return;
++ }
++
++ framework_fd = s;
++}
++
++void adb_auth_init(void)
++{
++ int fd, ret;
++
++ list_init(&key_list);
++ adb_auth_reload_keys();
++
++ fd = android_get_control_socket("adbd");
++ if (fd < 0) {
++ D("Failed to get adbd socket\n");
++ return;
++ }
++
++ ret = listen(fd, 4);
++ if (ret < 0) {
++ D("Failed to listen on '%d'\n", fd);
++ return;
++ }
++
++ fdevent_install(&listener_fde, fd, adb_auth_listener, NULL);
++ fdevent_add(&listener_fde, FDE_READ);
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/adb_auth_host.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb_auth_host.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,426 @@
++/*
++ * Copyright (C) 2012 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#include <stdio.h>
++
++#ifdef _WIN32
++# define WIN32_LEAN_AND_MEAN
++# include "windows.h"
++# include "shlobj.h"
++#else
++# include <sys/types.h>
++# include <sys/stat.h>
++# include <unistd.h>
++#endif
++#include <string.h>
++
++#include "sysdeps.h"
++#include "adb.h"
++#include "adb_auth.h"
++
++/* HACK: we need the RSAPublicKey struct
++ * but RSA_verify conflits with openssl */
++#define RSA_verify RSA_verify_mincrypt
++#include "mincrypt/rsa.h"
++#undef RSA_verify
++
++#include <cutils/list.h>
++
++#include <openssl/evp.h>
++#include <openssl/objects.h>
++#include <openssl/pem.h>
++#include <openssl/rsa.h>
++#include <openssl/sha.h>
++
++#define TRACE_TAG TRACE_AUTH
++
++#define ANDROID_PATH ".android"
++#define ADB_KEY_FILE "adbkey"
++
++
++struct adb_private_key {
++ struct listnode node;
++ RSA *rsa;
++};
++
++static struct listnode key_list;
++
++
++/* Convert OpenSSL RSA private key to android pre-computed RSAPublicKey format */
++static int RSA_to_RSAPublicKey(RSA *rsa, RSAPublicKey *pkey)
++{
++ int ret = 1;
++ unsigned int i;
++
++ BN_CTX* ctx = BN_CTX_new();
++ BIGNUM* r32 = BN_new();
++ BIGNUM* rr = BN_new();
++ BIGNUM* r = BN_new();
++ BIGNUM* rem = BN_new();
++ BIGNUM* n = BN_new();
++ BIGNUM* n0inv = BN_new();
++
++ if (RSA_size(rsa) != RSANUMBYTES) {
++ ret = 0;
++ goto out;
++ }
++
++ BN_set_bit(r32, 32);
++ BN_copy(n, rsa->n);
++ BN_set_bit(r, RSANUMWORDS * 32);
++ BN_mod_sqr(rr, r, n, ctx);
++ BN_div(NULL, rem, n, r32, ctx);
++ BN_mod_inverse(n0inv, rem, r32, ctx);
++
++ pkey->len = RSANUMWORDS;
++ pkey->n0inv = 0 - BN_get_word(n0inv);
++ for (i = 0; i < RSANUMWORDS; i++) {
++ BN_div(rr, rem, rr, r32, ctx);
++ pkey->rr[i] = BN_get_word(rem);
++ BN_div(n, rem, n, r32, ctx);
++ pkey->n[i] = BN_get_word(rem);
++ }
++ pkey->exponent = BN_get_word(rsa->e);
++
++out:
++ BN_free(n0inv);
++ BN_free(n);
++ BN_free(rem);
++ BN_free(r);
++ BN_free(rr);
++ BN_free(r32);
++ BN_CTX_free(ctx);
++
++ return ret;
++}
++
++static void get_user_info(char *buf, size_t len)
++{
++ char hostname[1024], username[1024];
++ int ret;
++
++#ifndef _WIN32
++ ret = gethostname(hostname, sizeof(hostname));
++ if (ret < 0)
++#endif
++ strcpy(hostname, "unknown");
++
++#if !defined _WIN32 && !defined ADB_HOST_ON_TARGET
++ ret = getlogin_r(username, sizeof(username));
++ if (ret < 0)
++#endif
++ strcpy(username, "unknown");
++
++ ret = snprintf(buf, len, " %s@%s", username, hostname);
++ if (ret >= (signed)len)
++ buf[len - 1] = '\0';
++}
++
++static int write_public_keyfile(RSA *private_key, const char *private_key_path)
++{
++ RSAPublicKey pkey;
++ BIO *bio, *b64, *bfile;
++ char path[PATH_MAX], info[MAX_PAYLOAD];
++ int ret;
++
++ ret = snprintf(path, sizeof(path), "%s.pub", private_key_path);
++ if (ret >= (signed)sizeof(path))
++ return 0;
++
++ ret = RSA_to_RSAPublicKey(private_key, &pkey);
++ if (!ret) {
++ D("Failed to convert to publickey\n");
++ return 0;
++ }
++
++ bfile = BIO_new_file(path, "w");
++ if (!bfile) {
++ D("Failed to open '%s'\n", path);
++ return 0;
++ }
++
++ D("Writing public key to '%s'\n", path);
++
++ b64 = BIO_new(BIO_f_base64());
++ BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
++
++ bio = BIO_push(b64, bfile);
++ BIO_write(bio, &pkey, sizeof(pkey));
++ BIO_flush(bio);
++ BIO_pop(b64);
++ BIO_free(b64);
++
++ get_user_info(info, sizeof(info));
++ BIO_write(bfile, info, strlen(info));
++ BIO_flush(bfile);
++ BIO_free_all(bfile);
++
++ return 1;
++}
++
++static int generate_key(const char *file)
++{
++ EVP_PKEY* pkey = EVP_PKEY_new();
++ BIGNUM* exponent = BN_new();
++ RSA* rsa = RSA_new();
++ mode_t old_mask;
++ FILE *f = NULL;
++ int ret = 0;
++
++ D("generate_key '%s'\n", file);
++
++ if (!pkey || !exponent || !rsa) {
++ D("Failed to allocate key\n");
++ goto out;
++ }
++
++ BN_set_word(exponent, RSA_F4);
++ RSA_generate_key_ex(rsa, 2048, exponent, NULL);
++ EVP_PKEY_set1_RSA(pkey, rsa);
++
++ old_mask = umask(077);
++
++ f = fopen(file, "w");
++ if (!f) {
++ D("Failed to open '%s'\n", file);
++ umask(old_mask);
++ goto out;
++ }
++
++ umask(old_mask);
++
++ if (!PEM_write_PrivateKey(f, pkey, NULL, NULL, 0, NULL, NULL)) {
++ D("Failed to write key\n");
++ goto out;
++ }
++
++ if (!write_public_keyfile(rsa, file)) {
++ D("Failed to write public key\n");
++ goto out;
++ }
++
++ ret = 1;
++
++out:
++ if (f)
++ fclose(f);
++ EVP_PKEY_free(pkey);
++ RSA_free(rsa);
++ BN_free(exponent);
++ return ret;
++}
++
++static int read_key(const char *file, struct listnode *list)
++{
++ struct adb_private_key *key;
++ FILE *f;
++
++ D("read_key '%s'\n", file);
++
++ f = fopen(file, "r");
++ if (!f) {
++ D("Failed to open '%s'\n", file);
++ return 0;
++ }
++
++ key = malloc(sizeof(*key));
++ if (!key) {
++ D("Failed to alloc key\n");
++ fclose(f);
++ return 0;
++ }
++ key->rsa = RSA_new();
++
++ if (!PEM_read_RSAPrivateKey(f, &key->rsa, NULL, NULL)) {
++ D("Failed to read key\n");
++ fclose(f);
++ RSA_free(key->rsa);
++ free(key);
++ return 0;
++ }
++
++ fclose(f);
++ list_add_tail(list, &key->node);
++ return 1;
++}
++
++static int get_user_keyfilepath(char *filename, size_t len)
++{
++ const char *format, *home;
++ char android_dir[PATH_MAX];
++ struct stat buf;
++#ifdef _WIN32
++ char path[PATH_MAX];
++ home = getenv("ANDROID_SDK_HOME");
++ if (!home) {
++ SHGetFolderPath(NULL, CSIDL_PROFILE, NULL, 0, path);
++ home = path;
++ }
++ format = "%s\\%s";
++#else
++ home = getenv("HOME");
++ if (!home)
++ return -1;
++ format = "%s/%s";
++#endif
++
++ D("home '%s'\n", home);
++
++ if (snprintf(android_dir, sizeof(android_dir), format, home,
++ ANDROID_PATH) >= (int)sizeof(android_dir))
++ return -1;
++
++ if (stat(android_dir, &buf)) {
++ if (adb_mkdir(android_dir, 0750) < 0) {
++ D("Cannot mkdir '%s'", android_dir);
++ return -1;
++ }
++ }
++
++ return snprintf(filename, len, format, android_dir, ADB_KEY_FILE);
++}
++
++static int get_user_key(struct listnode *list)
++{
++ struct stat buf;
++ char path[PATH_MAX];
++ int ret;
++
++ ret = get_user_keyfilepath(path, sizeof(path));
++ if (ret < 0 || ret >= (signed)sizeof(path)) {
++ D("Error getting user key filename");
++ return 0;
++ }
++
++ D("user key '%s'\n", path);
++
++ if (stat(path, &buf) == -1) {
++ if (!generate_key(path)) {
++ D("Failed to generate new key\n");
++ return 0;
++ }
++ }
++
++ return read_key(path, list);
++}
++
++static void get_vendor_keys(struct listnode *list)
++{
++ const char *adb_keys_path;
++ char keys_path[MAX_PAYLOAD];
++ char *path;
++ char *save;
++ struct stat buf;
++
++ adb_keys_path = getenv("ADB_VENDOR_KEYS");
++ if (!adb_keys_path)
++ return;
++ strncpy(keys_path, adb_keys_path, sizeof(keys_path));
++
++ path = adb_strtok_r(keys_path, ENV_PATH_SEPARATOR_STR, &save);
++ while (path) {
++ D("Reading: '%s'\n", path);
++
++ if (stat(path, &buf))
++ D("Can't read '%s'\n", path);
++ else if (!read_key(path, list))
++ D("Failed to read '%s'\n", path);
++
++ path = adb_strtok_r(NULL, ENV_PATH_SEPARATOR_STR, &save);
++ }
++}
++
++int adb_auth_sign(void *node, void *token, size_t token_size, void *sig)
++{
++ unsigned int len;
++ struct adb_private_key *key = node_to_item(node, struct adb_private_key, node);
++
++ if (!RSA_sign(NID_sha1, token, token_size, sig, &len, key->rsa)) {
++ return 0;
++ }
++
++ D("adb_auth_sign len=%d\n", len);
++ return (int)len;
++}
++
++void *adb_auth_nextkey(void *current)
++{
++ struct listnode *item;
++
++ if (list_empty(&key_list))
++ return NULL;
++
++ if (!current)
++ return list_head(&key_list);
++
++ list_for_each(item, &key_list) {
++ if (item == current) {
++ /* current is the last item, we tried all the keys */
++ if (item->next == &key_list)
++ return NULL;
++ return item->next;
++ }
++ }
++
++ return NULL;
++}
++
++int adb_auth_get_userkey(unsigned char *data, size_t len)
++{
++ char path[PATH_MAX];
++ char *file;
++ int ret;
++
++ ret = get_user_keyfilepath(path, sizeof(path) - 4);
++ if (ret < 0 || ret >= (signed)(sizeof(path) - 4)) {
++ D("Error getting user key filename");
++ return 0;
++ }
++ strcat(path, ".pub");
++
++ file = load_file(path, (unsigned*)&ret);
++ if (!file) {
++ D("Can't load '%s'\n", path);
++ return 0;
++ }
++
++ if (len < (size_t)(ret + 1)) {
++ D("%s: Content too large ret=%d\n", path, ret);
++ return 0;
++ }
++
++ memcpy(data, file, ret);
++ data[ret] = '\0';
++
++ return ret + 1;
++}
++
++void adb_auth_init(void)
++{
++ int ret;
++
++ D("adb_auth_init\n");
++
++ list_init(&key_list);
++
++ ret = get_user_key(&key_list);
++ if (!ret) {
++ D("Failed to get user key\n");
++ return;
++ }
++
++ get_vendor_keys(&key_list);
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/adb_client.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb_client.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,340 @@
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <errno.h>
++#include <limits.h>
++#include <stdarg.h>
++#include <zipfile/zipfile.h>
++#include <sys/types.h>
++#include <sys/stat.h>
++
++#include "sysdeps.h"
++
++#define TRACE_TAG TRACE_ADB
++#include "adb_client.h"
++
++static transport_type __adb_transport = kTransportAny;
++static const char* __adb_serial = NULL;
++
++static int __adb_server_port = DEFAULT_ADB_PORT;
++static const char* __adb_server_name = NULL;
++
++void adb_set_transport(transport_type type, const char* serial)
++{
++ __adb_transport = type;
++ __adb_serial = serial;
++}
++
++void adb_set_tcp_specifics(int server_port)
++{
++ __adb_server_port = server_port;
++}
++
++void adb_set_tcp_name(const char* hostname)
++{
++ __adb_server_name = hostname;
++}
++
++int adb_get_emulator_console_port(void)
++{
++ const char* serial = __adb_serial;
++ int port;
++
++ if (serial == NULL) {
++ /* if no specific device was specified, we need to look at */
++ /* the list of connected devices, and extract an emulator */
++ /* name from it. two emulators is an error */
++ char* tmp = adb_query("host:devices");
++ char* p = tmp;
++ if(!tmp) {
++ printf("no emulator connected\n");
++ return -1;
++ }
++ while (*p) {
++ char* q = strchr(p, '\n');
++ if (q != NULL)
++ *q++ = 0;
++ else
++ q = p + strlen(p);
++
++ if (!memcmp(p, LOCAL_CLIENT_PREFIX, sizeof(LOCAL_CLIENT_PREFIX)-1)) {
++ if (serial != NULL) { /* more than one emulator listed */
++ free(tmp);
++ return -2;
++ }
++ serial = p;
++ }
++
++ p = q;
++ }
++ free(tmp);
++
++ if (serial == NULL)
++ return -1; /* no emulator found */
++ }
++ else {
++ if (memcmp(serial, LOCAL_CLIENT_PREFIX, sizeof(LOCAL_CLIENT_PREFIX)-1) != 0)
++ return -1; /* not an emulator */
++ }
++
++ serial += sizeof(LOCAL_CLIENT_PREFIX)-1;
++ port = strtol(serial, NULL, 10);
++ return port;
++}
++
++static char __adb_error[256] = { 0 };
++
++const char *adb_error(void)
++{
++ return __adb_error;
++}
++
++static int switch_socket_transport(int fd)
++{
++ char service[64];
++ char tmp[5];
++ int len;
++
++ if (__adb_serial)
++ snprintf(service, sizeof service, "host:transport:%s", __adb_serial);
++ else {
++ char* transport_type = "???";
++
++ switch (__adb_transport) {
++ case kTransportUsb:
++ transport_type = "transport-usb";
++ break;
++ case kTransportLocal:
++ transport_type = "transport-local";
++ break;
++ case kTransportAny:
++ transport_type = "transport-any";
++ break;
++ case kTransportHost:
++ // no switch necessary
++ return 0;
++ break;
++ }
++
++ snprintf(service, sizeof service, "host:%s", transport_type);
++ }
++ len = strlen(service);
++ snprintf(tmp, sizeof tmp, "%04x", len);
++
++ if(writex(fd, tmp, 4) || writex(fd, service, len)) {
++ strcpy(__adb_error, "write failure during connection");
++ adb_close(fd);
++ return -1;
++ }
++ D("Switch transport in progress\n");
++
++ if(adb_status(fd)) {
++ adb_close(fd);
++ D("Switch transport failed\n");
++ return -1;
++ }
++ D("Switch transport success\n");
++ return 0;
++}
++
++int adb_status(int fd)
++{
++ unsigned char buf[5];
++ unsigned len;
++
++ if(readx(fd, buf, 4)) {
++ strcpy(__adb_error, "protocol fault (no status)");
++ return -1;
++ }
++
++ if(!memcmp(buf, "OKAY", 4)) {
++ return 0;
++ }
++
++ if(memcmp(buf, "FAIL", 4)) {
++ sprintf(__adb_error,
++ "protocol fault (status %02x %02x %02x %02x?!)",
++ buf[0], buf[1], buf[2], buf[3]);
++ return -1;
++ }
++
++ if(readx(fd, buf, 4)) {
++ strcpy(__adb_error, "protocol fault (status len)");
++ return -1;
++ }
++ buf[4] = 0;
++ len = strtoul((char*)buf, 0, 16);
++ if(len > 255) len = 255;
++ if(readx(fd, __adb_error, len)) {
++ strcpy(__adb_error, "protocol fault (status read)");
++ return -1;
++ }
++ __adb_error[len] = 0;
++ return -1;
++}
++
++int _adb_connect(const char *service)
++{
++ char tmp[5];
++ int len;
++ int fd;
++
++ D("_adb_connect: %s\n", service);
++ len = strlen(service);
++ if((len < 1) || (len > 1024)) {
++ strcpy(__adb_error, "service name too long");
++ return -1;
++ }
++ snprintf(tmp, sizeof tmp, "%04x", len);
++
++ if (__adb_server_name)
++ fd = socket_network_client(__adb_server_name, __adb_server_port, SOCK_STREAM);
++ else
++ fd = socket_loopback_client(__adb_server_port, SOCK_STREAM);
++
++ if(fd < 0) {
++ strcpy(__adb_error, "cannot connect to daemon");
++ return -2;
++ }
++
++ if (memcmp(service,"host",4) != 0 && switch_socket_transport(fd)) {
++ return -1;
++ }
++
++ if(writex(fd, tmp, 4) || writex(fd, service, len)) {
++ strcpy(__adb_error, "write failure during connection");
++ adb_close(fd);
++ return -1;
++ }
++
++ if(adb_status(fd)) {
++ adb_close(fd);
++ return -1;
++ }
++
++ D("_adb_connect: return fd %d\n", fd);
++ return fd;
++}
++
++int adb_connect(const char *service)
++{
++ // first query the adb server's version
++ int fd = _adb_connect("host:version");
++
++ D("adb_connect: service %s\n", service);
++ if(fd == -2 && __adb_server_name) {
++ fprintf(stderr,"** Cannot start server on remote host\n");
++ return fd;
++ } else if(fd == -2) {
++ fprintf(stdout,"* daemon not running. starting it now on port %d *\n",
++ __adb_server_port);
++ start_server:
++ if(launch_server(__adb_server_port)) {
++ fprintf(stderr,"* failed to start daemon *\n");
++ return -1;
++ } else {
++ fprintf(stdout,"* daemon started successfully *\n");
++ }
++ /* give the server some time to start properly and detect devices */
++ adb_sleep_ms(3000);
++ // fall through to _adb_connect
++ } else {
++ // if server was running, check its version to make sure it is not out of date
++ char buf[100];
++ int n;
++ int version = ADB_SERVER_VERSION - 1;
++
++ // if we have a file descriptor, then parse version result
++ if(fd >= 0) {
++ if(readx(fd, buf, 4)) goto error;
++
++ buf[4] = 0;
++ n = strtoul(buf, 0, 16);
++ if(n > (int)sizeof(buf)) goto error;
++ if(readx(fd, buf, n)) goto error;
++ adb_close(fd);
++
++ if (sscanf(buf, "%04x", &version) != 1) goto error;
++ } else {
++ // if fd is -1, then check for "unknown host service",
++ // which would indicate a version of adb that does not support the version command
++ if (strcmp(__adb_error, "unknown host service") != 0)
++ return fd;
++ }
++
++ if(version != ADB_SERVER_VERSION) {
++ printf("adb server is out of date. killing...\n");
++ fd = _adb_connect("host:kill");
++ adb_close(fd);
++
++ /* XXX can we better detect its death? */
++ adb_sleep_ms(2000);
++ goto start_server;
++ }
++ }
++
++ // if the command is start-server, we are done.
++ if (!strcmp(service, "host:start-server"))
++ return 0;
++
++ fd = _adb_connect(service);
++ if(fd == -2) {
++ fprintf(stderr,"** daemon still not running\n");
++ }
++ D("adb_connect: return fd %d\n", fd);
++
++ return fd;
++error:
++ adb_close(fd);
++ return -1;
++}
++
++
++int adb_command(const char *service)
++{
++ int fd = adb_connect(service);
++ if(fd < 0) {
++ return -1;
++ }
++
++ if(adb_status(fd)) {
++ adb_close(fd);
++ return -1;
++ }
++
++ return 0;
++}
++
++char *adb_query(const char *service)
++{
++ char buf[5];
++ unsigned n;
++ char *tmp;
++
++ D("adb_query: %s\n", service);
++ int fd = adb_connect(service);
++ if(fd < 0) {
++ fprintf(stderr,"error: %s\n", __adb_error);
++ return 0;
++ }
++
++ if(readx(fd, buf, 4)) goto oops;
++
++ buf[4] = 0;
++ n = strtoul(buf, 0, 16);
++ if(n > 1024) goto oops;
++
++ tmp = malloc(n + 1);
++ if(tmp == 0) goto oops;
++
++ if(readx(fd, tmp, n) == 0) {
++ tmp[n] = 0;
++ adb_close(fd);
++ return tmp;
++ }
++ free(tmp);
++
++oops:
++ adb_close(fd);
++ return 0;
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/adb_client.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/adb_client.h 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,57 @@
++#ifndef _ADB_CLIENT_H_
++#define _ADB_CLIENT_H_
++
++#include "adb.h"
++
++/* connect to adb, connect to the named service, and return
++** a valid fd for interacting with that service upon success
++** or a negative number on failure
++*/
++int adb_connect(const char *service);
++int _adb_connect(const char *service);
++
++/* connect to adb, connect to the named service, return 0 if
++** the connection succeeded AND the service returned OKAY
++*/
++int adb_command(const char *service);
++
++/* connect to adb, connect to the named service, return
++** a malloc'd string of its response upon success or NULL
++** on failure.
++*/
++char *adb_query(const char *service);
++
++/* Set the preferred transport to connect to.
++*/
++void adb_set_transport(transport_type type, const char* serial);
++
++/* Set TCP specifics of the transport to use
++*/
++void adb_set_tcp_specifics(int server_port);
++
++/* Set TCP Hostname of the transport to use
++*/
++void adb_set_tcp_name(const char* hostname);
++
++/* Return the console port of the currently connected emulator (if any)
++ * of -1 if there is no emulator, and -2 if there is more than one.
++ * assumes adb_set_transport() was alled previously...
++ */
++int adb_get_emulator_console_port(void);
++
++/* send commands to the current emulator instance. will fail if there
++ * is zero, or more than one emulator connected (or if you use -s <serial>
++ * with a <serial> that does not designate an emulator)
++ */
++int adb_send_emulator_command(int argc, char** argv);
++
++/* return verbose error string from last operation */
++const char *adb_error(void);
++
++/* read a standard adb status response (OKAY|FAIL) and
++** return 0 in the event of OKAY, -1 in the event of FAIL
++** or protocol error
++*/
++int adb_status(int fd);
++
++#endif
+Index: android-tools-4.2.2+git20130218/core/adbd/android_filesystem_config.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/android_filesystem_config.h 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,302 @@
++/*
++ * 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.
++ */
++
++/* This file is used to define the properties of the filesystem
++** images generated by build tools (mkbootfs and mkyaffs2image) and
++** by the device side of adb.
++*/
++
++#ifndef _ANDROID_FILESYSTEM_CONFIG_H_
++#define _ANDROID_FILESYSTEM_CONFIG_H_
++
++#include <string.h>
++#include <sys/stat.h>
++#include <sys/types.h>
++
++/* This is the master Users and Groups config for the platform.
++** DO NOT EVER RENUMBER.
++*/
++
++#define AID_ROOT 0 /* traditional unix root user */
++
++#define AID_SYSTEM 1000 /* system server */
++
++#define AID_RADIO 1001 /* telephony subsystem, RIL */
++#define AID_BLUETOOTH 1002 /* bluetooth subsystem */
++#define AID_GRAPHICS 1003 /* graphics devices */
++#define AID_INPUT 1004 /* input devices */
++#define AID_AUDIO 1005 /* audio devices */
++#define AID_CAMERA 1006 /* camera devices */
++#define AID_LOG 1007 /* log devices */
++#define AID_COMPASS 1008 /* compass device */
++#define AID_MOUNT 1009 /* mountd socket */
++#define AID_WIFI 1010 /* wifi subsystem */
++#define AID_ADB 1011 /* android debug bridge (adbd) */
++#define AID_INSTALL 1012 /* group for installing packages */
++#define AID_MEDIA 1013 /* mediaserver process */
++#define AID_DHCP 1014 /* dhcp client */
++#define AID_SDCARD_RW 1015 /* external storage write access */
++#define AID_VPN 1016 /* vpn system */
++#define AID_KEYSTORE 1017 /* keystore subsystem */
++#define AID_USB 1018 /* USB devices */
++#define AID_DRM 1019 /* DRM server */
++#define AID_MDNSR 1020 /* MulticastDNSResponder (service discovery) */
++#define AID_GPS 1021 /* GPS daemon */
++#define AID_UNUSED1 1022 /* deprecated, DO NOT USE */
++#define AID_MEDIA_RW 1023 /* internal media storage write access */
++#define AID_MTP 1024 /* MTP USB driver access */
++#define AID_UNUSED2 1025 /* deprecated, DO NOT USE */
++#define AID_DRMRPC 1026 /* group for drm rpc */
++#define AID_NFC 1027 /* nfc subsystem */
++#define AID_SDCARD_R 1028 /* external storage read access */
++
++#define AID_SHELL 2000 /* adb and debug shell user */
++#define AID_CACHE 2001 /* cache access */
++#define AID_DIAG 2002 /* access to diagnostic resources */
++
++/* The 3000 series are intended for use as supplemental group id's only.
++ * They indicate special Android capabilities that the kernel is aware of. */
++#define AID_NET_BT_ADMIN 3001 /* bluetooth: create any socket */
++#define AID_NET_BT 3002 /* bluetooth: create sco, rfcomm or l2cap sockets */
++#define AID_INET 3003 /* can create AF_INET and AF_INET6 sockets */
++#define AID_NET_RAW 3004 /* can create raw INET sockets */
++#define AID_NET_ADMIN 3005 /* can configure interfaces and routing tables. */
++#define AID_NET_BW_STATS 3006 /* read bandwidth statistics */
++#define AID_NET_BW_ACCT 3007 /* change bandwidth statistics accounting */
++#define AID_NET_BT_STACK 3008 /* bluetooth: access config files */
++#define AID_QCOM_ONCRPC 3009 /* can read/write /dev/oncrpc files */
++#define AID_QCOM_DIAG 3010 /* can read/write /dev/diag */
++
++#if defined(MOTOROLA_UIDS)
++#define AID_MOT_OSH 5000 /* OSH */
++#define AID_MOT_ACCY 9000 /* access to accessory */
++#define AID_MOT_PWRIC 9001 /* power IC */
++#define AID_MOT_USB 9002 /* mot usb */
++#define AID_MOT_DRM 9003 /* can access DRM resource. */
++#define AID_MOT_TCMD 9004 /* mot_tcmd */
++#define AID_MOT_SEC_RTC 9005 /* mot cpcap rtc */
++#define AID_MOT_TOMBSTONE 9006
++#define AID_MOT_TPAPI 9007 /* mot_tpapi */
++#define AID_MOT_SECCLKD 9008 /* mot_secclkd */
++#define AID_MOT_WHISPER 9009 /* Whisper Protocol access */
++#define AID_MOT_CAIF 9010 /* can create CAIF sockets */
++#define AID_MOT_DLNA 9011 /* DLNA native */
++#endif // MOTOROLA_UIDS
++
++#define AID_MISC 9998 /* access to misc storage */
++#define AID_NOBODY 9999
++
++#define AID_APP 10000 /* first app user */
++
++#define AID_ISOLATED_START 99000 /* start of uids for fully isolated sandboxed processes */
++#define AID_ISOLATED_END 99999 /* end of uids for fully isolated sandboxed processes */
++
++#define AID_USER 100000 /* offset for uid ranges for each user */
++
++#define AID_SHARED_GID_START 50000 /* start of gids for apps in each user to share */
++#define AID_SHARED_GID_END 59999 /* start of gids for apps in each user to share */
++
++#if !defined(EXCLUDE_FS_CONFIG_STRUCTURES)
++struct android_id_info {
++ const char *name;
++ unsigned aid;
++};
++
++static const struct android_id_info android_ids[] = {
++ { "root", AID_ROOT, },
++ { "system", AID_SYSTEM, },
++ { "radio", AID_RADIO, },
++ { "bluetooth", AID_BLUETOOTH, },
++ { "graphics", AID_GRAPHICS, },
++ { "input", AID_INPUT, },
++ { "audio", AID_AUDIO, },
++ { "camera", AID_CAMERA, },
++ { "log", AID_LOG, },
++ { "compass", AID_COMPASS, },
++ { "mount", AID_MOUNT, },
++ { "wifi", AID_WIFI, },
++ { "dhcp", AID_DHCP, },
++ { "adb", AID_ADB, },
++ { "install", AID_INSTALL, },
++ { "media", AID_MEDIA, },
++ { "drm", AID_DRM, },
++ { "mdnsr", AID_MDNSR, },
++ { "nfc", AID_NFC, },
++ { "drmrpc", AID_DRMRPC, },
++ { "shell", AID_SHELL, },
++ { "cache", AID_CACHE, },
++ { "diag", AID_DIAG, },
++ { "net_bt_admin", AID_NET_BT_ADMIN, },
++ { "net_bt", AID_NET_BT, },
++ { "net_bt_stack", AID_NET_BT_STACK, },
++ { "sdcard_r", AID_SDCARD_R, },
++ { "sdcard_rw", AID_SDCARD_RW, },
++ { "media_rw", AID_MEDIA_RW, },
++ { "vpn", AID_VPN, },
++ { "keystore", AID_KEYSTORE, },
++ { "usb", AID_USB, },
++ { "mtp", AID_MTP, },
++ { "gps", AID_GPS, },
++ { "inet", AID_INET, },
++ { "net_raw", AID_NET_RAW, },
++ { "net_admin", AID_NET_ADMIN, },
++ { "net_bw_stats", AID_NET_BW_STATS, },
++ { "net_bw_acct", AID_NET_BW_ACCT, },
++ { "qcom_oncrpc", AID_QCOM_ONCRPC, },
++ { "qcom_diag", AID_QCOM_DIAG, },
++#if defined(MOTOROLA_UIDS)
++ { "mot_osh", AID_MOT_OSH, },
++ { "mot_accy", AID_MOT_ACCY, },
++ { "mot_pwric", AID_MOT_PWRIC, },
++ { "mot_usb", AID_MOT_USB, },
++ { "mot_drm", AID_MOT_DRM, },
++ { "mot_tcmd", AID_MOT_TCMD, },
++ { "mot_sec_rtc", AID_MOT_SEC_RTC, },
++ { "mot_tombstone", AID_MOT_TOMBSTONE, },
++ { "mot_tpapi", AID_MOT_TPAPI, },
++ { "mot_secclkd", AID_MOT_SECCLKD, },
++ { "mot_whisper", AID_MOT_WHISPER, },
++ { "mot_caif", AID_MOT_CAIF, },
++ { "mot_dlna", AID_MOT_DLNA, },
++#endif
++ { "misc", AID_MISC, },
++ { "nobody", AID_NOBODY, },
++};
++
++#define android_id_count \
++ (sizeof(android_ids) / sizeof(android_ids[0]))
++
++struct fs_path_config {
++ unsigned mode;
++ unsigned uid;
++ unsigned gid;
++ const char *prefix;
++};
++
++/* Rules for directories.
++** These rules are applied based on "first match", so they
++** should start with the most specific path and work their
++** way up to the root.
++*/
++
++static struct fs_path_config android_dirs[] = {
++ { 00770, AID_SYSTEM, AID_CACHE, "cache" },
++ { 00771, AID_SYSTEM, AID_SYSTEM, "data/app" },
++ { 00771, AID_SYSTEM, AID_SYSTEM, "data/app-private" },
++ { 00771, AID_SYSTEM, AID_SYSTEM, "data/dalvik-cache" },
++ { 00771, AID_SYSTEM, AID_SYSTEM, "data/data" },
++ { 00771, AID_SHELL, AID_SHELL, "data/local/tmp" },
++ { 00771, AID_SHELL, AID_SHELL, "data/local" },
++ { 01771, AID_SYSTEM, AID_MISC, "data/misc" },
++ { 00770, AID_DHCP, AID_DHCP, "data/misc/dhcp" },
++ { 00775, AID_MEDIA_RW, AID_MEDIA_RW, "data/media" },
++ { 00775, AID_MEDIA_RW, AID_MEDIA_RW, "data/media/Music" },
++ { 00771, AID_SYSTEM, AID_SYSTEM, "data" },
++ { 00750, AID_ROOT, AID_SHELL, "sbin" },
++ { 00755, AID_ROOT, AID_ROOT, "system/addon.d" },
++ { 00755, AID_ROOT, AID_SHELL, "system/bin" },
++ { 00755, AID_ROOT, AID_SHELL, "system/vendor" },
++ { 00755, AID_ROOT, AID_SHELL, "system/xbin" },
++ { 00755, AID_ROOT, AID_ROOT, "system/etc/ppp" },
++ { 00777, AID_ROOT, AID_ROOT, "sdcard" },
++ { 00755, AID_ROOT, AID_ROOT, 0 },
++};
++
++/* Rules for files.
++** These rules are applied based on "first match", so they
++** should start with the most specific path and work their
++** way up to the root. Prefixes ending in * denotes wildcard
++** and will allow partial matches.
++*/
++static struct fs_path_config android_files[] = {
++ { 00440, AID_ROOT, AID_SHELL, "system/etc/init.goldfish.rc" },
++ { 00550, AID_ROOT, AID_SHELL, "system/etc/init.goldfish.sh" },
++ { 00440, AID_ROOT, AID_SHELL, "system/etc/init.trout.rc" },
++ { 00550, AID_ROOT, AID_SHELL, "system/etc/init.ril" },
++ { 00550, AID_ROOT, AID_SHELL, "system/etc/init.testmenu" },
++ { 00550, AID_DHCP, AID_SHELL, "system/etc/dhcpcd/dhcpcd-run-hooks" },
++ { 00440, AID_BLUETOOTH, AID_BLUETOOTH, "system/etc/dbus.conf" },
++ { 00444, AID_RADIO, AID_AUDIO, "system/etc/AudioPara4.csv" },
++ { 00555, AID_ROOT, AID_ROOT, "system/etc/ppp/*" },
++ { 00555, AID_ROOT, AID_ROOT, "system/etc/rc.*" },
++ { 00755, AID_ROOT, AID_ROOT, "system/addon.d/*" },
++ { 00644, AID_SYSTEM, AID_SYSTEM, "data/app/*" },
++ { 00644, AID_MEDIA_RW, AID_MEDIA_RW, "data/media/*" },
++ { 00644, AID_SYSTEM, AID_SYSTEM, "data/app-private/*" },
++ { 00644, AID_APP, AID_APP, "data/data/*" },
++ /* the following two files are INTENTIONALLY set-gid and not set-uid.
++ * Do not change. */
++ { 02755, AID_ROOT, AID_NET_RAW, "system/bin/ping" },
++ { 02750, AID_ROOT, AID_INET, "system/bin/netcfg" },
++ /* the following five files are INTENTIONALLY set-uid, but they
++ * are NOT included on user builds. */
++ { 06755, AID_ROOT, AID_ROOT, "system/xbin/su" },
++ { 06755, AID_ROOT, AID_ROOT, "system/xbin/librank" },
++ { 06755, AID_ROOT, AID_ROOT, "system/xbin/procrank" },
++ { 06755, AID_ROOT, AID_ROOT, "system/xbin/procmem" },
++ { 06755, AID_ROOT, AID_ROOT, "system/xbin/tcpdump" },
++ { 04770, AID_ROOT, AID_RADIO, "system/bin/pppd-ril" },
++ /* the following file is INTENTIONALLY set-uid, and IS included
++ * in user builds. */
++ { 06750, AID_ROOT, AID_SHELL, "system/bin/run-as" },
++ { 06750, AID_ROOT, AID_SYSTEM, "system/bin/rebootcmd" },
++ { 00755, AID_ROOT, AID_SHELL, "system/bin/*" },
++ { 00755, AID_ROOT, AID_ROOT, "system/lib/valgrind/*" },
++ { 00755, AID_ROOT, AID_SHELL, "system/xbin/*" },
++ { 00755, AID_ROOT, AID_SHELL, "system/vendor/bin/*" },
++ { 00750, AID_ROOT, AID_SHELL, "sbin/*" },
++ { 00755, AID_ROOT, AID_ROOT, "bin/*" },
++ { 00750, AID_ROOT, AID_SHELL, "init*" },
++ { 00750, AID_ROOT, AID_SHELL, "charger*" },
++ { 00750, AID_ROOT, AID_SHELL, "sbin/fs_mgr" },
++ { 00640, AID_ROOT, AID_SHELL, "fstab.*" },
++ { 00755, AID_ROOT, AID_SHELL, "system/etc/init.d/*" },
++ { 00644, AID_ROOT, AID_ROOT, 0 },
++};
++
++static inline void fs_config(const char *path, int dir,
++ unsigned *uid, unsigned *gid, unsigned *mode)
++{
++ struct fs_path_config *pc;
++ int plen;
++
++ pc = dir ? android_dirs : android_files;
++ plen = strlen(path);
++ for(; pc->prefix; pc++){
++ int len = strlen(pc->prefix);
++ if (dir) {
++ if(plen < len) continue;
++ if(!strncmp(pc->prefix, path, len)) break;
++ continue;
++ }
++ /* If name ends in * then allow partial matches. */
++ if (pc->prefix[len -1] == '*') {
++ if(!strncmp(pc->prefix, path, len - 1)) break;
++ } else if (plen == len){
++ if(!strncmp(pc->prefix, path, len)) break;
++ }
++ }
++ *uid = pc->uid;
++ *gid = pc->gid;
++ *mode = (*mode & (~07777)) | pc->mode;
++
++#if 0
++ fprintf(stderr,"< '%s' '%s' %d %d %o >\n",
++ path, pc->prefix ? pc->prefix : "", *uid, *gid, *mode);
++#endif
++}
++#endif
++#endif
+Index: android-tools-4.2.2+git20130218/core/adbd/arpa_nameser.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/arpa_nameser.h 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,577 @@
++/* $NetBSD: nameser.h,v 1.19 2005/12/26 19:01:47 perry Exp $ */
++
++/*
++ * Copyright (c) 1983, 1989, 1993
++ * The Regents of the University of California. All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ * 3. Neither the name of the University nor the names of its contributors
++ * may be used to endorse or promote products derived from this software
++ * without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++/*
++ * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
++ * Copyright (c) 1996-1999 by Internet Software Consortium.
++ *
++ * Permission to use, copy, modify, and distribute this software for any
++ * purpose with or without fee is hereby granted, provided that the above
++ * copyright notice and this permission notice appear in all copies.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
++ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
++ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
++ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
++ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
++ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
++ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ */
++
++/*
++ * Id: nameser.h,v 1.2.2.4.4.1 2004/03/09 08:33:30 marka Exp
++ */
++
++#ifndef _ARPA_NAMESER_H_
++#define _ARPA_NAMESER_H_
++
++#define BIND_4_COMPAT
++
++#include <sys/types.h>
++#include <sys/cdefs.h>
++
++/*
++ * Revision information. This is the release date in YYYYMMDD format.
++ * It can change every day so the right thing to do with it is use it
++ * in preprocessor commands such as "#if (__NAMESER > 19931104)". Do not
++ * compare for equality; rather, use it to determine whether your libbind.a
++ * contains a new enough lib/nameser/ to support the feature you need.
++ */
++
++#define __NAMESER 19991006 /* New interface version stamp. */
++
++/*
++ * Define constants based on RFC 883, RFC 1034, RFC 1035
++ */
++#define NS_PACKETSZ 512 /* default UDP packet size */
++#define NS_MAXDNAME 1025 /* maximum domain name */
++#define NS_MAXMSG 65535 /* maximum message size */
++#define NS_MAXCDNAME 255 /* maximum compressed domain name */
++#define NS_MAXLABEL 63 /* maximum length of domain label */
++#define NS_HFIXEDSZ 12 /* #/bytes of fixed data in header */
++#define NS_QFIXEDSZ 4 /* #/bytes of fixed data in query */
++#define NS_RRFIXEDSZ 10 /* #/bytes of fixed data in r record */
++#define NS_INT32SZ 4 /* #/bytes of data in a uint32_t */
++#define NS_INT16SZ 2 /* #/bytes of data in a uint16_t */
++#define NS_INT8SZ 1 /* #/bytes of data in a uint8_t */
++#define NS_INADDRSZ 4 /* IPv4 T_A */
++#define NS_IN6ADDRSZ 16 /* IPv6 T_AAAA */
++#define NS_CMPRSFLGS 0xc0 /* Flag bits indicating name compression. */
++#define NS_DEFAULTPORT 53 /* For both TCP and UDP. */
++
++/*
++ * These can be expanded with synonyms, just keep ns_parse.c:ns_parserecord()
++ * in synch with it.
++ */
++typedef enum __ns_sect {
++ ns_s_qd = 0, /* Query: Question. */
++ ns_s_zn = 0, /* Update: Zone. */
++ ns_s_an = 1, /* Query: Answer. */
++ ns_s_pr = 1, /* Update: Prerequisites. */
++ ns_s_ns = 2, /* Query: Name servers. */
++ ns_s_ud = 2, /* Update: Update. */
++ ns_s_ar = 3, /* Query|Update: Additional records. */
++ ns_s_max = 4
++} ns_sect;
++
++/*
++ * This is a message handle. It is caller allocated and has no dynamic data.
++ * This structure is intended to be opaque to all but ns_parse.c, thus the
++ * leading _'s on the member names. Use the accessor functions, not the _'s.
++ */
++typedef struct __ns_msg {
++ const u_char *_msg, *_eom;
++ uint16_t _id, _flags, _counts[ns_s_max];
++ const u_char *_sections[ns_s_max];
++ ns_sect _sect;
++ int _rrnum;
++ const u_char *_msg_ptr;
++} ns_msg;
++
++/* Private data structure - do not use from outside library. */
++struct _ns_flagdata { int mask, shift; };
++extern const struct _ns_flagdata _ns_flagdata[];
++
++/* Accessor macros - this is part of the public interface. */
++
++#define ns_msg_id(handle) ((handle)._id + 0)
++#define ns_msg_base(handle) ((handle)._msg + 0)
++#define ns_msg_end(handle) ((handle)._eom + 0)
++#define ns_msg_size(handle) ((size_t)((handle)._eom - (handle)._msg))
++#define ns_msg_count(handle, section) ((handle)._counts[section] + 0)
++
++/*
++ * This is a parsed record. It is caller allocated and has no dynamic data.
++ */
++typedef struct __ns_rr {
++ char name[NS_MAXDNAME];
++ uint16_t type;
++ uint16_t rr_class;
++ uint32_t ttl;
++ uint16_t rdlength;
++ const u_char * rdata;
++} ns_rr;
++
++/* Accessor macros - this is part of the public interface. */
++#define ns_rr_name(rr) (((rr).name[0] != '\0') ? (rr).name : ".")
++#define ns_rr_type(rr) ((ns_type)((rr).type + 0))
++#define ns_rr_class(rr) ((ns_class)((rr).rr_class + 0))
++#define ns_rr_ttl(rr) ((u_long)(rr).ttl + 0)
++#define ns_rr_rdlen(rr) ((size_t)(rr).rdlength + 0)
++#define ns_rr_rdata(rr) ((rr).rdata + 0)
++
++/*
++ * These don't have to be in the same order as in the packet flags word,
++ * and they can even overlap in some cases, but they will need to be kept
++ * in synch with ns_parse.c:ns_flagdata[].
++ */
++typedef enum __ns_flag {
++ ns_f_qr, /* Question/Response. */
++ ns_f_opcode, /* Operation code. */
++ ns_f_aa, /* Authoritative Answer. */
++ ns_f_tc, /* Truncation occurred. */
++ ns_f_rd, /* Recursion Desired. */
++ ns_f_ra, /* Recursion Available. */
++ ns_f_z, /* MBZ. */
++ ns_f_ad, /* Authentic Data (DNSSEC). */
++ ns_f_cd, /* Checking Disabled (DNSSEC). */
++ ns_f_rcode, /* Response code. */
++ ns_f_max
++} ns_flag;
++
++/*
++ * Currently defined opcodes.
++ */
++typedef enum __ns_opcode {
++ ns_o_query = 0, /* Standard query. */
++ ns_o_iquery = 1, /* Inverse query (deprecated/unsupported). */
++ ns_o_status = 2, /* Name server status query (unsupported). */
++ /* Opcode 3 is undefined/reserved. */
++ ns_o_notify = 4, /* Zone change notification. */
++ ns_o_update = 5, /* Zone update message. */
++ ns_o_max = 6
++} ns_opcode;
++
++/*
++ * Currently defined response codes.
++ */
++typedef enum __ns_rcode {
++ ns_r_noerror = 0, /* No error occurred. */
++ ns_r_formerr = 1, /* Format error. */
++ ns_r_servfail = 2, /* Server failure. */
++ ns_r_nxdomain = 3, /* Name error. */
++ ns_r_notimpl = 4, /* Unimplemented. */
++ ns_r_refused = 5, /* Operation refused. */
++ /* these are for BIND_UPDATE */
++ ns_r_yxdomain = 6, /* Name exists */
++ ns_r_yxrrset = 7, /* RRset exists */
++ ns_r_nxrrset = 8, /* RRset does not exist */
++ ns_r_notauth = 9, /* Not authoritative for zone */
++ ns_r_notzone = 10, /* Zone of record different from zone section */
++ ns_r_max = 11,
++ /* The following are EDNS extended rcodes */
++ ns_r_badvers = 16,
++ /* The following are TSIG errors */
++ ns_r_badsig = 16,
++ ns_r_badkey = 17,
++ ns_r_badtime = 18
++} ns_rcode;
++
++/* BIND_UPDATE */
++typedef enum __ns_update_operation {
++ ns_uop_delete = 0,
++ ns_uop_add = 1,
++ ns_uop_max = 2
++} ns_update_operation;
++
++/*
++ * This structure is used for TSIG authenticated messages
++ */
++struct ns_tsig_key {
++ char name[NS_MAXDNAME], alg[NS_MAXDNAME];
++ unsigned char *data;
++ int len;
++};
++typedef struct ns_tsig_key ns_tsig_key;
++
++/*
++ * This structure is used for TSIG authenticated TCP messages
++ */
++struct ns_tcp_tsig_state {
++ int counter;
++ struct dst_key *key;
++ void *ctx;
++ unsigned char sig[NS_PACKETSZ];
++ int siglen;
++};
++typedef struct ns_tcp_tsig_state ns_tcp_tsig_state;
++
++#define NS_TSIG_FUDGE 300
++#define NS_TSIG_TCP_COUNT 100
++#define NS_TSIG_ALG_HMAC_MD5 "HMAC-MD5.SIG-ALG.REG.INT"
++
++#define NS_TSIG_ERROR_NO_TSIG -10
++#define NS_TSIG_ERROR_NO_SPACE -11
++#define NS_TSIG_ERROR_FORMERR -12
++
++/*
++ * Currently defined type values for resources and queries.
++ */
++typedef enum __ns_type {
++ ns_t_invalid = 0, /* Cookie. */
++ ns_t_a = 1, /* Host address. */
++ ns_t_ns = 2, /* Authoritative server. */
++ ns_t_md = 3, /* Mail destination. */
++ ns_t_mf = 4, /* Mail forwarder. */
++ ns_t_cname = 5, /* Canonical name. */
++ ns_t_soa = 6, /* Start of authority zone. */
++ ns_t_mb = 7, /* Mailbox domain name. */
++ ns_t_mg = 8, /* Mail group member. */
++ ns_t_mr = 9, /* Mail rename name. */
++ ns_t_null = 10, /* Null resource record. */
++ ns_t_wks = 11, /* Well known service. */
++ ns_t_ptr = 12, /* Domain name pointer. */
++ ns_t_hinfo = 13, /* Host information. */
++ ns_t_minfo = 14, /* Mailbox information. */
++ ns_t_mx = 15, /* Mail routing information. */
++ ns_t_txt = 16, /* Text strings. */
++ ns_t_rp = 17, /* Responsible person. */
++ ns_t_afsdb = 18, /* AFS cell database. */
++ ns_t_x25 = 19, /* X_25 calling address. */
++ ns_t_isdn = 20, /* ISDN calling address. */
++ ns_t_rt = 21, /* Router. */
++ ns_t_nsap = 22, /* NSAP address. */
++ ns_t_nsap_ptr = 23, /* Reverse NSAP lookup (deprecated). */
++ ns_t_sig = 24, /* Security signature. */
++ ns_t_key = 25, /* Security key. */
++ ns_t_px = 26, /* X.400 mail mapping. */
++ ns_t_gpos = 27, /* Geographical position (withdrawn). */
++ ns_t_aaaa = 28, /* Ip6 Address. */
++ ns_t_loc = 29, /* Location Information. */
++ ns_t_nxt = 30, /* Next domain (security). */
++ ns_t_eid = 31, /* Endpoint identifier. */
++ ns_t_nimloc = 32, /* Nimrod Locator. */
++ ns_t_srv = 33, /* Server Selection. */
++ ns_t_atma = 34, /* ATM Address */
++ ns_t_naptr = 35, /* Naming Authority PoinTeR */
++ ns_t_kx = 36, /* Key Exchange */
++ ns_t_cert = 37, /* Certification record */
++ ns_t_a6 = 38, /* IPv6 address (deprecates AAAA) */
++ ns_t_dname = 39, /* Non-terminal DNAME (for IPv6) */
++ ns_t_sink = 40, /* Kitchen sink (experimentatl) */
++ ns_t_opt = 41, /* EDNS0 option (meta-RR) */
++ ns_t_apl = 42, /* Address prefix list (RFC 3123) */
++ ns_t_tkey = 249, /* Transaction key */
++ ns_t_tsig = 250, /* Transaction signature. */
++ ns_t_ixfr = 251, /* Incremental zone transfer. */
++ ns_t_axfr = 252, /* Transfer zone of authority. */
++ ns_t_mailb = 253, /* Transfer mailbox records. */
++ ns_t_maila = 254, /* Transfer mail agent records. */
++ ns_t_any = 255, /* Wildcard match. */
++ ns_t_zxfr = 256, /* BIND-specific, nonstandard. */
++ ns_t_max = 65536
++} ns_type;
++
++/* Exclusively a QTYPE? (not also an RTYPE) */
++#define ns_t_qt_p(t) (ns_t_xfr_p(t) || (t) == ns_t_any || \
++ (t) == ns_t_mailb || (t) == ns_t_maila)
++/* Some kind of meta-RR? (not a QTYPE, but also not an RTYPE) */
++#define ns_t_mrr_p(t) ((t) == ns_t_tsig || (t) == ns_t_opt)
++/* Exclusively an RTYPE? (not also a QTYPE or a meta-RR) */
++#define ns_t_rr_p(t) (!ns_t_qt_p(t) && !ns_t_mrr_p(t))
++#define ns_t_udp_p(t) ((t) != ns_t_axfr && (t) != ns_t_zxfr)
++#define ns_t_xfr_p(t) ((t) == ns_t_axfr || (t) == ns_t_ixfr || \
++ (t) == ns_t_zxfr)
++
++/*
++ * Values for class field
++ */
++typedef enum __ns_class {
++ ns_c_invalid = 0, /* Cookie. */
++ ns_c_in = 1, /* Internet. */
++ ns_c_2 = 2, /* unallocated/unsupported. */
++ ns_c_chaos = 3, /* MIT Chaos-net. */
++ ns_c_hs = 4, /* MIT Hesiod. */
++ /* Query class values which do not appear in resource records */
++ ns_c_none = 254, /* for prereq. sections in update requests */
++ ns_c_any = 255, /* Wildcard match. */
++ ns_c_max = 65536
++} ns_class;
++
++/* DNSSEC constants. */
++
++typedef enum __ns_key_types {
++ ns_kt_rsa = 1, /* key type RSA/MD5 */
++ ns_kt_dh = 2, /* Diffie Hellman */
++ ns_kt_dsa = 3, /* Digital Signature Standard (MANDATORY) */
++ ns_kt_private = 254 /* Private key type starts with OID */
++} ns_key_types;
++
++typedef enum __ns_cert_types {
++ cert_t_pkix = 1, /* PKIX (X.509v3) */
++ cert_t_spki = 2, /* SPKI */
++ cert_t_pgp = 3, /* PGP */
++ cert_t_url = 253, /* URL private type */
++ cert_t_oid = 254 /* OID private type */
++} ns_cert_types;
++
++/* Flags field of the KEY RR rdata. */
++#define NS_KEY_TYPEMASK 0xC000 /* Mask for "type" bits */
++#define NS_KEY_TYPE_AUTH_CONF 0x0000 /* Key usable for both */
++#define NS_KEY_TYPE_CONF_ONLY 0x8000 /* Key usable for confidentiality */
++#define NS_KEY_TYPE_AUTH_ONLY 0x4000 /* Key usable for authentication */
++#define NS_KEY_TYPE_NO_KEY 0xC000 /* No key usable for either; no key */
++/* The type bits can also be interpreted independently, as single bits: */
++#define NS_KEY_NO_AUTH 0x8000 /* Key unusable for authentication */
++#define NS_KEY_NO_CONF 0x4000 /* Key unusable for confidentiality */
++#define NS_KEY_RESERVED2 0x2000 /* Security is *mandatory* if bit=0 */
++#define NS_KEY_EXTENDED_FLAGS 0x1000 /* reserved - must be zero */
++#define NS_KEY_RESERVED4 0x0800 /* reserved - must be zero */
++#define NS_KEY_RESERVED5 0x0400 /* reserved - must be zero */
++#define NS_KEY_NAME_TYPE 0x0300 /* these bits determine the type */
++#define NS_KEY_NAME_USER 0x0000 /* key is assoc. with user */
++#define NS_KEY_NAME_ENTITY 0x0200 /* key is assoc. with entity eg host */
++#define NS_KEY_NAME_ZONE 0x0100 /* key is zone key */
++#define NS_KEY_NAME_RESERVED 0x0300 /* reserved meaning */
++#define NS_KEY_RESERVED8 0x0080 /* reserved - must be zero */
++#define NS_KEY_RESERVED9 0x0040 /* reserved - must be zero */
++#define NS_KEY_RESERVED10 0x0020 /* reserved - must be zero */
++#define NS_KEY_RESERVED11 0x0010 /* reserved - must be zero */
++#define NS_KEY_SIGNATORYMASK 0x000F /* key can sign RR's of same name */
++#define NS_KEY_RESERVED_BITMASK ( NS_KEY_RESERVED2 | \
++ NS_KEY_RESERVED4 | \
++ NS_KEY_RESERVED5 | \
++ NS_KEY_RESERVED8 | \
++ NS_KEY_RESERVED9 | \
++ NS_KEY_RESERVED10 | \
++ NS_KEY_RESERVED11 )
++#define NS_KEY_RESERVED_BITMASK2 0xFFFF /* no bits defined here */
++
++/* The Algorithm field of the KEY and SIG RR's is an integer, {1..254} */
++#define NS_ALG_MD5RSA 1 /* MD5 with RSA */
++#define NS_ALG_DH 2 /* Diffie Hellman KEY */
++#define NS_ALG_DSA 3 /* DSA KEY */
++#define NS_ALG_DSS NS_ALG_DSA
++#define NS_ALG_EXPIRE_ONLY 253 /* No alg, no security */
++#define NS_ALG_PRIVATE_OID 254 /* Key begins with OID giving alg */
++
++/* Protocol values */
++/* value 0 is reserved */
++#define NS_KEY_PROT_TLS 1
++#define NS_KEY_PROT_EMAIL 2
++#define NS_KEY_PROT_DNSSEC 3
++#define NS_KEY_PROT_IPSEC 4
++#define NS_KEY_PROT_ANY 255
++
++/* Signatures */
++#define NS_MD5RSA_MIN_BITS 512 /* Size of a mod or exp in bits */
++#define NS_MD5RSA_MAX_BITS 4096
++ /* Total of binary mod and exp */
++#define NS_MD5RSA_MAX_BYTES ((NS_MD5RSA_MAX_BITS+7/8)*2+3)
++ /* Max length of text sig block */
++#define NS_MD5RSA_MAX_BASE64 (((NS_MD5RSA_MAX_BYTES+2)/3)*4)
++#define NS_MD5RSA_MIN_SIZE ((NS_MD5RSA_MIN_BITS+7)/8)
++#define NS_MD5RSA_MAX_SIZE ((NS_MD5RSA_MAX_BITS+7)/8)
++
++#define NS_DSA_SIG_SIZE 41
++#define NS_DSA_MIN_SIZE 213
++#define NS_DSA_MAX_BYTES 405
++
++/* Offsets into SIG record rdata to find various values */
++#define NS_SIG_TYPE 0 /* Type flags */
++#define NS_SIG_ALG 2 /* Algorithm */
++#define NS_SIG_LABELS 3 /* How many labels in name */
++#define NS_SIG_OTTL 4 /* Original TTL */
++#define NS_SIG_EXPIR 8 /* Expiration time */
++#define NS_SIG_SIGNED 12 /* Signature time */
++#define NS_SIG_FOOT 16 /* Key footprint */
++#define NS_SIG_SIGNER 18 /* Domain name of who signed it */
++
++/* How RR types are represented as bit-flags in NXT records */
++#define NS_NXT_BITS 8
++#define NS_NXT_BIT_SET( n,p) (p[(n)/NS_NXT_BITS] |= (0x80>>((n)%NS_NXT_BITS)))
++#define NS_NXT_BIT_CLEAR(n,p) (p[(n)/NS_NXT_BITS] &= ~(0x80>>((n)%NS_NXT_BITS)))
++#define NS_NXT_BIT_ISSET(n,p) (p[(n)/NS_NXT_BITS] & (0x80>>((n)%NS_NXT_BITS)))
++#define NS_NXT_MAX 127
++
++/*
++ * EDNS0 extended flags, host order.
++ */
++#define NS_OPT_DNSSEC_OK 0x8000U
++
++/*
++ * Inline versions of get/put short/long. Pointer is advanced.
++ */
++#define NS_GET16(s, cp) do { \
++ const u_char *t_cp = (const u_char *)(cp); \
++ (s) = ((uint16_t)t_cp[0] << 8) \
++ | ((uint16_t)t_cp[1]) \
++ ; \
++ (cp) += NS_INT16SZ; \
++} while (/*CONSTCOND*/0)
++
++#define NS_GET32(l, cp) do { \
++ const u_char *t_cp = (const u_char *)(cp); \
++ (l) = ((uint32_t)t_cp[0] << 24) \
++ | ((uint32_t)t_cp[1] << 16) \
++ | ((uint32_t)t_cp[2] << 8) \
++ | ((uint32_t)t_cp[3]) \
++ ; \
++ (cp) += NS_INT32SZ; \
++} while (/*CONSTCOND*/0)
++
++#define NS_PUT16(s, cp) do { \
++ uint32_t t_s = (uint32_t)(s); \
++ u_char *t_cp = (u_char *)(cp); \
++ *t_cp++ = t_s >> 8; \
++ *t_cp = t_s; \
++ (cp) += NS_INT16SZ; \
++} while (/*CONSTCOND*/0)
++
++#define NS_PUT32(l, cp) do { \
++ uint32_t t_l = (uint32_t)(l); \
++ u_char *t_cp = (u_char *)(cp); \
++ *t_cp++ = t_l >> 24; \
++ *t_cp++ = t_l >> 16; \
++ *t_cp++ = t_l >> 8; \
++ *t_cp = t_l; \
++ (cp) += NS_INT32SZ; \
++} while (/*CONSTCOND*/0)
++
++/*
++ * ANSI C identifier hiding for bind's lib/nameser.
++ */
++#define ns_msg_getflag __ns_msg_getflag
++#define ns_get16 __ns_get16
++#define ns_get32 __ns_get32
++#define ns_put16 __ns_put16
++#define ns_put32 __ns_put32
++#define ns_initparse __ns_initparse
++#define ns_skiprr __ns_skiprr
++#define ns_parserr __ns_parserr
++#define ns_sprintrr __ns_sprintrr
++#define ns_sprintrrf __ns_sprintrrf
++#define ns_format_ttl __ns_format_ttl
++#define ns_parse_ttl __ns_parse_ttl
++#define ns_datetosecs __ns_datetosecs
++#define ns_name_ntol __ns_name_ntol
++#define ns_name_ntop __ns_name_ntop
++#define ns_name_pton __ns_name_pton
++#define ns_name_unpack __ns_name_unpack
++#define ns_name_pack __ns_name_pack
++#define ns_name_compress __ns_name_compress
++#define ns_name_uncompress __ns_name_uncompress
++#define ns_name_skip __ns_name_skip
++#define ns_name_rollback __ns_name_rollback
++#define ns_sign __ns_sign
++#define ns_sign2 __ns_sign2
++#define ns_sign_tcp __ns_sign_tcp
++#define ns_sign_tcp2 __ns_sign_tcp2
++#define ns_sign_tcp_init __ns_sign_tcp_init
++#define ns_find_tsig __ns_find_tsig
++#define ns_verify __ns_verify
++#define ns_verify_tcp __ns_verify_tcp
++#define ns_verify_tcp_init __ns_verify_tcp_init
++#define ns_samedomain __ns_samedomain
++#define ns_subdomain __ns_subdomain
++#define ns_makecanon __ns_makecanon
++#define ns_samename __ns_samename
++
++__BEGIN_DECLS
++int ns_msg_getflag(ns_msg, int);
++uint16_t ns_get16(const u_char *);
++uint32_t ns_get32(const u_char *);
++void ns_put16(uint16_t, u_char *);
++void ns_put32(uint32_t, u_char *);
++int ns_initparse(const u_char *, int, ns_msg *);
++int ns_skiprr(const u_char *, const u_char *, ns_sect, int);
++int ns_parserr(ns_msg *, ns_sect, int, ns_rr *);
++int ns_sprintrr(const ns_msg *, const ns_rr *,
++ const char *, const char *, char *, size_t);
++int ns_sprintrrf(const u_char *, size_t, const char *,
++ ns_class, ns_type, u_long, const u_char *,
++ size_t, const char *, const char *,
++ char *, size_t);
++int ns_format_ttl(u_long, char *, size_t);
++int ns_parse_ttl(const char *, u_long *);
++uint32_t ns_datetosecs(const char *cp, int *errp);
++int ns_name_ntol(const u_char *, u_char *, size_t);
++int ns_name_ntop(const u_char *, char *, size_t);
++int ns_name_pton(const char *, u_char *, size_t);
++int ns_name_unpack(const u_char *, const u_char *,
++ const u_char *, u_char *, size_t);
++int ns_name_pack(const u_char *, u_char *, int,
++ const u_char **, const u_char **);
++int ns_name_uncompress(const u_char *, const u_char *,
++ const u_char *, char *, size_t);
++int ns_name_compress(const char *, u_char *, size_t,
++ const u_char **, const u_char **);
++int ns_name_skip(const u_char **, const u_char *);
++void ns_name_rollback(const u_char *, const u_char **,
++ const u_char **);
++int ns_sign(u_char *, int *, int, int, void *,
++ const u_char *, int, u_char *, int *, time_t);
++int ns_sign2(u_char *, int *, int, int, void *,
++ const u_char *, int, u_char *, int *, time_t,
++ u_char **, u_char **);
++int ns_sign_tcp(u_char *, int *, int, int,
++ ns_tcp_tsig_state *, int);
++int ns_sign_tcp2(u_char *, int *, int, int,
++ ns_tcp_tsig_state *, int,
++ u_char **, u_char **);
++int ns_sign_tcp_init(void *, const u_char *, int,
++ ns_tcp_tsig_state *);
++u_char *ns_find_tsig(u_char *, u_char *);
++int ns_verify(u_char *, int *, void *,
++ const u_char *, int, u_char *, int *,
++ time_t *, int);
++int ns_verify_tcp(u_char *, int *, ns_tcp_tsig_state *, int);
++int ns_verify_tcp_init(void *, const u_char *, int,
++ ns_tcp_tsig_state *);
++int ns_samedomain(const char *, const char *);
++int ns_subdomain(const char *, const char *);
++int ns_makecanon(const char *, char *, size_t);
++int ns_samename(const char *, const char *);
++__END_DECLS
++
++#ifdef BIND_4_COMPAT
++#include "arpa_nameser_compat.h"
++#endif
++
++#if 0
++# include <logd.h>
++# define XLOG(...) \
++ __libc_android_log_print(ANDROID_LOG_DEBUG,"libc",__VA_ARGS__)
++#else
++#define XLOG(...) do {} while (0)
++#endif
++
++#endif /* !_ARPA_NAMESER_H_ */
+Index: android-tools-4.2.2+git20130218/core/adbd/arpa_nameser_compat.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/arpa_nameser_compat.h 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,236 @@
++/* $NetBSD: nameser_compat.h,v 1.1.1.2 2004/11/07 01:28:27 christos Exp $ */
++
++/* Copyright (c) 1983, 1989
++ * The Regents of the University of California. All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ * 3. All advertising materials mentioning features or use of this software
++ * must display the following acknowledgement:
++ * This product includes software developed by the University of
++ * California, Berkeley and its contributors.
++ * 4. Neither the name of the University nor the names of its contributors
++ * may be used to endorse or promote products derived from this software
++ * without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++/*
++ * from nameser.h 8.1 (Berkeley) 6/2/93
++ * Id: nameser_compat.h,v 1.1.2.3.4.2 2004/07/01 04:43:41 marka Exp
++ */
++
++#ifndef _ARPA_NAMESER_COMPAT_
++#define _ARPA_NAMESER_COMPAT_
++
++#define __BIND 19950621 /* (DEAD) interface version stamp. */
++
++#include <endian.h>
++
++#ifndef BYTE_ORDER
++#if (BSD >= 199103)
++# include <machine/endian.h>
++#else
++#ifdef __linux
++# include <endian.h>
++#else
++#define LITTLE_ENDIAN 1234 /* least-significant byte first (vax, pc) */
++#define BIG_ENDIAN 4321 /* most-significant byte first (IBM, net) */
++#define PDP_ENDIAN 3412 /* LSB first in word, MSW first in long (pdp)*/
++
++#if defined(vax) || defined(ns32000) || defined(sun386) || defined(i386) || \
++ defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \
++ defined(__alpha__) || defined(__alpha) || \
++ (defined(__Lynx__) && defined(__x86__))
++#define BYTE_ORDER LITTLE_ENDIAN
++#endif
++
++#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \
++ defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \
++ defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\
++ defined(apollo) || defined(__convex__) || defined(_CRAY) || \
++ defined(__hppa) || defined(__hp9000) || \
++ defined(__hp9000s300) || defined(__hp9000s700) || \
++ defined(__hp3000s900) || defined(__hpux) || defined(MPE) || \
++ defined (BIT_ZERO_ON_LEFT) || defined(m68k) || defined(__sparc) || \
++ (defined(__Lynx__) && \
++ (defined(__68k__) || defined(__sparc__) || defined(__powerpc__)))
++#define BYTE_ORDER BIG_ENDIAN
++#endif
++#endif /* __linux */
++#endif /* BSD */
++#endif /* BYTE_ORDER */
++
++#if !defined(BYTE_ORDER) || \
++ (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN && \
++ BYTE_ORDER != PDP_ENDIAN)
++ /* you must determine what the correct bit order is for
++ * your compiler - the next line is an intentional error
++ * which will force your compiles to bomb until you fix
++ * the above macros.
++ */
++ #error "Undefined or invalid BYTE_ORDER";
++#endif
++
++/*
++ * Structure for query header. The order of the fields is machine- and
++ * compiler-dependent, depending on the byte/bit order and the layout
++ * of bit fields. We use bit fields only in int variables, as this
++ * is all ANSI requires. This requires a somewhat confusing rearrangement.
++ */
++
++typedef struct {
++ unsigned id :16; /* query identification number */
++#if BYTE_ORDER == BIG_ENDIAN
++ /* fields in third byte */
++ unsigned qr: 1; /* response flag */
++ unsigned opcode: 4; /* purpose of message */
++ unsigned aa: 1; /* authoritive answer */
++ unsigned tc: 1; /* truncated message */
++ unsigned rd: 1; /* recursion desired */
++ /* fields in fourth byte */
++ unsigned ra: 1; /* recursion available */
++ unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */
++ unsigned ad: 1; /* authentic data from named */
++ unsigned cd: 1; /* checking disabled by resolver */
++ unsigned rcode :4; /* response code */
++#endif
++#if BYTE_ORDER == LITTLE_ENDIAN || BYTE_ORDER == PDP_ENDIAN
++ /* fields in third byte */
++ unsigned rd :1; /* recursion desired */
++ unsigned tc :1; /* truncated message */
++ unsigned aa :1; /* authoritive answer */
++ unsigned opcode :4; /* purpose of message */
++ unsigned qr :1; /* response flag */
++ /* fields in fourth byte */
++ unsigned rcode :4; /* response code */
++ unsigned cd: 1; /* checking disabled by resolver */
++ unsigned ad: 1; /* authentic data from named */
++ unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */
++ unsigned ra :1; /* recursion available */
++#endif
++ /* remaining bytes */
++ unsigned qdcount :16; /* number of question entries */
++ unsigned ancount :16; /* number of answer entries */
++ unsigned nscount :16; /* number of authority entries */
++ unsigned arcount :16; /* number of resource entries */
++} HEADER;
++
++#define PACKETSZ NS_PACKETSZ
++#define MAXDNAME NS_MAXDNAME
++#define MAXCDNAME NS_MAXCDNAME
++#define MAXLABEL NS_MAXLABEL
++#define HFIXEDSZ NS_HFIXEDSZ
++#define QFIXEDSZ NS_QFIXEDSZ
++#define RRFIXEDSZ NS_RRFIXEDSZ
++#define INT32SZ NS_INT32SZ
++#define INT16SZ NS_INT16SZ
++#define INT8SZ NS_INT8SZ
++#define INADDRSZ NS_INADDRSZ
++#define IN6ADDRSZ NS_IN6ADDRSZ
++#define INDIR_MASK NS_CMPRSFLGS
++#define NAMESERVER_PORT NS_DEFAULTPORT
++
++#define S_ZONE ns_s_zn
++#define S_PREREQ ns_s_pr
++#define S_UPDATE ns_s_ud
++#define S_ADDT ns_s_ar
++
++#define QUERY ns_o_query
++#define IQUERY ns_o_iquery
++#define STATUS ns_o_status
++#define NS_NOTIFY_OP ns_o_notify
++#define NS_UPDATE_OP ns_o_update
++
++#define NOERROR ns_r_noerror
++#define FORMERR ns_r_formerr
++#define SERVFAIL ns_r_servfail
++#define NXDOMAIN ns_r_nxdomain
++#define NOTIMP ns_r_notimpl
++#define REFUSED ns_r_refused
++#define YXDOMAIN ns_r_yxdomain
++#define YXRRSET ns_r_yxrrset
++#define NXRRSET ns_r_nxrrset
++#define NOTAUTH ns_r_notauth
++#define NOTZONE ns_r_notzone
++/*#define BADSIG ns_r_badsig*/
++/*#define BADKEY ns_r_badkey*/
++/*#define BADTIME ns_r_badtime*/
++
++
++#define DELETE ns_uop_delete
++#define ADD ns_uop_add
++
++#define T_A ns_t_a
++#define T_NS ns_t_ns
++#define T_MD ns_t_md
++#define T_MF ns_t_mf
++#define T_CNAME ns_t_cname
++#define T_SOA ns_t_soa
++#define T_MB ns_t_mb
++#define T_MG ns_t_mg
++#define T_MR ns_t_mr
++#define T_NULL ns_t_null
++#define T_WKS ns_t_wks
++#define T_PTR ns_t_ptr
++#define T_HINFO ns_t_hinfo
++#define T_MINFO ns_t_minfo
++#define T_MX ns_t_mx
++#define T_TXT ns_t_txt
++#define T_RP ns_t_rp
++#define T_AFSDB ns_t_afsdb
++#define T_X25 ns_t_x25
++#define T_ISDN ns_t_isdn
++#define T_RT ns_t_rt
++#define T_NSAP ns_t_nsap
++#define T_NSAP_PTR ns_t_nsap_ptr
++#define T_SIG ns_t_sig
++#define T_KEY ns_t_key
++#define T_PX ns_t_px
++#define T_GPOS ns_t_gpos
++#define T_AAAA ns_t_aaaa
++#define T_LOC ns_t_loc
++#define T_NXT ns_t_nxt
++#define T_EID ns_t_eid
++#define T_NIMLOC ns_t_nimloc
++#define T_SRV ns_t_srv
++#define T_ATMA ns_t_atma
++#define T_NAPTR ns_t_naptr
++#define T_A6 ns_t_a6
++#define T_TSIG ns_t_tsig
++#define T_IXFR ns_t_ixfr
++#define T_AXFR ns_t_axfr
++#define T_MAILB ns_t_mailb
++#define T_MAILA ns_t_maila
++#define T_ANY ns_t_any
++
++#define C_IN ns_c_in
++#define C_CHAOS ns_c_chaos
++#define C_HS ns_c_hs
++/* BIND_UPDATE */
++#define C_NONE ns_c_none
++#define C_ANY ns_c_any
++
++#define GETSHORT NS_GET16
++#define GETLONG NS_GET32
++#define PUTSHORT NS_PUT16
++#define PUTLONG NS_PUT32
++
++#endif /* _ARPA_NAMESER_COMPAT_ */
+Index: android-tools-4.2.2+git20130218/core/adbd/backup_service.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/backup_service.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,155 @@
++/*
++ * Copyright (C) 2011 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#include <unistd.h>
++#include <stdio.h>
++
++#include "sysdeps.h"
++
++#define TRACE_TAG TRACE_ADB
++#include "adb.h"
++
++typedef struct {
++ pid_t pid;
++ int fd;
++} backup_harvest_params;
++
++// socketpair but do *not* mark as close_on_exec
++static int backup_socketpair(int sv[2]) {
++ int rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv );
++ if (rc < 0)
++ return -1;
++
++ return 0;
++}
++
++// harvest the child process then close the read end of the socketpair
++static void* backup_child_waiter(void* args) {
++ int status;
++ backup_harvest_params* params = (backup_harvest_params*) args;
++
++ waitpid(params->pid, &status, 0);
++ adb_close(params->fd);
++ free(params);
++ return NULL;
++}
++
++/* returns the data socket passing the backup data here for forwarding */
++int backup_service(BackupOperation op, char* args) {
++ pid_t pid;
++ int s[2];
++ char* operation;
++ int socketnum;
++
++ // Command string and choice of stdin/stdout for the pipe depend on our invocation
++ if (op == BACKUP) {
++ operation = "backup";
++ socketnum = STDOUT_FILENO;
++ } else {
++ operation = "restore";
++ socketnum = STDIN_FILENO;
++ }
++
++ D("backup_service(%s, %s)\n", operation, args);
++
++ // set up the pipe from the subprocess to here
++ // parent will read s[0]; child will write s[1]
++ if (backup_socketpair(s)) {
++ D("can't create backup/restore socketpair\n");
++ fprintf(stderr, "unable to create backup/restore socketpair\n");
++ return -1;
++ }
++
++ D("Backup/restore socket pair: (send=%d, receive=%d)\n", s[1], s[0]);
++ close_on_exec(s[0]); // only the side we hold on to
++
++ // spin off the child process to run the backup command
++ pid = fork();
++ if (pid < 0) {
++ // failure
++ D("can't fork for %s\n", operation);
++ fprintf(stderr, "unable to fork for %s\n", operation);
++ adb_close(s[0]);
++ adb_close(s[1]);
++ return -1;
++ }
++
++ // Great, we're off and running.
++ if (pid == 0) {
++ // child -- actually run the backup here
++ char* p;
++ int argc;
++ char portnum[16];
++ char** bu_args;
++
++ // fixed args: [0] is 'bu', [1] is the port number, [2] is the 'operation' string
++ argc = 3;
++ for (p = (char*)args; p && *p; ) {
++ argc++;
++ while (*p && *p != ':') p++;
++ if (*p == ':') p++;
++ }
++
++ bu_args = (char**) alloca(argc*sizeof(char*) + 1);
++
++ // run through again to build the argv array
++ argc = 0;
++ bu_args[argc++] = "bu";
++ snprintf(portnum, sizeof(portnum), "%d", s[1]);
++ bu_args[argc++] = portnum;
++ bu_args[argc++] = operation;
++ for (p = (char*)args; p && *p; ) {
++ bu_args[argc++] = p;
++ while (*p && *p != ':') p++;
++ if (*p == ':') {
++ *p = 0;
++ p++;
++ }
++ }
++ bu_args[argc] = NULL;
++
++ // Close the half of the socket that we don't care about, route 'bu's console
++ // to the output socket, and off we go
++ adb_close(s[0]);
++
++ // off we go
++ execvp("/system/bin/bu", (char * const *)bu_args);
++ // oops error - close up shop and go home
++ fprintf(stderr, "Unable to exec 'bu', bailing\n");
++ exit(-1);
++ } else {
++ adb_thread_t t;
++ backup_harvest_params* params;
++
++ // parent, i.e. adbd -- close the sending half of the socket
++ D("fork() returned pid %d\n", pid);
++ adb_close(s[1]);
++
++ // spin a thread to harvest the child process
++ params = (backup_harvest_params*) malloc(sizeof(backup_harvest_params));
++ params->pid = pid;
++ params->fd = s[0];
++ if (adb_thread_create(&t, backup_child_waiter, params)) {
++ adb_close(s[0]);
++ free(params);
++ D("Unable to create child harvester\n");
++ return -1;
++ }
++ }
++
++ // we'll be reading from s[0] as the data is sent by the child process
++ return s[0];
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/base64.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/base64.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,340 @@
++/* $NetBSD: base64.c,v 1.8 2002/11/11 01:15:17 thorpej Exp $ */
++
++/*
++ * Copyright (c) 1996 by Internet Software Consortium.
++ *
++ * Permission to use, copy, modify, and distribute this software for any
++ * purpose with or without fee is hereby granted, provided that the above
++ * copyright notice and this permission notice appear in all copies.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
++ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
++ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
++ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
++ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
++ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
++ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
++ * SOFTWARE.
++ */
++
++/*
++ * Portions Copyright (c) 1995 by International Business Machines, Inc.
++ *
++ * International Business Machines, Inc. (hereinafter called IBM) grants
++ * permission under its copyrights to use, copy, modify, and distribute this
++ * Software with or without fee, provided that the above copyright notice and
++ * all paragraphs of this notice appear in all copies, and that the name of IBM
++ * not be used in connection with the marketing of any product incorporating
++ * the Software or modifications thereof, without specific, written prior
++ * permission.
++ *
++ * To the extent it has a right to do so, IBM grants an immunity from suit
++ * under its patents, if any, for the use, sale or manufacture of products to
++ * the extent that such products are used for performing Domain Name System
++ * dynamic updates in TCP/IP networks by means of the Software. No immunity is
++ * granted for any product per se or for any other function of any product.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
++ * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
++ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
++ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
++ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
++ */
++
++#include <sys/cdefs.h>
++#if defined(LIBC_SCCS) && !defined(lint)
++__RCSID("$NetBSD: base64.c,v 1.8 2002/11/11 01:15:17 thorpej Exp $");
++#endif /* LIBC_SCCS and not lint */
++
++#include <sys/types.h>
++#include <sys/param.h>
++#include <sys/socket.h>
++#include <netinet/in.h>
++#include <arpa/inet.h>
++#include "arpa_nameser.h"
++
++#include <assert.h>
++#include <ctype.h>
++#ifdef ANDROID_CHANGES
++#include "resolv_private.h"
++#else
++#include <resolv.h>
++#endif
++#include <stdio.h>
++
++#include <stdlib.h>
++#include <string.h>
++
++static const char Base64[] =
++ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
++static const char Pad64 = '=';
++
++/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
++ The following encoding technique is taken from RFC 1521 by Borenstein
++ and Freed. It is reproduced here in a slightly edited form for
++ convenience.
++
++ A 65-character subset of US-ASCII is used, enabling 6 bits to be
++ represented per printable character. (The extra 65th character, "=",
++ is used to signify a special processing function.)
++
++ The encoding process represents 24-bit groups of input bits as output
++ strings of 4 encoded characters. Proceeding from left to right, a
++ 24-bit input group is formed by concatenating 3 8-bit input groups.
++ These 24 bits are then treated as 4 concatenated 6-bit groups, each
++ of which is translated into a single digit in the base64 alphabet.
++
++ Each 6-bit group is used as an index into an array of 64 printable
++ characters. The character referenced by the index is placed in the
++ output string.
++
++ Table 1: The Base64 Alphabet
++
++ Value Encoding Value Encoding Value Encoding Value Encoding
++ 0 A 17 R 34 i 51 z
++ 1 B 18 S 35 j 52 0
++ 2 C 19 T 36 k 53 1
++ 3 D 20 U 37 l 54 2
++ 4 E 21 V 38 m 55 3
++ 5 F 22 W 39 n 56 4
++ 6 G 23 X 40 o 57 5
++ 7 H 24 Y 41 p 58 6
++ 8 I 25 Z 42 q 59 7
++ 9 J 26 a 43 r 60 8
++ 10 K 27 b 44 s 61 9
++ 11 L 28 c 45 t 62 +
++ 12 M 29 d 46 u 63 /
++ 13 N 30 e 47 v
++ 14 O 31 f 48 w (pad) =
++ 15 P 32 g 49 x
++ 16 Q 33 h 50 y
++
++ Special processing is performed if fewer than 24 bits are available
++ at the end of the data being encoded. A full encoding quantum is
++ always completed at the end of a quantity. When fewer than 24 input
++ bits are available in an input group, zero bits are added (on the
++ right) to form an integral number of 6-bit groups. Padding at the
++ end of the data is performed using the '=' character.
++
++ Since all base64 input is an integral number of octets, only the
++ -------------------------------------------------
++ following cases can arise:
++
++ (1) the final quantum of encoding input is an integral
++ multiple of 24 bits; here, the final unit of encoded
++ output will be an integral multiple of 4 characters
++ with no "=" padding,
++ (2) the final quantum of encoding input is exactly 8 bits;
++ here, the final unit of encoded output will be two
++ characters followed by two "=" padding characters, or
++ (3) the final quantum of encoding input is exactly 16 bits;
++ here, the final unit of encoded output will be three
++ characters followed by one "=" padding character.
++ */
++
++int
++b64_ntop(src, srclength, target, targsize)
++ u_char const *src;
++ size_t srclength;
++ char *target;
++ size_t targsize;
++{
++ size_t datalength = 0;
++ u_char input[3] = { 0, 0, 0 }; /* make compiler happy */
++ u_char output[4];
++ size_t i;
++
++ assert(src != NULL);
++ assert(target != NULL);
++
++ while (2 < srclength) {
++ input[0] = *src++;
++ input[1] = *src++;
++ input[2] = *src++;
++ srclength -= 3;
++
++ output[0] = (u_int32_t)input[0] >> 2;
++ output[1] = ((u_int32_t)(input[0] & 0x03) << 4) +
++ ((u_int32_t)input[1] >> 4);
++ output[2] = ((u_int32_t)(input[1] & 0x0f) << 2) +
++ ((u_int32_t)input[2] >> 6);
++ output[3] = input[2] & 0x3f;
++ assert(output[0] < 64);
++ assert(output[1] < 64);
++ assert(output[2] < 64);
++ assert(output[3] < 64);
++
++ if (datalength + 4 > targsize)
++ return (-1);
++ target[datalength++] = Base64[output[0]];
++ target[datalength++] = Base64[output[1]];
++ target[datalength++] = Base64[output[2]];
++ target[datalength++] = Base64[output[3]];
++ }
++
++ /* Now we worry about padding. */
++ if (0 != srclength) {
++ /* Get what's left. */
++ input[0] = input[1] = input[2] = '\0';
++ for (i = 0; i < srclength; i++)
++ input[i] = *src++;
++
++ output[0] = (u_int32_t)input[0] >> 2;
++ output[1] = ((u_int32_t)(input[0] & 0x03) << 4) +
++ ((u_int32_t)input[1] >> 4);
++ output[2] = ((u_int32_t)(input[1] & 0x0f) << 2) +
++ ((u_int32_t)input[2] >> 6);
++ assert(output[0] < 64);
++ assert(output[1] < 64);
++ assert(output[2] < 64);
++
++ if (datalength + 4 > targsize)
++ return (-1);
++ target[datalength++] = Base64[output[0]];
++ target[datalength++] = Base64[output[1]];
++ if (srclength == 1)
++ target[datalength++] = Pad64;
++ else
++ target[datalength++] = Base64[output[2]];
++ target[datalength++] = Pad64;
++ }
++ if (datalength >= targsize)
++ return (-1);
++ target[datalength] = '\0'; /* Returned value doesn't count \0. */
++ return (datalength);
++}
++
++/* skips all whitespace anywhere.
++ converts characters, four at a time, starting at (or after)
++ src from base - 64 numbers into three 8 bit bytes in the target area.
++ it returns the number of data bytes stored at the target, or -1 on error.
++ */
++
++int
++b64_pton(src, target, targsize)
++ char const *src;
++ u_char *target;
++ size_t targsize;
++{
++ size_t tarindex;
++ int state, ch;
++ char *pos;
++
++ assert(src != NULL);
++ assert(target != NULL);
++
++ state = 0;
++ tarindex = 0;
++
++ while ((ch = (u_char) *src++) != '\0') {
++ if (isspace(ch)) /* Skip whitespace anywhere. */
++ continue;
++
++ if (ch == Pad64)
++ break;
++
++ pos = strchr(Base64, ch);
++ if (pos == 0) /* A non-base64 character. */
++ return (-1);
++
++ switch (state) {
++ case 0:
++ if (target) {
++ if (tarindex >= targsize)
++ return (-1);
++ target[tarindex] = (pos - Base64) << 2;
++ }
++ state = 1;
++ break;
++ case 1:
++ if (target) {
++ if (tarindex + 1 >= targsize)
++ return (-1);
++ target[tarindex] |=
++ (u_int32_t)(pos - Base64) >> 4;
++ target[tarindex+1] = ((pos - Base64) & 0x0f)
++ << 4 ;
++ }
++ tarindex++;
++ state = 2;
++ break;
++ case 2:
++ if (target) {
++ if (tarindex + 1 >= targsize)
++ return (-1);
++ target[tarindex] |=
++ (u_int32_t)(pos - Base64) >> 2;
++ target[tarindex+1] = ((pos - Base64) & 0x03)
++ << 6;
++ }
++ tarindex++;
++ state = 3;
++ break;
++ case 3:
++ if (target) {
++ if (tarindex >= targsize)
++ return (-1);
++ target[tarindex] |= (pos - Base64);
++ }
++ tarindex++;
++ state = 0;
++ break;
++ default:
++ abort();
++ }
++ }
++
++ /*
++ * We are done decoding Base-64 chars. Let's see if we ended
++ * on a byte boundary, and/or with erroneous trailing characters.
++ */
++
++ if (ch == Pad64) { /* We got a pad char. */
++ ch = *src++; /* Skip it, get next. */
++ switch (state) {
++ case 0: /* Invalid = in first position */
++ case 1: /* Invalid = in second position */
++ return (-1);
++
++ case 2: /* Valid, means one byte of info */
++ /* Skip any number of spaces. */
++ for (; ch != '\0'; ch = (u_char) *src++)
++ if (!isspace(ch))
++ break;
++ /* Make sure there is another trailing = sign. */
++ if (ch != Pad64)
++ return (-1);
++ ch = *src++; /* Skip the = */
++ /* Fall through to "single trailing =" case. */
++ /* FALLTHROUGH */
++
++ case 3: /* Valid, means two bytes of info */
++ /*
++ * We know this char is an =. Is there anything but
++ * whitespace after it?
++ */
++ for (; ch != '\0'; ch = (u_char) *src++)
++ if (!isspace(ch))
++ return (-1);
++
++ /*
++ * Now make sure for cases 2 and 3 that the "extra"
++ * bits that slopped past the last full byte were
++ * zeros. If we don't check them, they become a
++ * subliminal channel.
++ */
++ if (target && target[tarindex] != 0)
++ return (-1);
++ }
++ } else {
++ /*
++ * We ended by seeing the end of the string. Make sure we
++ * have no partial bytes lying around.
++ */
++ if (state != 0)
++ return (-1);
++ }
++
++ return (tarindex);
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/commandline.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/commandline.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,1743 @@
++/*
++ * 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.
++ */
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <errno.h>
++#include <unistd.h>
++#include <limits.h>
++#include <stdarg.h>
++#include <sys/types.h>
++#include <sys/stat.h>
++#include <ctype.h>
++#include <assert.h>
++
++#include "sysdeps.h"
++
++#ifdef HAVE_TERMIO_H
++#include <termios.h>
++#endif
++
++#define TRACE_TAG TRACE_ADB
++#include "adb.h"
++#include "adb_client.h"
++#include "file_sync_service.h"
++
++static int do_cmd(transport_type ttype, char* serial, char *cmd, ...);
++
++void get_my_path(char *s, size_t maxLen);
++int find_sync_dirs(const char *srcarg,
++ char **android_srcdir_out, char **data_srcdir_out);
++int install_app(transport_type transport, char* serial, int argc, char** argv);
++int uninstall_app(transport_type transport, char* serial, int argc, char** argv);
++
++static const char *gProductOutPath = NULL;
++extern int gListenAll;
++
++static char *product_file(const char *extra)
++{
++ int n;
++ char *x;
++
++ if (gProductOutPath == NULL) {
++ fprintf(stderr, "adb: Product directory not specified; "
++ "use -p or define ANDROID_PRODUCT_OUT\n");
++ exit(1);
++ }
++
++ n = strlen(gProductOutPath) + strlen(extra) + 2;
++ x = malloc(n);
++ if (x == 0) {
++ fprintf(stderr, "adb: Out of memory (product_file())\n");
++ exit(1);
++ }
++
++ snprintf(x, (size_t)n, "%s" OS_PATH_SEPARATOR_STR "%s", gProductOutPath, extra);
++ return x;
++}
++
++void version(FILE * out) {
++ fprintf(out, "Android Debug Bridge version %d.%d.%d\n",
++ ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION);
++}
++
++void help()
++{
++ version(stderr);
++
++ fprintf(stderr,
++ "\n"
++ " -a - directs adb to listen on all interfaces for a connection\n"
++ " -d - directs command to the only connected USB device\n"
++ " returns an error if more than one USB device is present.\n"
++ " -e - directs command to the only running emulator.\n"
++ " returns an error if more than one emulator is running.\n"
++ " -s <specific device> - directs command to the device or emulator with the given\n"
++ " serial number or qualifier. Overrides ANDROID_SERIAL\n"
++ " environment variable.\n"
++ " -p <product name or path> - simple product name like 'sooner', or\n"
++ " a relative/absolute path to a product\n"
++ " out directory like 'out/target/product/sooner'.\n"
++ " If -p is not specified, the ANDROID_PRODUCT_OUT\n"
++ " environment variable is used, which must\n"
++ " be an absolute path.\n"
++ " -H - Name of adb server host (default: localhost)\n"
++ " -P - Port of adb server (default: 5037)\n"
++ " devices [-l] - list all connected devices\n"
++ " ('-l' will also list device qualifiers)\n"
++ " connect <host>[:<port>] - connect to a device via TCP/IP\n"
++ " Port 5555 is used by default if no port number is specified.\n"
++ " disconnect [<host>[:<port>]] - disconnect from a TCP/IP device.\n"
++ " Port 5555 is used by default if no port number is specified.\n"
++ " Using this command with no additional arguments\n"
++ " will disconnect from all connected TCP/IP devices.\n"
++ "\n"
++ "device commands:\n"
++ " adb push <local> <remote> - copy file/dir to device\n"
++ " adb pull <remote> [<local>] - copy file/dir from device\n"
++ " adb sync [ <directory> ] - copy host->device only if changed\n"
++ " (-l means list but don't copy)\n"
++ " (see 'adb help all')\n"
++ " adb shell - run remote shell interactively\n"
++ " adb shell <command> - run remote shell command\n"
++ " adb emu <command> - run emulator console command\n"
++ " adb logcat [ <filter-spec> ] - View device log\n"
++ " adb forward --list - list all forward socket connections.\n"
++ " the format is a list of lines with the following format:\n"
++ " <serial> \" \" <local> \" \" <remote> \"\\n\"\n"
++ " adb forward <local> <remote> - forward socket connections\n"
++ " forward specs are one of: \n"
++ " tcp:<port>\n"
++ " localabstract:<unix domain socket name>\n"
++ " localreserved:<unix domain socket name>\n"
++ " localfilesystem:<unix domain socket name>\n"
++ " dev:<character device name>\n"
++ " jdwp:<process pid> (remote only)\n"
++ " adb forward --no-rebind <local> <remote>\n"
++ " - same as 'adb forward <local> <remote>' but fails\n"
++ " if <local> is already forwarded\n"
++ " adb forward --remove <local> - remove a specific forward socket connection\n"
++ " adb forward --remove-all - remove all forward socket connections\n"
++ " adb jdwp - list PIDs of processes hosting a JDWP transport\n"
++ " adb install [-l] [-r] [-s] [--algo <algorithm name> --key <hex-encoded key> --iv <hex-encoded iv>] <file>\n"
++ " - push this package file to the device and install it\n"
++ " ('-l' means forward-lock the app)\n"
++ " ('-r' means reinstall the app, keeping its data)\n"
++ " ('-s' means install on SD card instead of internal storage)\n"
++ " ('--algo', '--key', and '--iv' mean the file is encrypted already)\n"
++ " adb uninstall [-k] <package> - remove this app package from the device\n"
++ " ('-k' means keep the data and cache directories)\n"
++ " adb bugreport - return all information from the device\n"
++ " that should be included in a bug report.\n"
++ "\n"
++ " adb backup [-f <file>] [-apk|-noapk] [-shared|-noshared] [-all] [-system|-nosystem] [<packages...>]\n"
++ " - write an archive of the device's data to <file>.\n"
++ " If no -f option is supplied then the data is written\n"
++ " to \"backup.ab\" in the current directory.\n"
++ " (-apk|-noapk enable/disable backup of the .apks themselves\n"
++ " in the archive; the default is noapk.)\n"
++ " (-shared|-noshared enable/disable backup of the device's\n"
++ " shared storage / SD card contents; the default is noshared.)\n"
++ " (-all means to back up all installed applications)\n"
++ " (-system|-nosystem toggles whether -all automatically includes\n"
++ " system applications; the default is to include system apps)\n"
++ " (<packages...> is the list of applications to be backed up. If\n"
++ " the -all or -shared flags are passed, then the package\n"
++ " list is optional. Applications explicitly given on the\n"
++ " command line will be included even if -nosystem would\n"
++ " ordinarily cause them to be omitted.)\n"
++ "\n"
++ " adb restore <file> - restore device contents from the <file> backup archive\n"
++ "\n"
++ " adb help - show this help message\n"
++ " adb version - show version num\n"
++ "\n"
++ "scripting:\n"
++ " adb wait-for-device - block until device is online\n"
++ " adb start-server - ensure that there is a server running\n"
++ " adb kill-server - kill the server if it is running\n"
++ " adb get-state - prints: offline | bootloader | device\n"
++ " adb get-serialno - prints: <serial-number>\n"
++ " adb get-devpath - prints: <device-path>\n"
++ " adb status-window - continuously print device status for a specified device\n"
++ " adb remount - remounts the /system partition on the device read-write\n"
++ " adb reboot [bootloader|recovery] - reboots the device, optionally into the bootloader or recovery program\n"
++ " adb reboot-bootloader - reboots the device into the bootloader\n"
++ " adb root - restarts the adbd daemon with root permissions\n"
++ " adb usb - restarts the adbd daemon listening on USB\n"
++ " adb tcpip <port> - restarts the adbd daemon listening on TCP on the specified port"
++ "\n"
++ "networking:\n"
++ " adb ppp <tty> [parameters] - Run PPP over USB.\n"
++ " Note: you should not automatically start a PPP connection.\n"
++ " <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1\n"
++ " [parameters] - Eg. defaultroute debug dump local notty usepeerdns\n"
++ "\n"
++ "adb sync notes: adb sync [ <directory> ]\n"
++ " <localdir> can be interpreted in several ways:\n"
++ "\n"
++ " - If <directory> is not specified, both /system and /data partitions will be updated.\n"
++ "\n"
++ " - If it is \"system\" or \"data\", only the corresponding partition\n"
++ " is updated.\n"
++ "\n"
++ "environmental variables:\n"
++ " ADB_TRACE - Print debug information. A comma separated list of the following values\n"
++ " 1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp\n"
++ " ANDROID_SERIAL - The serial number to connect to. -s takes priority over this if given.\n"
++ " ANDROID_LOG_TAGS - When used with the logcat option, only these debug tags are printed.\n"
++ );
++}
++
++int usage()
++{
++ help();
++ return 1;
++}
++
++#ifdef HAVE_TERMIO_H
++static struct termios tio_save;
++
++static void stdin_raw_init(int fd)
++{
++ struct termios tio;
++
++ if(tcgetattr(fd, &tio)) return;
++ if(tcgetattr(fd, &tio_save)) return;
++
++ tio.c_lflag = 0; /* disable CANON, ECHO*, etc */
++
++ /* no timeout but request at least one character per read */
++ tio.c_cc[VTIME] = 0;
++ tio.c_cc[VMIN] = 1;
++
++ tcsetattr(fd, TCSANOW, &tio);
++ tcflush(fd, TCIFLUSH);
++}
++
++static void stdin_raw_restore(int fd)
++{
++ tcsetattr(fd, TCSANOW, &tio_save);
++ tcflush(fd, TCIFLUSH);
++}
++#endif
++
++static void read_and_dump(int fd)
++{
++ char buf[4096];
++ int len;
++
++ while(fd >= 0) {
++ D("read_and_dump(): pre adb_read(fd=%d)\n", fd);
++ len = adb_read(fd, buf, 4096);
++ D("read_and_dump(): post adb_read(fd=%d): len=%d\n", fd, len);
++ if(len == 0) {
++ break;
++ }
++
++ if(len < 0) {
++ if(errno == EINTR) continue;
++ break;
++ }
++ fwrite(buf, 1, len, stdout);
++ fflush(stdout);
++ }
++}
++
++static void copy_to_file(int inFd, int outFd) {
++ const size_t BUFSIZE = 32 * 1024;
++ char* buf = (char*) malloc(BUFSIZE);
++ int len;
++ long total = 0;
++
++ D("copy_to_file(%d -> %d)\n", inFd, outFd);
++ for (;;) {
++ len = adb_read(inFd, buf, BUFSIZE);
++ if (len == 0) {
++ D("copy_to_file() : read 0 bytes; exiting\n");
++ break;
++ }
++ if (len < 0) {
++ if (errno == EINTR) {
++ D("copy_to_file() : EINTR, retrying\n");
++ continue;
++ }
++ D("copy_to_file() : error %d\n", errno);
++ break;
++ }
++ adb_write(outFd, buf, len);
++ total += len;
++ }
++ D("copy_to_file() finished after %lu bytes\n", total);
++ free(buf);
++}
++
++static void *stdin_read_thread(void *x)
++{
++ int fd, fdi;
++ unsigned char buf[1024];
++ int r, n;
++ int state = 0;
++
++ int *fds = (int*) x;
++ fd = fds[0];
++ fdi = fds[1];
++ free(fds);
++
++ for(;;) {
++ /* fdi is really the client's stdin, so use read, not adb_read here */
++ D("stdin_read_thread(): pre unix_read(fdi=%d,...)\n", fdi);
++ r = unix_read(fdi, buf, 1024);
++ D("stdin_read_thread(): post unix_read(fdi=%d,...)\n", fdi);
++ if(r == 0) break;
++ if(r < 0) {
++ if(errno == EINTR) continue;
++ break;
++ }
++ for(n = 0; n < r; n++){
++ switch(buf[n]) {
++ case '\n':
++ state = 1;
++ break;
++ case '\r':
++ state = 1;
++ break;
++ case '~':
++ if(state == 1) state++;
++ break;
++ case '.':
++ if(state == 2) {
++ fprintf(stderr,"\n* disconnect *\n");
++#ifdef HAVE_TERMIO_H
++ stdin_raw_restore(fdi);
++#endif
++ exit(0);
++ }
++ default:
++ state = 0;
++ }
++ }
++ r = adb_write(fd, buf, r);
++ if(r <= 0) {
++ break;
++ }
++ }
++ return 0;
++}
++
++int interactive_shell(void)
++{
++ adb_thread_t thr;
++ int fdi, fd;
++ int *fds;
++
++ fd = adb_connect("shell:");
++ if(fd < 0) {
++ fprintf(stderr,"error: %s\n", adb_error());
++ return 1;
++ }
++ fdi = 0; //dup(0);
++
++ fds = malloc(sizeof(int) * 2);
++ fds[0] = fd;
++ fds[1] = fdi;
++
++#ifdef HAVE_TERMIO_H
++ stdin_raw_init(fdi);
++#endif
++ adb_thread_create(&thr, stdin_read_thread, fds);
++ read_and_dump(fd);
++#ifdef HAVE_TERMIO_H
++ stdin_raw_restore(fdi);
++#endif
++ return 0;
++}
++
++
++static void format_host_command(char* buffer, size_t buflen, const char* command, transport_type ttype, const char* serial)
++{
++ if (serial) {
++ snprintf(buffer, buflen, "host-serial:%s:%s", serial, command);
++ } else {
++ const char* prefix = "host";
++ if (ttype == kTransportUsb)
++ prefix = "host-usb";
++ else if (ttype == kTransportLocal)
++ prefix = "host-local";
++
++ snprintf(buffer, buflen, "%s:%s", prefix, command);
++ }
++}
++
++int adb_download_buffer(const char *service, const void* data, int sz,
++ unsigned progress)
++{
++ char buf[4096];
++ unsigned total;
++ int fd;
++ const unsigned char *ptr;
++
++ sprintf(buf,"%s:%d", service, sz);
++ fd = adb_connect(buf);
++ if(fd < 0) {
++ fprintf(stderr,"error: %s\n", adb_error());
++ return -1;
++ }
++
++ int opt = CHUNK_SIZE;
++ opt = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt));
++
++ total = sz;
++ ptr = data;
++
++ if(progress) {
++ char *x = strrchr(service, ':');
++ if(x) service = x + 1;
++ }
++
++ while(sz > 0) {
++ unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz;
++ if(writex(fd, ptr, xfer)) {
++ adb_status(fd);
++ fprintf(stderr,"* failed to write data '%s' *\n", adb_error());
++ return -1;
++ }
++ sz -= xfer;
++ ptr += xfer;
++ if(progress) {
++ printf("sending: '%s' %4d%% \r", service, (int)(100LL - ((100LL * sz) / (total))));
++ fflush(stdout);
++ }
++ }
++ if(progress) {
++ printf("\n");
++ }
++
++ if(readx(fd, buf, 4)){
++ fprintf(stderr,"* error reading response *\n");
++ adb_close(fd);
++ return -1;
++ }
++ if(memcmp(buf, "OKAY", 4)) {
++ buf[4] = 0;
++ fprintf(stderr,"* error response '%s' *\n", buf);
++ adb_close(fd);
++ return -1;
++ }
++
++ adb_close(fd);
++ return 0;
++}
++
++
++int adb_download(const char *service, const char *fn, unsigned progress)
++{
++ void *data;
++ unsigned sz;
++
++ data = load_file(fn, &sz);
++ if(data == 0) {
++ fprintf(stderr,"* cannot read '%s' *\n", service);
++ return -1;
++ }
++
++ int status = adb_download_buffer(service, data, sz, progress);
++ free(data);
++ return status;
++}
++
++static void status_window(transport_type ttype, const char* serial)
++{
++ char command[4096];
++ char *state = 0;
++ char *laststate = 0;
++
++ /* silence stderr */
++#ifdef _WIN32
++ /* XXX: TODO */
++#else
++ int fd;
++ fd = unix_open("/dev/null", O_WRONLY);
++ dup2(fd, 2);
++ adb_close(fd);
++#endif
++
++ format_host_command(command, sizeof command, "get-state", ttype, serial);
++
++ for(;;) {
++ adb_sleep_ms(250);
++
++ if(state) {
++ free(state);
++ state = 0;
++ }
++
++ state = adb_query(command);
++
++ if(state) {
++ if(laststate && !strcmp(state,laststate)){
++ continue;
++ } else {
++ if(laststate) free(laststate);
++ laststate = strdup(state);
++ }
++ }
++
++ printf("%c[2J%c[2H", 27, 27);
++ printf("Android Debug Bridge\n");
++ printf("State: %s\n", state ? state : "offline");
++ fflush(stdout);
++ }
++}
++
++/** duplicate string and quote all \ " ( ) chars + space character. */
++static char *
++dupAndQuote(const char *s)
++{
++ const char *ts;
++ size_t alloc_len;
++ char *ret;
++ char *dest;
++
++ ts = s;
++
++ alloc_len = 0;
++
++ for( ;*ts != '\0'; ts++) {
++ alloc_len++;
++ if (*ts == ' ' || *ts == '"' || *ts == '\\' || *ts == '(' || *ts == ')') {
++ alloc_len++;
++ }
++ }
++
++ ret = (char *)malloc(alloc_len + 1);
++
++ ts = s;
++ dest = ret;
++
++ for ( ;*ts != '\0'; ts++) {
++ if (*ts == ' ' || *ts == '"' || *ts == '\\' || *ts == '(' || *ts == ')') {
++ *dest++ = '\\';
++ }
++
++ *dest++ = *ts;
++ }
++
++ *dest++ = '\0';
++
++ return ret;
++}
++
++/**
++ * Run ppp in "notty" mode against a resource listed as the first parameter
++ * eg:
++ *
++ * ppp dev:/dev/omap_csmi_tty0 <ppp options>
++ *
++ */
++int ppp(int argc, char **argv)
++{
++#ifdef HAVE_WIN32_PROC
++ fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]);
++ return -1;
++#else
++ char *adb_service_name;
++ pid_t pid;
++ int fd;
++
++ if (argc < 2) {
++ fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n",
++ argv[0]);
++
++ return 1;
++ }
++
++ adb_service_name = argv[1];
++
++ fd = adb_connect(adb_service_name);
++
++ if(fd < 0) {
++ fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n",
++ adb_service_name, adb_error());
++ return 1;
++ }
++
++ pid = fork();
++
++ if (pid < 0) {
++ perror("from fork()");
++ return 1;
++ } else if (pid == 0) {
++ int err;
++ int i;
++ const char **ppp_args;
++
++ // copy args
++ ppp_args = (const char **) alloca(sizeof(char *) * argc + 1);
++ ppp_args[0] = "pppd";
++ for (i = 2 ; i < argc ; i++) {
++ //argv[2] and beyond become ppp_args[1] and beyond
++ ppp_args[i - 1] = argv[i];
++ }
++ ppp_args[i-1] = NULL;
++
++ // child side
++
++ dup2(fd, STDIN_FILENO);
++ dup2(fd, STDOUT_FILENO);
++ adb_close(STDERR_FILENO);
++ adb_close(fd);
++
++ err = execvp("pppd", (char * const *)ppp_args);
++
++ if (err < 0) {
++ perror("execing pppd");
++ }
++ exit(-1);
++ } else {
++ // parent side
++
++ adb_close(fd);
++ return 0;
++ }
++#endif /* !HAVE_WIN32_PROC */
++}
++
++static int send_shellcommand(transport_type transport, char* serial, char* buf)
++{
++ int fd, ret;
++
++ for(;;) {
++ fd = adb_connect(buf);
++ if(fd >= 0)
++ break;
++ fprintf(stderr,"- waiting for device -\n");
++ adb_sleep_ms(1000);
++ do_cmd(transport, serial, "wait-for-device", 0);
++ }
++
++ read_and_dump(fd);
++ ret = adb_close(fd);
++ if (ret)
++ perror("close");
++
++ return ret;
++}
++
++static int logcat(transport_type transport, char* serial, int argc, char **argv)
++{
++ char buf[4096];
++
++ char *log_tags;
++ char *quoted_log_tags;
++
++ log_tags = getenv("ANDROID_LOG_TAGS");
++ quoted_log_tags = dupAndQuote(log_tags == NULL ? "" : log_tags);
++
++ snprintf(buf, sizeof(buf),
++ "shell:export ANDROID_LOG_TAGS=\"\%s\" ; exec logcat",
++ quoted_log_tags);
++
++ free(quoted_log_tags);
++
++ if (!strcmp(argv[0],"longcat")) {
++ strncat(buf, " -v long", sizeof(buf)-1);
++ }
++
++ argc -= 1;
++ argv += 1;
++ while(argc-- > 0) {
++ char *quoted;
++
++ quoted = dupAndQuote (*argv++);
++
++ strncat(buf, " ", sizeof(buf)-1);
++ strncat(buf, quoted, sizeof(buf)-1);
++ free(quoted);
++ }
++
++ send_shellcommand(transport, serial, buf);
++ return 0;
++}
++
++static int mkdirs(char *path)
++{
++ int ret;
++ char *x = path + 1;
++
++ for(;;) {
++ x = adb_dirstart(x);
++ if(x == 0) return 0;
++ *x = 0;
++ ret = adb_mkdir(path, 0775);
++ *x = OS_PATH_SEPARATOR;
++ if((ret < 0) && (errno != EEXIST)) {
++ return ret;
++ }
++ x++;
++ }
++ return 0;
++}
++
++static int backup(int argc, char** argv) {
++ char buf[4096];
++ char default_name[32];
++ const char* filename = strcpy(default_name, "./backup.ab");
++ int fd, outFd;
++ int i, j;
++
++ /* find, extract, and use any -f argument */
++ for (i = 1; i < argc; i++) {
++ if (!strcmp("-f", argv[i])) {
++ if (i == argc-1) {
++ fprintf(stderr, "adb: -f passed with no filename\n");
++ return usage();
++ }
++ filename = argv[i+1];
++ for (j = i+2; j <= argc; ) {
++ argv[i++] = argv[j++];
++ }
++ argc -= 2;
++ argv[argc] = NULL;
++ }
++ }
++
++ /* bare "adb backup" or "adb backup -f filename" are not valid invocations */
++ if (argc < 2) return usage();
++
++ adb_unlink(filename);
++ mkdirs((char *)filename);
++ outFd = adb_creat(filename, 0640);
++ if (outFd < 0) {
++ fprintf(stderr, "adb: unable to open file %s\n", filename);
++ return -1;
++ }
++
++ snprintf(buf, sizeof(buf), "backup");
++ for (argc--, argv++; argc; argc--, argv++) {
++ strncat(buf, ":", sizeof(buf) - strlen(buf) - 1);
++ strncat(buf, argv[0], sizeof(buf) - strlen(buf) - 1);
++ }
++
++ D("backup. filename=%s buf=%s\n", filename, buf);
++ fd = adb_connect(buf);
++ if (fd < 0) {
++ fprintf(stderr, "adb: unable to connect for backup\n");
++ adb_close(outFd);
++ return -1;
++ }
++
++ printf("Now unlock your device and confirm the backup operation.\n");
++ copy_to_file(fd, outFd);
++
++ adb_close(fd);
++ adb_close(outFd);
++ return 0;
++}
++
++static int restore(int argc, char** argv) {
++ const char* filename;
++ int fd, tarFd;
++
++ if (argc != 2) return usage();
++
++ filename = argv[1];
++ tarFd = adb_open(filename, O_RDONLY);
++ if (tarFd < 0) {
++ fprintf(stderr, "adb: unable to open file %s\n", filename);
++ return -1;
++ }
++
++ fd = adb_connect("restore:");
++ if (fd < 0) {
++ fprintf(stderr, "adb: unable to connect for backup\n");
++ adb_close(tarFd);
++ return -1;
++ }
++
++ printf("Now unlock your device and confirm the restore operation.\n");
++ copy_to_file(tarFd, fd);
++
++ adb_close(fd);
++ adb_close(tarFd);
++ return 0;
++}
++
++#define SENTINEL_FILE "config" OS_PATH_SEPARATOR_STR "envsetup.make"
++static int top_works(const char *top)
++{
++ if (top != NULL && adb_is_absolute_host_path(top)) {
++ char path_buf[PATH_MAX];
++ snprintf(path_buf, sizeof(path_buf),
++ "%s" OS_PATH_SEPARATOR_STR SENTINEL_FILE, top);
++ return access(path_buf, F_OK) == 0;
++ }
++ return 0;
++}
++
++static char *find_top_from(const char *indir, char path_buf[PATH_MAX])
++{
++ strcpy(path_buf, indir);
++ while (1) {
++ if (top_works(path_buf)) {
++ return path_buf;
++ }
++ char *s = adb_dirstop(path_buf);
++ if (s != NULL) {
++ *s = '\0';
++ } else {
++ path_buf[0] = '\0';
++ return NULL;
++ }
++ }
++}
++
++static char *find_top(char path_buf[PATH_MAX])
++{
++ char *top = getenv("ANDROID_BUILD_TOP");
++ if (top != NULL && top[0] != '\0') {
++ if (!top_works(top)) {
++ fprintf(stderr, "adb: bad ANDROID_BUILD_TOP value \"%s\"\n", top);
++ return NULL;
++ }
++ } else {
++ top = getenv("TOP");
++ if (top != NULL && top[0] != '\0') {
++ if (!top_works(top)) {
++ fprintf(stderr, "adb: bad TOP value \"%s\"\n", top);
++ return NULL;
++ }
++ } else {
++ top = NULL;
++ }
++ }
++
++ if (top != NULL) {
++ /* The environment pointed to a top directory that works.
++ */
++ strcpy(path_buf, top);
++ return path_buf;
++ }
++
++ /* The environment didn't help. Walk up the tree from the CWD
++ * to see if we can find the top.
++ */
++ char dir[PATH_MAX];
++ top = find_top_from(getcwd(dir, sizeof(dir)), path_buf);
++ if (top == NULL) {
++ /* If the CWD isn't under a good-looking top, see if the
++ * executable is.
++ */
++ get_my_path(dir, PATH_MAX);
++ top = find_top_from(dir, path_buf);
++ }
++ return top;
++}
++
++/* <hint> may be:
++ * - A simple product name
++ * e.g., "sooner"
++TODO: debug? sooner-debug, sooner:debug?
++ * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir
++ * e.g., "out/target/product/sooner"
++ * - An absolute path to the PRODUCT_OUT dir
++ * e.g., "/src/device/out/target/product/sooner"
++ *
++ * Given <hint>, try to construct an absolute path to the
++ * ANDROID_PRODUCT_OUT dir.
++ */
++static const char *find_product_out_path(const char *hint)
++{
++ static char path_buf[PATH_MAX];
++
++ if (hint == NULL || hint[0] == '\0') {
++ return NULL;
++ }
++
++ /* If it's already absolute, don't bother doing any work.
++ */
++ if (adb_is_absolute_host_path(hint)) {
++ strcpy(path_buf, hint);
++ return path_buf;
++ }
++
++ /* If there are any slashes in it, assume it's a relative path;
++ * make it absolute.
++ */
++ if (adb_dirstart(hint) != NULL) {
++ if (getcwd(path_buf, sizeof(path_buf)) == NULL) {
++ fprintf(stderr, "adb: Couldn't get CWD: %s\n", strerror(errno));
++ return NULL;
++ }
++ if (strlen(path_buf) + 1 + strlen(hint) >= sizeof(path_buf)) {
++ fprintf(stderr, "adb: Couldn't assemble path\n");
++ return NULL;
++ }
++ strcat(path_buf, OS_PATH_SEPARATOR_STR);
++ strcat(path_buf, hint);
++ return path_buf;
++ }
++
++ /* It's a string without any slashes. Try to do something with it.
++ *
++ * Try to find the root of the build tree, and build a PRODUCT_OUT
++ * path from there.
++ */
++ char top_buf[PATH_MAX];
++ const char *top = find_top(top_buf);
++ if (top == NULL) {
++ fprintf(stderr, "adb: Couldn't find top of build tree\n");
++ return NULL;
++ }
++//TODO: if we have a way to indicate debug, look in out/debug/target/...
++ snprintf(path_buf, sizeof(path_buf),
++ "%s" OS_PATH_SEPARATOR_STR
++ "out" OS_PATH_SEPARATOR_STR
++ "target" OS_PATH_SEPARATOR_STR
++ "product" OS_PATH_SEPARATOR_STR
++ "%s", top_buf, hint);
++ if (access(path_buf, F_OK) < 0) {
++ fprintf(stderr, "adb: Couldn't find a product dir "
++ "based on \"-p %s\"; \"%s\" doesn't exist\n", hint, path_buf);
++ return NULL;
++ }
++ return path_buf;
++}
++
++int adb_commandline(int argc, char **argv)
++{
++ char buf[4096];
++ int no_daemon = 0;
++ int is_daemon = 0;
++ int is_server = 0;
++ int persist = 0;
++ int r;
++ int quote;
++ transport_type ttype = kTransportAny;
++ char* serial = NULL;
++ char* server_port_str = NULL;
++
++ /* If defined, this should be an absolute path to
++ * the directory containing all of the various system images
++ * for a particular product. If not defined, and the adb
++ * command requires this information, then the user must
++ * specify the path using "-p".
++ */
++ gProductOutPath = getenv("ANDROID_PRODUCT_OUT");
++ if (gProductOutPath == NULL || gProductOutPath[0] == '\0') {
++ gProductOutPath = NULL;
++ }
++ // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint
++
++ serial = getenv("ANDROID_SERIAL");
++
++ /* Validate and assign the server port */
++ server_port_str = getenv("ANDROID_ADB_SERVER_PORT");
++ int server_port = DEFAULT_ADB_PORT;
++ if (server_port_str && strlen(server_port_str) > 0) {
++ server_port = (int) strtol(server_port_str, NULL, 0);
++ if (server_port <= 0 || server_port > 65535) {
++ fprintf(stderr,
++ "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. Got \"%s\"\n",
++ server_port_str);
++ return usage();
++ }
++ }
++
++ /* modifiers and flags */
++ while(argc > 0) {
++ if(!strcmp(argv[0],"server")) {
++ is_server = 1;
++ } else if(!strcmp(argv[0],"nodaemon")) {
++ no_daemon = 1;
++ } else if (!strcmp(argv[0], "fork-server")) {
++ /* this is a special flag used only when the ADB client launches the ADB Server */
++ is_daemon = 1;
++ } else if(!strcmp(argv[0],"persist")) {
++ persist = 1;
++ } else if(!strncmp(argv[0], "-p", 2)) {
++ const char *product = NULL;
++ if (argv[0][2] == '\0') {
++ if (argc < 2) return usage();
++ product = argv[1];
++ argc--;
++ argv++;
++ } else {
++ product = argv[0] + 2;
++ }
++ gProductOutPath = find_product_out_path(product);
++ if (gProductOutPath == NULL) {
++ fprintf(stderr, "adb: could not resolve \"-p %s\"\n",
++ product);
++ return usage();
++ }
++ } else if (argv[0][0]=='-' && argv[0][1]=='s') {
++ if (isdigit(argv[0][2])) {
++ serial = argv[0] + 2;
++ } else {
++ if(argc < 2 || argv[0][2] != '\0') return usage();
++ serial = argv[1];
++ argc--;
++ argv++;
++ }
++ } else if (!strcmp(argv[0],"-d")) {
++ ttype = kTransportUsb;
++ } else if (!strcmp(argv[0],"-e")) {
++ ttype = kTransportLocal;
++ } else if (!strcmp(argv[0],"-a")) {
++ gListenAll = 1;
++ } else if(!strncmp(argv[0], "-H", 2)) {
++ const char *hostname = NULL;
++ if (argv[0][2] == '\0') {
++ if (argc < 2) return usage();
++ hostname = argv[1];
++ argc--;
++ argv++;
++ } else {
++ hostname = argv[0] + 2;
++ }
++ adb_set_tcp_name(hostname);
++
++ } else if(!strncmp(argv[0], "-P", 2)) {
++ if (argv[0][2] == '\0') {
++ if (argc < 2) return usage();
++ server_port_str = argv[1];
++ argc--;
++ argv++;
++ } else {
++ server_port_str = argv[0] + 2;
++ }
++ if (strlen(server_port_str) > 0) {
++ server_port = (int) strtol(server_port_str, NULL, 0);
++ if (server_port <= 0 || server_port > 65535) {
++ fprintf(stderr,
++ "adb: port number must be a positive number less than 65536. Got \"%s\"\n",
++ server_port_str);
++ return usage();
++ }
++ } else {
++ fprintf(stderr,
++ "adb: port number must be a positive number less than 65536. Got empty string.\n");
++ return usage();
++ }
++ } else {
++ /* out of recognized modifiers and flags */
++ break;
++ }
++ argc--;
++ argv++;
++ }
++
++ adb_set_transport(ttype, serial);
++ adb_set_tcp_specifics(server_port);
++
++ if (is_server) {
++ if (no_daemon || is_daemon) {
++ r = adb_main(is_daemon, server_port);
++ } else {
++ r = launch_server(server_port);
++ }
++ if(r) {
++ fprintf(stderr,"* could not start server *\n");
++ }
++ return r;
++ }
++
++top:
++ if(argc == 0) {
++ return usage();
++ }
++
++ /* adb_connect() commands */
++
++ if(!strcmp(argv[0], "devices")) {
++ char *tmp;
++ char *listopt;
++ if (argc < 2)
++ listopt = "";
++ else if (argc == 2 && !strcmp(argv[1], "-l"))
++ listopt = argv[1];
++ else {
++ fprintf(stderr, "Usage: adb devices [-l]\n");
++ return 1;
++ }
++ snprintf(buf, sizeof buf, "host:%s%s", argv[0], listopt);
++ tmp = adb_query(buf);
++ if(tmp) {
++ printf("List of devices attached \n");
++ printf("%s\n", tmp);
++ return 0;
++ } else {
++ return 1;
++ }
++ }
++
++ if(!strcmp(argv[0], "connect")) {
++ char *tmp;
++ if (argc != 2) {
++ fprintf(stderr, "Usage: adb connect <host>[:<port>]\n");
++ return 1;
++ }
++ snprintf(buf, sizeof buf, "host:connect:%s", argv[1]);
++ tmp = adb_query(buf);
++ if(tmp) {
++ printf("%s\n", tmp);
++ return 0;
++ } else {
++ return 1;
++ }
++ }
++
++ if(!strcmp(argv[0], "disconnect")) {
++ char *tmp;
++ if (argc > 2) {
++ fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n");
++ return 1;
++ }
++ if (argc == 2) {
++ snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]);
++ } else {
++ snprintf(buf, sizeof buf, "host:disconnect:");
++ }
++ tmp = adb_query(buf);
++ if(tmp) {
++ printf("%s\n", tmp);
++ return 0;
++ } else {
++ return 1;
++ }
++ }
++
++ if (!strcmp(argv[0], "emu")) {
++ return adb_send_emulator_command(argc, argv);
++ }
++
++ if(!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) {
++ int r;
++ int fd;
++
++ char h = (argv[0][0] == 'h');
++
++ if (h) {
++ printf("\x1b[41;33m");
++ fflush(stdout);
++ }
++
++ if(argc < 2) {
++ D("starting interactive shell\n");
++ r = interactive_shell();
++ if (h) {
++ printf("\x1b[0m");
++ fflush(stdout);
++ }
++ return r;
++ }
++
++ snprintf(buf, sizeof buf, "shell:%s", argv[1]);
++ argc -= 2;
++ argv += 2;
++ while(argc-- > 0) {
++ strcat(buf, " ");
++
++ /* quote empty strings and strings with spaces */
++ quote = (**argv == 0 || strchr(*argv, ' '));
++ if (quote)
++ strcat(buf, "\"");
++ strcat(buf, *argv++);
++ if (quote)
++ strcat(buf, "\"");
++ }
++
++ for(;;) {
++ D("interactive shell loop. buff=%s\n", buf);
++ fd = adb_connect(buf);
++ if(fd >= 0) {
++ D("about to read_and_dump(fd=%d)\n", fd);
++ read_and_dump(fd);
++ D("read_and_dump() done.\n");
++ adb_close(fd);
++ r = 0;
++ } else {
++ fprintf(stderr,"error: %s\n", adb_error());
++ r = -1;
++ }
++
++ if(persist) {
++ fprintf(stderr,"\n- waiting for device -\n");
++ adb_sleep_ms(1000);
++ do_cmd(ttype, serial, "wait-for-device", 0);
++ } else {
++ if (h) {
++ printf("\x1b[0m");
++ fflush(stdout);
++ }
++ D("interactive shell loop. return r=%d\n", r);
++ return r;
++ }
++ }
++ }
++
++ if(!strcmp(argv[0], "kill-server")) {
++ int fd;
++ fd = _adb_connect("host:kill");
++ if(fd == -1) {
++ fprintf(stderr,"* server not running *\n");
++ return 1;
++ }
++ return 0;
++ }
++
++ if(!strcmp(argv[0], "sideload")) {
++ if(argc != 2) return usage();
++ if(adb_download("sideload", argv[1], 1)) {
++ return 1;
++ } else {
++ return 0;
++ }
++ }
++
++ if(!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot")
++ || !strcmp(argv[0], "reboot-bootloader")
++ || !strcmp(argv[0], "tcpip") || !strcmp(argv[0], "usb")
++ || !strcmp(argv[0], "root")) {
++ char command[100];
++ if (!strcmp(argv[0], "reboot-bootloader"))
++ snprintf(command, sizeof(command), "reboot:bootloader");
++ else if (argc > 1)
++ snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]);
++ else
++ snprintf(command, sizeof(command), "%s:", argv[0]);
++ int fd = adb_connect(command);
++ if(fd >= 0) {
++ read_and_dump(fd);
++ adb_close(fd);
++ return 0;
++ }
++ fprintf(stderr,"error: %s\n", adb_error());
++ return 1;
++ }
++
++ if(!strcmp(argv[0], "bugreport")) {
++ if (argc != 1) return usage();
++ do_cmd(ttype, serial, "shell", "bugreport", 0);
++ return 0;
++ }
++
++ /* adb_command() wrapper commands */
++
++ if(!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) {
++ char* service = argv[0];
++ if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) {
++ if (ttype == kTransportUsb) {
++ service = "wait-for-usb";
++ } else if (ttype == kTransportLocal) {
++ service = "wait-for-local";
++ } else {
++ service = "wait-for-any";
++ }
++ }
++
++ format_host_command(buf, sizeof buf, service, ttype, serial);
++
++ if (adb_command(buf)) {
++ D("failure: %s *\n",adb_error());
++ fprintf(stderr,"error: %s\n", adb_error());
++ return 1;
++ }
++
++ /* Allow a command to be run after wait-for-device,
++ * e.g. 'adb wait-for-device shell'.
++ */
++ if(argc > 1) {
++ argc--;
++ argv++;
++ goto top;
++ }
++ return 0;
++ }
++
++ if(!strcmp(argv[0], "forward")) {
++ char host_prefix[64];
++ char remove = 0;
++ char remove_all = 0;
++ char list = 0;
++ char no_rebind = 0;
++
++ // Parse options here.
++ while (argc > 1 && argv[1][0] == '-') {
++ if (!strcmp(argv[1], "--list"))
++ list = 1;
++ else if (!strcmp(argv[1], "--remove"))
++ remove = 1;
++ else if (!strcmp(argv[1], "--remove-all"))
++ remove_all = 1;
++ else if (!strcmp(argv[1], "--no-rebind"))
++ no_rebind = 1;
++ else {
++ return usage();
++ }
++ argc--;
++ argv++;
++ }
++
++ // Ensure we can only use one option at a time.
++ if (list + remove + remove_all + no_rebind > 1) {
++ return usage();
++ }
++
++ // Determine the <host-prefix> for this command.
++ if (serial) {
++ snprintf(host_prefix, sizeof host_prefix, "host-serial:%s",
++ serial);
++ } else if (ttype == kTransportUsb) {
++ snprintf(host_prefix, sizeof host_prefix, "host-usb");
++ } else if (ttype == kTransportLocal) {
++ snprintf(host_prefix, sizeof host_prefix, "host-local");
++ } else {
++ snprintf(host_prefix, sizeof host_prefix, "host");
++ }
++
++ // Implement forward --list
++ if (list) {
++ if (argc != 1)
++ return usage();
++ snprintf(buf, sizeof buf, "%s:list-forward", host_prefix);
++ char* forwards = adb_query(buf);
++ if (forwards == NULL) {
++ fprintf(stderr, "error: %s\n", adb_error());
++ return 1;
++ }
++ printf("%s", forwards);
++ free(forwards);
++ return 0;
++ }
++
++ // Implement forward --remove-all
++ else if (remove_all) {
++ if (argc != 1)
++ return usage();
++ snprintf(buf, sizeof buf, "%s:killforward-all", host_prefix);
++ }
++
++ // Implement forward --remove <local>
++ else if (remove) {
++ if (argc != 2)
++ return usage();
++ snprintf(buf, sizeof buf, "%s:killforward:%s", host_prefix, argv[1]);
++ }
++ // Or implement one of:
++ // forward <local> <remote>
++ // forward --no-rebind <local> <remote>
++ else
++ {
++ if (argc != 3)
++ return usage();
++ const char* command = no_rebind ? "forward:norebind:" : "forward";
++ snprintf(buf, sizeof buf, "%s:%s:%s;%s", host_prefix, command, argv[1], argv[2]);
++ }
++
++ if(adb_command(buf)) {
++ fprintf(stderr,"error: %s\n", adb_error());
++ return 1;
++ }
++ return 0;
++ }
++
++ /* do_sync_*() commands */
++
++ if(!strcmp(argv[0], "ls")) {
++ if(argc != 2) return usage();
++ return do_sync_ls(argv[1]);
++ }
++
++ if(!strcmp(argv[0], "push")) {
++ if(argc != 3) return usage();
++ return do_sync_push(argv[1], argv[2], 0 /* no verify APK */);
++ }
++
++ if(!strcmp(argv[0], "pull")) {
++ if (argc == 2) {
++ return do_sync_pull(argv[1], ".");
++ } else if (argc == 3) {
++ return do_sync_pull(argv[1], argv[2]);
++ } else {
++ return usage();
++ }
++ }
++
++ if(!strcmp(argv[0], "install")) {
++ if (argc < 2) return usage();
++ return install_app(ttype, serial, argc, argv);
++ }
++
++ if(!strcmp(argv[0], "uninstall")) {
++ if (argc < 2) return usage();
++ return uninstall_app(ttype, serial, argc, argv);
++ }
++
++ if(!strcmp(argv[0], "sync")) {
++ char *srcarg, *android_srcpath, *data_srcpath;
++ int listonly = 0;
++
++ int ret;
++ if(argc < 2) {
++ /* No local path was specified. */
++ srcarg = NULL;
++ } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) {
++ listonly = 1;
++ if (argc == 3) {
++ srcarg = argv[2];
++ } else {
++ srcarg = NULL;
++ }
++ } else if(argc == 2) {
++ /* A local path or "android"/"data" arg was specified. */
++ srcarg = argv[1];
++ } else {
++ return usage();
++ }
++ ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath);
++ if(ret != 0) return usage();
++
++ if(android_srcpath != NULL)
++ ret = do_sync_sync(android_srcpath, "/system", listonly);
++ if(ret == 0 && data_srcpath != NULL)
++ ret = do_sync_sync(data_srcpath, "/data", listonly);
++
++ free(android_srcpath);
++ free(data_srcpath);
++ return ret;
++ }
++
++ /* passthrough commands */
++
++ if(!strcmp(argv[0],"get-state") ||
++ !strcmp(argv[0],"get-serialno") ||
++ !strcmp(argv[0],"get-devpath"))
++ {
++ char *tmp;
++
++ format_host_command(buf, sizeof buf, argv[0], ttype, serial);
++ tmp = adb_query(buf);
++ if(tmp) {
++ printf("%s\n", tmp);
++ return 0;
++ } else {
++ return 1;
++ }
++ }
++
++ /* other commands */
++
++ if(!strcmp(argv[0],"status-window")) {
++ status_window(ttype, serial);
++ return 0;
++ }
++
++ if(!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) {
++ return logcat(ttype, serial, argc, argv);
++ }
++
++ if(!strcmp(argv[0],"ppp")) {
++ return ppp(argc, argv);
++ }
++
++ if (!strcmp(argv[0], "start-server")) {
++ return adb_connect("host:start-server");
++ }
++
++ if (!strcmp(argv[0], "backup")) {
++ return backup(argc, argv);
++ }
++
++ if (!strcmp(argv[0], "restore")) {
++ return restore(argc, argv);
++ }
++
++ if (!strcmp(argv[0], "jdwp")) {
++ int fd = adb_connect("jdwp");
++ if (fd >= 0) {
++ read_and_dump(fd);
++ adb_close(fd);
++ return 0;
++ } else {
++ fprintf(stderr, "error: %s\n", adb_error());
++ return -1;
++ }
++ }
++
++ /* "adb /?" is a common idiom under Windows */
++ if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {
++ help();
++ return 0;
++ }
++
++ if(!strcmp(argv[0], "version")) {
++ version(stdout);
++ return 0;
++ }
++
++ usage();
++ return 1;
++}
++
++static int do_cmd(transport_type ttype, char* serial, char *cmd, ...)
++{
++ char *argv[16];
++ int argc;
++ va_list ap;
++
++ va_start(ap, cmd);
++ argc = 0;
++
++ if (serial) {
++ argv[argc++] = "-s";
++ argv[argc++] = serial;
++ } else if (ttype == kTransportUsb) {
++ argv[argc++] = "-d";
++ } else if (ttype == kTransportLocal) {
++ argv[argc++] = "-e";
++ }
++
++ argv[argc++] = cmd;
++ while((argv[argc] = va_arg(ap, char*)) != 0) argc++;
++ va_end(ap);
++
++#if 0
++ int n;
++ fprintf(stderr,"argc = %d\n",argc);
++ for(n = 0; n < argc; n++) {
++ fprintf(stderr,"argv[%d] = \"%s\"\n", n, argv[n]);
++ }
++#endif
++
++ return adb_commandline(argc, argv);
++}
++
++int find_sync_dirs(const char *srcarg,
++ char **android_srcdir_out, char **data_srcdir_out)
++{
++ char *android_srcdir, *data_srcdir;
++
++ if(srcarg == NULL) {
++ android_srcdir = product_file("system");
++ data_srcdir = product_file("data");
++ } else {
++ /* srcarg may be "data", "system" or NULL.
++ * if srcarg is NULL, then both data and system are synced
++ */
++ if(strcmp(srcarg, "system") == 0) {
++ android_srcdir = product_file("system");
++ data_srcdir = NULL;
++ } else if(strcmp(srcarg, "data") == 0) {
++ android_srcdir = NULL;
++ data_srcdir = product_file("data");
++ } else {
++ /* It's not "system" or "data".
++ */
++ return 1;
++ }
++ }
++
++ if(android_srcdir_out != NULL)
++ *android_srcdir_out = android_srcdir;
++ else
++ free(android_srcdir);
++
++ if(data_srcdir_out != NULL)
++ *data_srcdir_out = data_srcdir;
++ else
++ free(data_srcdir);
++
++ return 0;
++}
++
++static int pm_command(transport_type transport, char* serial,
++ int argc, char** argv)
++{
++ char buf[4096];
++
++ snprintf(buf, sizeof(buf), "shell:pm");
++
++ while(argc-- > 0) {
++ char *quoted;
++
++ quoted = dupAndQuote(*argv++);
++
++ strncat(buf, " ", sizeof(buf)-1);
++ strncat(buf, quoted, sizeof(buf)-1);
++ free(quoted);
++ }
++
++ send_shellcommand(transport, serial, buf);
++ return 0;
++}
++
++int uninstall_app(transport_type transport, char* serial, int argc, char** argv)
++{
++ /* if the user choose the -k option, we refuse to do it until devices are
++ out with the option to uninstall the remaining data somehow (adb/ui) */
++ if (argc == 3 && strcmp(argv[1], "-k") == 0)
++ {
++ printf(
++ "The -k option uninstalls the application while retaining the data/cache.\n"
++ "At the moment, there is no way to remove the remaining data.\n"
++ "You will have to reinstall the application with the same signature, and fully uninstall it.\n"
++ "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]);
++ return -1;
++ }
++
++ /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */
++ return pm_command(transport, serial, argc, argv);
++}
++
++static int delete_file(transport_type transport, char* serial, char* filename)
++{
++ char buf[4096];
++ char* quoted;
++
++ snprintf(buf, sizeof(buf), "shell:rm ");
++ quoted = dupAndQuote(filename);
++ strncat(buf, quoted, sizeof(buf)-1);
++ free(quoted);
++
++ send_shellcommand(transport, serial, buf);
++ return 0;
++}
++
++static const char* get_basename(const char* filename)
++{
++ const char* basename = adb_dirstop(filename);
++ if (basename) {
++ basename++;
++ return basename;
++ } else {
++ return filename;
++ }
++}
++
++static int check_file(const char* filename)
++{
++ struct stat st;
++
++ if (filename == NULL) {
++ return 0;
++ }
++
++ if (stat(filename, &st) != 0) {
++ fprintf(stderr, "can't find '%s' to install\n", filename);
++ return 1;
++ }
++
++ if (!S_ISREG(st.st_mode)) {
++ fprintf(stderr, "can't install '%s' because it's not a file\n", filename);
++ return 1;
++ }
++
++ return 0;
++}
++
++int install_app(transport_type transport, char* serial, int argc, char** argv)
++{
++ static const char *const DATA_DEST = "/data/local/tmp/%s";
++ static const char *const SD_DEST = "/sdcard/tmp/%s";
++ const char* where = DATA_DEST;
++ char apk_dest[PATH_MAX];
++ char verification_dest[PATH_MAX];
++ char* apk_file;
++ char* verification_file = NULL;
++ int file_arg = -1;
++ int err;
++ int i;
++ int verify_apk = 1;
++
++ for (i = 1; i < argc; i++) {
++ if (*argv[i] != '-') {
++ file_arg = i;
++ break;
++ } else if (!strcmp(argv[i], "-i")) {
++ // Skip the installer package name.
++ i++;
++ } else if (!strcmp(argv[i], "-s")) {
++ where = SD_DEST;
++ } else if (!strcmp(argv[i], "--algo")) {
++ verify_apk = 0;
++ i++;
++ } else if (!strcmp(argv[i], "--iv")) {
++ verify_apk = 0;
++ i++;
++ } else if (!strcmp(argv[i], "--key")) {
++ verify_apk = 0;
++ i++;
++ }
++ }
++
++ if (file_arg < 0) {
++ fprintf(stderr, "can't find filename in arguments\n");
++ return 1;
++ } else if (file_arg + 2 < argc) {
++ fprintf(stderr, "too many files specified; only takes APK file and verifier file\n");
++ return 1;
++ }
++
++ apk_file = argv[file_arg];
++
++ if (file_arg != argc - 1) {
++ verification_file = argv[file_arg + 1];
++ }
++
++ if (check_file(apk_file) || check_file(verification_file)) {
++ return 1;
++ }
++
++ snprintf(apk_dest, sizeof apk_dest, where, get_basename(apk_file));
++ if (verification_file != NULL) {
++ snprintf(verification_dest, sizeof(verification_dest), where, get_basename(verification_file));
++
++ if (!strcmp(apk_dest, verification_dest)) {
++ fprintf(stderr, "APK and verification file can't have the same name\n");
++ return 1;
++ }
++ }
++
++ err = do_sync_push(apk_file, apk_dest, verify_apk);
++ if (err) {
++ goto cleanup_apk;
++ } else {
++ argv[file_arg] = apk_dest; /* destination name, not source location */
++ }
++
++ if (verification_file != NULL) {
++ err = do_sync_push(verification_file, verification_dest, 0 /* no verify APK */);
++ if (err) {
++ goto cleanup_apk;
++ } else {
++ argv[file_arg + 1] = verification_dest; /* destination name, not source location */
++ }
++ }
++
++ pm_command(transport, serial, argc, argv);
++
++cleanup_apk:
++ if (verification_file != NULL) {
++ delete_file(transport, serial, verification_dest);
++ }
++
++ delete_file(transport, serial, apk_dest);
++
++ return err;
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/console.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/console.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,45 @@
++#include "sysdeps.h"
++#include "adb.h"
++#include "adb_client.h"
++#include <stdio.h>
++
++static int connect_to_console(void)
++{
++ int fd, port;
++
++ port = adb_get_emulator_console_port();
++ if (port < 0) {
++ if (port == -2)
++ fprintf(stderr, "error: more than one emulator detected. use -s option\n");
++ else
++ fprintf(stderr, "error: no emulator detected\n");
++ return -1;
++ }
++ fd = socket_loopback_client( port, SOCK_STREAM );
++ if (fd < 0) {
++ fprintf(stderr, "error: could not connect to TCP port %d\n", port);
++ return -1;
++ }
++ return fd;
++}
++
++
++int adb_send_emulator_command(int argc, char** argv)
++{
++ int fd, nn;
++
++ fd = connect_to_console();
++ if (fd < 0)
++ return 1;
++
++#define QUIT "quit\n"
++
++ for (nn = 1; nn < argc; nn++) {
++ adb_write( fd, argv[nn], strlen(argv[nn]) );
++ adb_write( fd, (nn == argc-1) ? "\n" : " ", 1 );
++ }
++ adb_write( fd, QUIT, sizeof(QUIT)-1 );
++ adb_close(fd);
++
++ return 0;
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/fdevent.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/fdevent.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,695 @@
++/* http://frotznet.googlecode.com/svn/trunk/utils/fdevent.c
++**
++** Copyright 2006, Brian Swetland <swetland@frotz.net>
++**
++** Licensed under the Apache License, Version 2.0 (the "License");
++** you may not use this file except in compliance with the License.
++** You may obtain a copy of the License at
++**
++** http://www.apache.org/licenses/LICENSE-2.0
++**
++** Unless required by applicable law or agreed to in writing, software
++** distributed under the License is distributed on an "AS IS" BASIS,
++** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++** See the License for the specific language governing permissions and
++** limitations under the License.
++*/
++
++#include <sys/ioctl.h>
++
++#include <stdlib.h>
++#include <stdio.h>
++#include <string.h>
++#include <unistd.h>
++#include <errno.h>
++
++#include <fcntl.h>
++
++#include <stdarg.h>
++#include <stddef.h>
++
++#include "fdevent.h"
++#include "transport.h"
++#include "sysdeps.h"
++
++
++/* !!! Do not enable DEBUG for the adb that will run as the server:
++** both stdout and stderr are used to communicate between the client
++** and server. Any extra output will cause failures.
++*/
++#define DEBUG 0 /* non-0 will break adb server */
++
++// This socket is used when a subproc shell service exists.
++// It wakes up the fdevent_loop() and cause the correct handling
++// of the shell's pseudo-tty master. I.e. force close it.
++int SHELL_EXIT_NOTIFY_FD = -1;
++
++static void fatal(const char *fn, const char *fmt, ...)
++{
++ va_list ap;
++ va_start(ap, fmt);
++ fprintf(stderr, "%s:", fn);
++ vfprintf(stderr, fmt, ap);
++ va_end(ap);
++ abort();
++}
++
++#define FATAL(x...) fatal(__FUNCTION__, x)
++
++#if DEBUG
++#define D(...) \
++ do { \
++ adb_mutex_lock(&D_lock); \
++ int save_errno = errno; \
++ fprintf(stderr, "%s::%s():", __FILE__, __FUNCTION__); \
++ errno = save_errno; \
++ fprintf(stderr, __VA_ARGS__); \
++ adb_mutex_unlock(&D_lock); \
++ errno = save_errno; \
++ } while(0)
++static void dump_fde(fdevent *fde, const char *info)
++{
++ adb_mutex_lock(&D_lock);
++ fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd,
++ fde->state & FDE_READ ? 'R' : ' ',
++ fde->state & FDE_WRITE ? 'W' : ' ',
++ fde->state & FDE_ERROR ? 'E' : ' ',
++ info);
++ adb_mutex_unlock(&D_lock);
++}
++#else
++#define D(...) ((void)0)
++#define dump_fde(fde, info) do { } while(0)
++#endif
++
++#define FDE_EVENTMASK 0x00ff
++#define FDE_STATEMASK 0xff00
++
++#define FDE_ACTIVE 0x0100
++#define FDE_PENDING 0x0200
++#define FDE_CREATED 0x0400
++
++static void fdevent_plist_enqueue(fdevent *node);
++static void fdevent_plist_remove(fdevent *node);
++static fdevent *fdevent_plist_dequeue(void);
++static void fdevent_subproc_event_func(int fd, unsigned events, void *userdata);
++
++static fdevent list_pending = {
++ .next = &list_pending,
++ .prev = &list_pending,
++};
++
++static fdevent **fd_table = 0;
++static int fd_table_max = 0;
++
++#ifdef CRAPTASTIC
++//HAVE_EPOLL
++
++#include <sys/epoll.h>
++
++static int epoll_fd = -1;
++
++static void fdevent_init()
++{
++ /* XXX: what's a good size for the passed in hint? */
++ epoll_fd = epoll_create(256);
++
++ if(epoll_fd < 0) {
++ perror("epoll_create() failed");
++ exit(1);
++ }
++
++ /* mark for close-on-exec */
++ fcntl(epoll_fd, F_SETFD, FD_CLOEXEC);
++}
++
++static void fdevent_connect(fdevent *fde)
++{
++ struct epoll_event ev;
++
++ memset(&ev, 0, sizeof(ev));
++ ev.events = 0;
++ ev.data.ptr = fde;
++
++#if 0
++ if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fde->fd, &ev)) {
++ perror("epoll_ctl() failed\n");
++ exit(1);
++ }
++#endif
++}
++
++static void fdevent_disconnect(fdevent *fde)
++{
++ struct epoll_event ev;
++
++ memset(&ev, 0, sizeof(ev));
++ ev.events = 0;
++ ev.data.ptr = fde;
++
++ /* technically we only need to delete if we
++ ** were actively monitoring events, but let's
++ ** be aggressive and do it anyway, just in case
++ ** something's out of sync
++ */
++ epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fde->fd, &ev);
++}
++
++static void fdevent_update(fdevent *fde, unsigned events)
++{
++ struct epoll_event ev;
++ int active;
++
++ active = (fde->state & FDE_EVENTMASK) != 0;
++
++ memset(&ev, 0, sizeof(ev));
++ ev.events = 0;
++ ev.data.ptr = fde;
++
++ if(events & FDE_READ) ev.events |= EPOLLIN;
++ if(events & FDE_WRITE) ev.events |= EPOLLOUT;
++ if(events & FDE_ERROR) ev.events |= (EPOLLERR | EPOLLHUP);
++
++ fde->state = (fde->state & FDE_STATEMASK) | events;
++
++ if(active) {
++ /* we're already active. if we're changing to *no*
++ ** events being monitored, we need to delete, otherwise
++ ** we need to just modify
++ */
++ if(ev.events) {
++ if(epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fde->fd, &ev)) {
++ perror("epoll_ctl() failed\n");
++ exit(1);
++ }
++ } else {
++ if(epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fde->fd, &ev)) {
++ perror("epoll_ctl() failed\n");
++ exit(1);
++ }
++ }
++ } else {
++ /* we're not active. if we're watching events, we need
++ ** to add, otherwise we can just do nothing
++ */
++ if(ev.events) {
++ if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fde->fd, &ev)) {
++ perror("epoll_ctl() failed\n");
++ exit(1);
++ }
++ }
++ }
++}
++
++static void fdevent_process()
++{
++ struct epoll_event events[256];
++ fdevent *fde;
++ int i, n;
++
++ n = epoll_wait(epoll_fd, events, 256, -1);
++
++ if(n < 0) {
++ if(errno == EINTR) return;
++ perror("epoll_wait");
++ exit(1);
++ }
++
++ for(i = 0; i < n; i++) {
++ struct epoll_event *ev = events + i;
++ fde = ev->data.ptr;
++
++ if(ev->events & EPOLLIN) {
++ fde->events |= FDE_READ;
++ }
++ if(ev->events & EPOLLOUT) {
++ fde->events |= FDE_WRITE;
++ }
++ if(ev->events & (EPOLLERR | EPOLLHUP)) {
++ fde->events |= FDE_ERROR;
++ }
++ if(fde->events) {
++ if(fde->state & FDE_PENDING) continue;
++ fde->state |= FDE_PENDING;
++ fdevent_plist_enqueue(fde);
++ }
++ }
++}
++
++#else /* USE_SELECT */
++
++#ifdef HAVE_WINSOCK
++#include <winsock2.h>
++#else
++#include <sys/select.h>
++#endif
++
++static fd_set read_fds;
++static fd_set write_fds;
++static fd_set error_fds;
++
++static int select_n = 0;
++
++static void fdevent_init(void)
++{
++ FD_ZERO(&read_fds);
++ FD_ZERO(&write_fds);
++ FD_ZERO(&error_fds);
++}
++
++static void fdevent_connect(fdevent *fde)
++{
++ if(fde->fd >= select_n) {
++ select_n = fde->fd + 1;
++ }
++}
++
++static void fdevent_disconnect(fdevent *fde)
++{
++ int i, n;
++
++ FD_CLR(fde->fd, &read_fds);
++ FD_CLR(fde->fd, &write_fds);
++ FD_CLR(fde->fd, &error_fds);
++
++ for(n = 0, i = 0; i < select_n; i++) {
++ if(fd_table[i] != 0) n = i;
++ }
++ select_n = n + 1;
++}
++
++static void fdevent_update(fdevent *fde, unsigned events)
++{
++ if(events & FDE_READ) {
++ FD_SET(fde->fd, &read_fds);
++ } else {
++ FD_CLR(fde->fd, &read_fds);
++ }
++ if(events & FDE_WRITE) {
++ FD_SET(fde->fd, &write_fds);
++ } else {
++ FD_CLR(fde->fd, &write_fds);
++ }
++ if(events & FDE_ERROR) {
++ FD_SET(fde->fd, &error_fds);
++ } else {
++ FD_CLR(fde->fd, &error_fds);
++ }
++
++ fde->state = (fde->state & FDE_STATEMASK) | events;
++}
++
++/* Looks at fd_table[] for bad FDs and sets bit in fds.
++** Returns the number of bad FDs.
++*/
++static int fdevent_fd_check(fd_set *fds)
++{
++ int i, n = 0;
++ fdevent *fde;
++
++ for(i = 0; i < select_n; i++) {
++ fde = fd_table[i];
++ if(fde == 0) continue;
++ if(fcntl(i, F_GETFL, NULL) < 0) {
++ FD_SET(i, fds);
++ n++;
++ // fde->state |= FDE_DONT_CLOSE;
++
++ }
++ }
++ return n;
++}
++
++#if !DEBUG
++static inline void dump_all_fds(const char *extra_msg) {}
++#else
++static void dump_all_fds(const char *extra_msg)
++{
++int i;
++ fdevent *fde;
++ // per fd: 4 digits (but really: log10(FD_SETSIZE)), 1 staus, 1 blank
++ char msg_buff[FD_SETSIZE*6 + 1], *pb=msg_buff;
++ size_t max_chars = FD_SETSIZE * 6 + 1;
++ int printed_out;
++#define SAFE_SPRINTF(...) \
++ do { \
++ printed_out = snprintf(pb, max_chars, __VA_ARGS__); \
++ if (printed_out <= 0) { \
++ D("... snprintf failed.\n"); \
++ return; \
++ } \
++ if (max_chars < (unsigned int)printed_out) { \
++ D("... snprintf out of space.\n"); \
++ return; \
++ } \
++ pb += printed_out; \
++ max_chars -= printed_out; \
++ } while(0)
++
++ for(i = 0; i < select_n; i++) {
++ fde = fd_table[i];
++ SAFE_SPRINTF("%d", i);
++ if(fde == 0) {
++ SAFE_SPRINTF("? ");
++ continue;
++ }
++ if(fcntl(i, F_GETFL, NULL) < 0) {
++ SAFE_SPRINTF("b");
++ }
++ SAFE_SPRINTF(" ");
++ }
++ D("%s fd_table[]->fd = {%s}\n", extra_msg, msg_buff);
++}
++#endif
++
++static void fdevent_process()
++{
++ int i, n;
++ fdevent *fde;
++ unsigned events;
++ fd_set rfd, wfd, efd;
++
++ memcpy(&rfd, &read_fds, sizeof(fd_set));
++ memcpy(&wfd, &write_fds, sizeof(fd_set));
++ memcpy(&efd, &error_fds, sizeof(fd_set));
++
++ dump_all_fds("pre select()");
++
++ n = select(select_n, &rfd, &wfd, &efd, NULL);
++ int saved_errno = errno;
++ D("select() returned n=%d, errno=%d\n", n, n<0?saved_errno:0);
++
++ dump_all_fds("post select()");
++
++ if(n < 0) {
++ switch(saved_errno) {
++ case EINTR: return;
++ case EBADF:
++ // Can't trust the FD sets after an error.
++ FD_ZERO(&wfd);
++ FD_ZERO(&efd);
++ FD_ZERO(&rfd);
++ break;
++ default:
++ D("Unexpected select() error=%d\n", saved_errno);
++ return;
++ }
++ }
++ if(n <= 0) {
++ // We fake a read, as the rest of the code assumes
++ // that errors will be detected at that point.
++ n = fdevent_fd_check(&rfd);
++ }
++
++ for(i = 0; (i < select_n) && (n > 0); i++) {
++ events = 0;
++ if(FD_ISSET(i, &rfd)) { events |= FDE_READ; n--; }
++ if(FD_ISSET(i, &wfd)) { events |= FDE_WRITE; n--; }
++ if(FD_ISSET(i, &efd)) { events |= FDE_ERROR; n--; }
++
++ if(events) {
++ fde = fd_table[i];
++ if(fde == 0)
++ FATAL("missing fde for fd %d\n", i);
++
++ fde->events |= events;
++
++ D("got events fde->fd=%d events=%04x, state=%04x\n",
++ fde->fd, fde->events, fde->state);
++ if(fde->state & FDE_PENDING) continue;
++ fde->state |= FDE_PENDING;
++ fdevent_plist_enqueue(fde);
++ }
++ }
++}
++
++#endif
++
++static void fdevent_register(fdevent *fde)
++{
++ if(fde->fd < 0) {
++ FATAL("bogus negative fd (%d)\n", fde->fd);
++ }
++
++ if(fde->fd >= fd_table_max) {
++ int oldmax = fd_table_max;
++ if(fde->fd > 32000) {
++ FATAL("bogus huuuuge fd (%d)\n", fde->fd);
++ }
++ if(fd_table_max == 0) {
++ fdevent_init();
++ fd_table_max = 256;
++ }
++ while(fd_table_max <= fde->fd) {
++ fd_table_max *= 2;
++ }
++ fd_table = realloc(fd_table, sizeof(fdevent*) * fd_table_max);
++ if(fd_table == 0) {
++ FATAL("could not expand fd_table to %d entries\n", fd_table_max);
++ }
++ memset(fd_table + oldmax, 0, sizeof(int) * (fd_table_max - oldmax));
++ }
++
++ fd_table[fde->fd] = fde;
++}
++
++static void fdevent_unregister(fdevent *fde)
++{
++ if((fde->fd < 0) || (fde->fd >= fd_table_max)) {
++ FATAL("fd out of range (%d)\n", fde->fd);
++ }
++
++ if(fd_table[fde->fd] != fde) {
++ FATAL("fd_table out of sync [%d]\n", fde->fd);
++ }
++
++ fd_table[fde->fd] = 0;
++
++ if(!(fde->state & FDE_DONT_CLOSE)) {
++ dump_fde(fde, "close");
++ adb_close(fde->fd);
++ }
++}
++
++static void fdevent_plist_enqueue(fdevent *node)
++{
++ fdevent *list = &list_pending;
++
++ node->next = list;
++ node->prev = list->prev;
++ node->prev->next = node;
++ list->prev = node;
++}
++
++static void fdevent_plist_remove(fdevent *node)
++{
++ node->prev->next = node->next;
++ node->next->prev = node->prev;
++ node->next = 0;
++ node->prev = 0;
++}
++
++static fdevent *fdevent_plist_dequeue(void)
++{
++ fdevent *list = &list_pending;
++ fdevent *node = list->next;
++
++ if(node == list) return 0;
++
++ list->next = node->next;
++ list->next->prev = list;
++ node->next = 0;
++ node->prev = 0;
++
++ return node;
++}
++
++static void fdevent_call_fdfunc(fdevent* fde)
++{
++ unsigned events = fde->events;
++ fde->events = 0;
++ if(!(fde->state & FDE_PENDING)) return;
++ fde->state &= (~FDE_PENDING);
++ dump_fde(fde, "callback");
++ fde->func(fde->fd, events, fde->arg);
++}
++
++static void fdevent_subproc_event_func(int fd, unsigned ev, void *userdata)
++{
++
++ D("subproc handling on fd=%d ev=%04x\n", fd, ev);
++
++ // Hook oneself back into the fde's suitable for select() on read.
++ if((fd < 0) || (fd >= fd_table_max)) {
++ FATAL("fd %d out of range for fd_table \n", fd);
++ }
++ fdevent *fde = fd_table[fd];
++ fdevent_add(fde, FDE_READ);
++
++ if(ev & FDE_READ){
++ int subproc_fd;
++
++ if(readx(fd, &subproc_fd, sizeof(subproc_fd))) {
++ FATAL("Failed to read the subproc's fd from fd=%d\n", fd);
++ }
++ if((subproc_fd < 0) || (subproc_fd >= fd_table_max)) {
++ D("subproc_fd %d out of range 0, fd_table_max=%d\n",
++ subproc_fd, fd_table_max);
++ return;
++ }
++ fdevent *subproc_fde = fd_table[subproc_fd];
++ if(!subproc_fde) {
++ D("subproc_fd %d cleared from fd_table\n", subproc_fd);
++ return;
++ }
++ if(subproc_fde->fd != subproc_fd) {
++ // Already reallocated?
++ D("subproc_fd %d != fd_table[].fd %d\n", subproc_fd, subproc_fde->fd);
++ return;
++ }
++
++ subproc_fde->force_eof = 1;
++
++ int rcount = 0;
++ ioctl(subproc_fd, FIONREAD, &rcount);
++ D("subproc with fd=%d has rcount=%d err=%d\n",
++ subproc_fd, rcount, errno);
++
++ if(rcount) {
++ // If there is data left, it will show up in the select().
++ // This works because there is no other thread reading that
++ // data when in this fd_func().
++ return;
++ }
++
++ D("subproc_fde.state=%04x\n", subproc_fde->state);
++ subproc_fde->events |= FDE_READ;
++ if(subproc_fde->state & FDE_PENDING) {
++ return;
++ }
++ subproc_fde->state |= FDE_PENDING;
++ fdevent_call_fdfunc(subproc_fde);
++ }
++}
++
++fdevent *fdevent_create(int fd, fd_func func, void *arg)
++{
++ fdevent *fde = (fdevent*) malloc(sizeof(fdevent));
++ if(fde == 0) return 0;
++ fdevent_install(fde, fd, func, arg);
++ fde->state |= FDE_CREATED;
++ return fde;
++}
++
++void fdevent_destroy(fdevent *fde)
++{
++ if(fde == 0) return;
++ if(!(fde->state & FDE_CREATED)) {
++ FATAL("fde %p not created by fdevent_create()\n", fde);
++ }
++ fdevent_remove(fde);
++}
++
++void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
++{
++ memset(fde, 0, sizeof(fdevent));
++ fde->state = FDE_ACTIVE;
++ fde->fd = fd;
++ fde->force_eof = 0;
++ fde->func = func;
++ fde->arg = arg;
++
++#ifndef HAVE_WINSOCK
++ fcntl(fd, F_SETFL, O_NONBLOCK);
++#endif
++ fdevent_register(fde);
++ dump_fde(fde, "connect");
++ fdevent_connect(fde);
++ fde->state |= FDE_ACTIVE;
++}
++
++void fdevent_remove(fdevent *fde)
++{
++ if(fde->state & FDE_PENDING) {
++ fdevent_plist_remove(fde);
++ }
++
++ if(fde->state & FDE_ACTIVE) {
++ fdevent_disconnect(fde);
++ dump_fde(fde, "disconnect");
++ fdevent_unregister(fde);
++ }
++
++ fde->state = 0;
++ fde->events = 0;
++}
++
++
++void fdevent_set(fdevent *fde, unsigned events)
++{
++ events &= FDE_EVENTMASK;
++
++ if((fde->state & FDE_EVENTMASK) == events) return;
++
++ if(fde->state & FDE_ACTIVE) {
++ fdevent_update(fde, events);
++ dump_fde(fde, "update");
++ }
++
++ fde->state = (fde->state & FDE_STATEMASK) | events;
++
++ if(fde->state & FDE_PENDING) {
++ /* if we're pending, make sure
++ ** we don't signal an event that
++ ** is no longer wanted.
++ */
++ fde->events &= (~events);
++ if(fde->events == 0) {
++ fdevent_plist_remove(fde);
++ fde->state &= (~FDE_PENDING);
++ }
++ }
++}
++
++void fdevent_add(fdevent *fde, unsigned events)
++{
++ fdevent_set(
++ fde, (fde->state & FDE_EVENTMASK) | (events & FDE_EVENTMASK));
++}
++
++void fdevent_del(fdevent *fde, unsigned events)
++{
++ fdevent_set(
++ fde, (fde->state & FDE_EVENTMASK) & (~(events & FDE_EVENTMASK)));
++}
++
++void fdevent_subproc_setup()
++{
++ int s[2];
++
++ if(adb_socketpair(s)) {
++ FATAL("cannot create shell-exit socket-pair\n");
++ }
++ SHELL_EXIT_NOTIFY_FD = s[0];
++ fdevent *fde;
++ fde = fdevent_create(s[1], fdevent_subproc_event_func, NULL);
++ if(!fde)
++ FATAL("cannot create fdevent for shell-exit handler\n");
++ fdevent_add(fde, FDE_READ);
++}
++
++void fdevent_loop()
++{
++ fdevent *fde;
++ fdevent_subproc_setup();
++
++ for(;;) {
++ D("--- ---- waiting for events\n");
++
++ fdevent_process();
++
++ while((fde = fdevent_plist_dequeue())) {
++ fdevent_call_fdfunc(fde);
++ }
++ }
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/fdevent.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/fdevent.h 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,83 @@
++/*
++ * Copyright (C) 2006 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 __FDEVENT_H
++#define __FDEVENT_H
++
++#include <stdint.h> /* for int64_t */
++
++/* events that may be observed */
++#define FDE_READ 0x0001
++#define FDE_WRITE 0x0002
++#define FDE_ERROR 0x0004
++#define FDE_TIMEOUT 0x0008
++
++/* features that may be set (via the events set/add/del interface) */
++#define FDE_DONT_CLOSE 0x0080
++
++typedef struct fdevent fdevent;
++
++typedef void (*fd_func)(int fd, unsigned events, void *userdata);
++
++/* Allocate and initialize a new fdevent object
++ * Note: use FD_TIMER as 'fd' to create a fd-less object
++ * (used to implement timers).
++*/
++fdevent *fdevent_create(int fd, fd_func func, void *arg);
++
++/* Uninitialize and deallocate an fdevent object that was
++** created by fdevent_create()
++*/
++void fdevent_destroy(fdevent *fde);
++
++/* Initialize an fdevent object that was externally allocated
++*/
++void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg);
++
++/* Uninitialize an fdevent object that was initialized by
++** fdevent_install()
++*/
++void fdevent_remove(fdevent *item);
++
++/* Change which events should cause notifications
++*/
++void fdevent_set(fdevent *fde, unsigned events);
++void fdevent_add(fdevent *fde, unsigned events);
++void fdevent_del(fdevent *fde, unsigned events);
++
++void fdevent_set_timeout(fdevent *fde, int64_t timeout_ms);
++
++/* loop forever, handling events.
++*/
++void fdevent_loop();
++
++struct fdevent
++{
++ fdevent *next;
++ fdevent *prev;
++
++ int fd;
++ int force_eof;
++
++ unsigned short state;
++ unsigned short events;
++
++ fd_func func;
++ void *arg;
++};
++
++
++#endif
+Index: android-tools-4.2.2+git20130218/core/adbd/file_sync_client.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/file_sync_client.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,1024 @@
++/*
++ * 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.
++ */
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <errno.h>
++#include <sys/stat.h>
++#include <sys/time.h>
++#include <time.h>
++#include <dirent.h>
++#include <limits.h>
++#include <sys/types.h>
++#include <zipfile/zipfile.h>
++
++#include "sysdeps.h"
++#include "adb.h"
++#include "adb_client.h"
++#include "file_sync_service.h"
++
++
++static unsigned total_bytes;
++static long long start_time;
++
++static long long NOW()
++{
++ struct timeval tv;
++ gettimeofday(&tv, 0);
++ return ((long long) tv.tv_usec) +
++ 1000000LL * ((long long) tv.tv_sec);
++}
++
++static void BEGIN()
++{
++ total_bytes = 0;
++ start_time = NOW();
++}
++
++static void END()
++{
++ long long t = NOW() - start_time;
++ if(total_bytes == 0) return;
++
++ if (t == 0) /* prevent division by 0 :-) */
++ t = 1000000;
++
++ fprintf(stderr,"%lld KB/s (%lld bytes in %lld.%03llds)\n",
++ ((((long long) total_bytes) * 1000000LL) / t) / 1024LL,
++ (long long) total_bytes, (t / 1000000LL), (t % 1000000LL) / 1000LL);
++}
++
++void sync_quit(int fd)
++{
++ syncmsg msg;
++
++ msg.req.id = ID_QUIT;
++ msg.req.namelen = 0;
++
++ writex(fd, &msg.req, sizeof(msg.req));
++}
++
++typedef void (*sync_ls_cb)(unsigned mode, unsigned size, unsigned time, const char *name, void *cookie);
++
++int sync_ls(int fd, const char *path, sync_ls_cb func, void *cookie)
++{
++ syncmsg msg;
++ char buf[257];
++ int len;
++
++ len = strlen(path);
++ if(len > 1024) goto fail;
++
++ msg.req.id = ID_LIST;
++ msg.req.namelen = htoll(len);
++
++ if(writex(fd, &msg.req, sizeof(msg.req)) ||
++ writex(fd, path, len)) {
++ goto fail;
++ }
++
++ for(;;) {
++ if(readx(fd, &msg.dent, sizeof(msg.dent))) break;
++ if(msg.dent.id == ID_DONE) return 0;
++ if(msg.dent.id != ID_DENT) break;
++
++ len = ltohl(msg.dent.namelen);
++ if(len > 256) break;
++
++ if(readx(fd, buf, len)) break;
++ buf[len] = 0;
++
++ func(ltohl(msg.dent.mode),
++ ltohl(msg.dent.size),
++ ltohl(msg.dent.time),
++ buf, cookie);
++ }
++
++fail:
++ adb_close(fd);
++ return -1;
++}
++
++typedef struct syncsendbuf syncsendbuf;
++
++struct syncsendbuf {
++ unsigned id;
++ unsigned size;
++ char data[SYNC_DATA_MAX];
++};
++
++static syncsendbuf send_buffer;
++
++int sync_readtime(int fd, const char *path, unsigned *timestamp)
++{
++ syncmsg msg;
++ int len = strlen(path);
++
++ msg.req.id = ID_STAT;
++ msg.req.namelen = htoll(len);
++
++ if(writex(fd, &msg.req, sizeof(msg.req)) ||
++ writex(fd, path, len)) {
++ return -1;
++ }
++
++ if(readx(fd, &msg.stat, sizeof(msg.stat))) {
++ return -1;
++ }
++
++ if(msg.stat.id != ID_STAT) {
++ return -1;
++ }
++
++ *timestamp = ltohl(msg.stat.time);
++ return 0;
++}
++
++static int sync_start_readtime(int fd, const char *path)
++{
++ syncmsg msg;
++ int len = strlen(path);
++
++ msg.req.id = ID_STAT;
++ msg.req.namelen = htoll(len);
++
++ if(writex(fd, &msg.req, sizeof(msg.req)) ||
++ writex(fd, path, len)) {
++ return -1;
++ }
++
++ return 0;
++}
++
++static int sync_finish_readtime(int fd, unsigned int *timestamp,
++ unsigned int *mode, unsigned int *size)
++{
++ syncmsg msg;
++
++ if(readx(fd, &msg.stat, sizeof(msg.stat)))
++ return -1;
++
++ if(msg.stat.id != ID_STAT)
++ return -1;
++
++ *timestamp = ltohl(msg.stat.time);
++ *mode = ltohl(msg.stat.mode);
++ *size = ltohl(msg.stat.size);
++
++ return 0;
++}
++
++int sync_readmode(int fd, const char *path, unsigned *mode)
++{
++ syncmsg msg;
++ int len = strlen(path);
++
++ msg.req.id = ID_STAT;
++ msg.req.namelen = htoll(len);
++
++ if(writex(fd, &msg.req, sizeof(msg.req)) ||
++ writex(fd, path, len)) {
++ return -1;
++ }
++
++ if(readx(fd, &msg.stat, sizeof(msg.stat))) {
++ return -1;
++ }
++
++ if(msg.stat.id != ID_STAT) {
++ return -1;
++ }
++
++ *mode = ltohl(msg.stat.mode);
++ return 0;
++}
++
++static int write_data_file(int fd, const char *path, syncsendbuf *sbuf)
++{
++ int lfd, err = 0;
++
++ lfd = adb_open(path, O_RDONLY);
++ if(lfd < 0) {
++ fprintf(stderr,"cannot open '%s': %s\n", path, strerror(errno));
++ return -1;
++ }
++
++ sbuf->id = ID_DATA;
++ for(;;) {
++ int ret;
++
++ ret = adb_read(lfd, sbuf->data, SYNC_DATA_MAX);
++ if(!ret)
++ break;
++
++ if(ret < 0) {
++ if(errno == EINTR)
++ continue;
++ fprintf(stderr,"cannot read '%s': %s\n", path, strerror(errno));
++ break;
++ }
++
++ sbuf->size = htoll(ret);
++ if(writex(fd, sbuf, sizeof(unsigned) * 2 + ret)){
++ err = -1;
++ break;
++ }
++ total_bytes += ret;
++ }
++
++ adb_close(lfd);
++ return err;
++}
++
++static int write_data_buffer(int fd, char* file_buffer, int size, syncsendbuf *sbuf)
++{
++ int err = 0;
++ int total = 0;
++
++ sbuf->id = ID_DATA;
++ while (total < size) {
++ int count = size - total;
++ if (count > SYNC_DATA_MAX) {
++ count = SYNC_DATA_MAX;
++ }
++
++ memcpy(sbuf->data, &file_buffer[total], count);
++ sbuf->size = htoll(count);
++ if(writex(fd, sbuf, sizeof(unsigned) * 2 + count)){
++ err = -1;
++ break;
++ }
++ total += count;
++ total_bytes += count;
++ }
++
++ return err;
++}
++
++#ifdef HAVE_SYMLINKS
++static int write_data_link(int fd, const char *path, syncsendbuf *sbuf)
++{
++ int len, ret;
++
++ len = readlink(path, sbuf->data, SYNC_DATA_MAX-1);
++ if(len < 0) {
++ fprintf(stderr, "error reading link '%s': %s\n", path, strerror(errno));
++ return -1;
++ }
++ sbuf->data[len] = '\0';
++
++ sbuf->size = htoll(len + 1);
++ sbuf->id = ID_DATA;
++
++ ret = writex(fd, sbuf, sizeof(unsigned) * 2 + len + 1);
++ if(ret)
++ return -1;
++
++ total_bytes += len + 1;
++
++ return 0;
++}
++#endif
++
++static int sync_send(int fd, const char *lpath, const char *rpath,
++ unsigned mtime, mode_t mode, int verifyApk)
++{
++ syncmsg msg;
++ int len, r;
++ syncsendbuf *sbuf = &send_buffer;
++ char* file_buffer = NULL;
++ int size = 0;
++ char tmp[64];
++
++ len = strlen(rpath);
++ if(len > 1024) goto fail;
++
++ snprintf(tmp, sizeof(tmp), ",%d", mode);
++ r = strlen(tmp);
++
++ if (verifyApk) {
++ int lfd;
++ zipfile_t zip;
++ zipentry_t entry;
++ int amt;
++
++ // if we are transferring an APK file, then sanity check to make sure
++ // we have a real zip file that contains an AndroidManifest.xml
++ // this requires that we read the entire file into memory.
++ lfd = adb_open(lpath, O_RDONLY);
++ if(lfd < 0) {
++ fprintf(stderr,"cannot open '%s': %s\n", lpath, strerror(errno));
++ return -1;
++ }
++
++ size = adb_lseek(lfd, 0, SEEK_END);
++ if (size == -1 || -1 == adb_lseek(lfd, 0, SEEK_SET)) {
++ fprintf(stderr, "error seeking in file '%s'\n", lpath);
++ adb_close(lfd);
++ return 1;
++ }
++
++ file_buffer = (char *)malloc(size);
++ if (file_buffer == NULL) {
++ fprintf(stderr, "could not allocate buffer for '%s'\n",
++ lpath);
++ adb_close(lfd);
++ return 1;
++ }
++ amt = adb_read(lfd, file_buffer, size);
++ if (amt != size) {
++ fprintf(stderr, "error reading from file: '%s'\n", lpath);
++ adb_close(lfd);
++ free(file_buffer);
++ return 1;
++ }
++
++ adb_close(lfd);
++
++ zip = init_zipfile(file_buffer, size);
++ if (zip == NULL) {
++ fprintf(stderr, "file '%s' is not a valid zip file\n",
++ lpath);
++ free(file_buffer);
++ return 1;
++ }
++
++ entry = lookup_zipentry(zip, "AndroidManifest.xml");
++ release_zipfile(zip);
++ if (entry == NULL) {
++ fprintf(stderr, "file '%s' does not contain AndroidManifest.xml\n",
++ lpath);
++ free(file_buffer);
++ return 1;
++ }
++ }
++
++ msg.req.id = ID_SEND;
++ msg.req.namelen = htoll(len + r);
++
++ if(writex(fd, &msg.req, sizeof(msg.req)) ||
++ writex(fd, rpath, len) || writex(fd, tmp, r)) {
++ free(file_buffer);
++ goto fail;
++ }
++
++ if (file_buffer) {
++ write_data_buffer(fd, file_buffer, size, sbuf);
++ free(file_buffer);
++ } else if (S_ISREG(mode))
++ write_data_file(fd, lpath, sbuf);
++#ifdef HAVE_SYMLINKS
++ else if (S_ISLNK(mode))
++ write_data_link(fd, lpath, sbuf);
++#endif
++ else
++ goto fail;
++
++ msg.data.id = ID_DONE;
++ msg.data.size = htoll(mtime);
++ if(writex(fd, &msg.data, sizeof(msg.data)))
++ goto fail;
++
++ if(readx(fd, &msg.status, sizeof(msg.status)))
++ return -1;
++
++ if(msg.status.id != ID_OKAY) {
++ if(msg.status.id == ID_FAIL) {
++ len = ltohl(msg.status.msglen);
++ if(len > 256) len = 256;
++ if(readx(fd, sbuf->data, len)) {
++ return -1;
++ }
++ sbuf->data[len] = 0;
++ } else
++ strcpy(sbuf->data, "unknown reason");
++
++ fprintf(stderr,"failed to copy '%s' to '%s': %s\n", lpath, rpath, sbuf->data);
++ return -1;
++ }
++
++ return 0;
++
++fail:
++ fprintf(stderr,"protocol failure\n");
++ adb_close(fd);
++ return -1;
++}
++
++static int mkdirs(char *name)
++{
++ int ret;
++ char *x = name + 1;
++
++ for(;;) {
++ x = adb_dirstart(x);
++ if(x == 0) return 0;
++ *x = 0;
++ ret = adb_mkdir(name, 0775);
++ *x = OS_PATH_SEPARATOR;
++ if((ret < 0) && (errno != EEXIST)) {
++ return ret;
++ }
++ x++;
++ }
++ return 0;
++}
++
++int sync_recv(int fd, const char *rpath, const char *lpath)
++{
++ syncmsg msg;
++ int len;
++ int lfd = -1;
++ char *buffer = send_buffer.data;
++ unsigned id;
++
++ len = strlen(rpath);
++ if(len > 1024) return -1;
++
++ msg.req.id = ID_RECV;
++ msg.req.namelen = htoll(len);
++ if(writex(fd, &msg.req, sizeof(msg.req)) ||
++ writex(fd, rpath, len)) {
++ return -1;
++ }
++
++ if(readx(fd, &msg.data, sizeof(msg.data))) {
++ return -1;
++ }
++ id = msg.data.id;
++
++ if((id == ID_DATA) || (id == ID_DONE)) {
++ adb_unlink(lpath);
++ mkdirs((char *)lpath);
++ lfd = adb_creat(lpath, 0644);
++ if(lfd < 0) {
++ fprintf(stderr,"cannot create '%s': %s\n", lpath, strerror(errno));
++ return -1;
++ }
++ goto handle_data;
++ } else {
++ goto remote_error;
++ }
++
++ for(;;) {
++ if(readx(fd, &msg.data, sizeof(msg.data))) {
++ return -1;
++ }
++ id = msg.data.id;
++
++ handle_data:
++ len = ltohl(msg.data.size);
++ if(id == ID_DONE) break;
++ if(id != ID_DATA) goto remote_error;
++ if(len > SYNC_DATA_MAX) {
++ fprintf(stderr,"data overrun\n");
++ adb_close(lfd);
++ return -1;
++ }
++
++ if(readx(fd, buffer, len)) {
++ adb_close(lfd);
++ return -1;
++ }
++
++ if(writex(lfd, buffer, len)) {
++ fprintf(stderr,"cannot write '%s': %s\n", rpath, strerror(errno));
++ adb_close(lfd);
++ return -1;
++ }
++
++ total_bytes += len;
++ }
++
++ adb_close(lfd);
++ return 0;
++
++remote_error:
++ adb_close(lfd);
++ adb_unlink(lpath);
++
++ if(id == ID_FAIL) {
++ len = ltohl(msg.data.size);
++ if(len > 256) len = 256;
++ if(readx(fd, buffer, len)) {
++ return -1;
++ }
++ buffer[len] = 0;
++ } else {
++ memcpy(buffer, &id, 4);
++ buffer[4] = 0;
++// strcpy(buffer,"unknown reason");
++ }
++ fprintf(stderr,"failed to copy '%s' to '%s': %s\n", rpath, lpath, buffer);
++ return 0;
++}
++
++
++
++/* --- */
++
++
++static void do_sync_ls_cb(unsigned mode, unsigned size, unsigned time,
++ const char *name, void *cookie)
++{
++ printf("%08x %08x %08x %s\n", mode, size, time, name);
++}
++
++int do_sync_ls(const char *path)
++{
++ int fd = adb_connect("sync:");
++ if(fd < 0) {
++ fprintf(stderr,"error: %s\n", adb_error());
++ return 1;
++ }
++
++ if(sync_ls(fd, path, do_sync_ls_cb, 0)) {
++ return 1;
++ } else {
++ sync_quit(fd);
++ return 0;
++ }
++}
++
++typedef struct copyinfo copyinfo;
++
++struct copyinfo
++{
++ copyinfo *next;
++ const char *src;
++ const char *dst;
++ unsigned int time;
++ unsigned int mode;
++ unsigned int size;
++ int flag;
++ //char data[0];
++};
++
++copyinfo *mkcopyinfo(const char *spath, const char *dpath,
++ const char *name, int isdir)
++{
++ int slen = strlen(spath);
++ int dlen = strlen(dpath);
++ int nlen = strlen(name);
++ int ssize = slen + nlen + 2;
++ int dsize = dlen + nlen + 2;
++
++ copyinfo *ci = malloc(sizeof(copyinfo) + ssize + dsize);
++ if(ci == 0) {
++ fprintf(stderr,"out of memory\n");
++ abort();
++ }
++
++ ci->next = 0;
++ ci->time = 0;
++ ci->mode = 0;
++ ci->size = 0;
++ ci->flag = 0;
++ ci->src = (const char*)(ci + 1);
++ ci->dst = ci->src + ssize;
++ snprintf((char*) ci->src, ssize, isdir ? "%s%s/" : "%s%s", spath, name);
++ snprintf((char*) ci->dst, dsize, isdir ? "%s%s/" : "%s%s", dpath, name);
++
++// fprintf(stderr,"mkcopyinfo('%s','%s')\n", ci->src, ci->dst);
++ return ci;
++}
++
++
++static int local_build_list(copyinfo **filelist,
++ const char *lpath, const char *rpath)
++{
++ DIR *d;
++ struct dirent *de;
++ struct stat st;
++ copyinfo *dirlist = 0;
++ copyinfo *ci, *next;
++
++// fprintf(stderr,"local_build_list('%s','%s')\n", lpath, rpath);
++
++ d = opendir(lpath);
++ if(d == 0) {
++ fprintf(stderr,"cannot open '%s': %s\n", lpath, strerror(errno));
++ return -1;
++ }
++
++ while((de = readdir(d))) {
++ char stat_path[PATH_MAX];
++ char *name = de->d_name;
++
++ if(name[0] == '.') {
++ if(name[1] == 0) continue;
++ if((name[1] == '.') && (name[2] == 0)) continue;
++ }
++
++ /*
++ * We could use d_type if HAVE_DIRENT_D_TYPE is defined, but reiserfs
++ * always returns DT_UNKNOWN, so we just use stat() for all cases.
++ */
++ if (strlen(lpath) + strlen(de->d_name) + 1 > sizeof(stat_path))
++ continue;
++ strcpy(stat_path, lpath);
++ strcat(stat_path, de->d_name);
++ stat(stat_path, &st);
++
++ if (S_ISDIR(st.st_mode)) {
++ ci = mkcopyinfo(lpath, rpath, name, 1);
++ ci->next = dirlist;
++ dirlist = ci;
++ } else {
++ ci = mkcopyinfo(lpath, rpath, name, 0);
++ if(lstat(ci->src, &st)) {
++ fprintf(stderr,"cannot stat '%s': %s\n", ci->src, strerror(errno));
++ closedir(d);
++
++ return -1;
++ }
++ if(!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
++ fprintf(stderr, "skipping special file '%s'\n", ci->src);
++ free(ci);
++ } else {
++ ci->time = st.st_mtime;
++ ci->mode = st.st_mode;
++ ci->size = st.st_size;
++ ci->next = *filelist;
++ *filelist = ci;
++ }
++ }
++ }
++
++ closedir(d);
++
++ for(ci = dirlist; ci != 0; ci = next) {
++ next = ci->next;
++ local_build_list(filelist, ci->src, ci->dst);
++ free(ci);
++ }
++
++ return 0;
++}
++
++
++static int copy_local_dir_remote(int fd, const char *lpath, const char *rpath, int checktimestamps, int listonly)
++{
++ copyinfo *filelist = 0;
++ copyinfo *ci, *next;
++ int pushed = 0;
++ int skipped = 0;
++
++ if((lpath[0] == 0) || (rpath[0] == 0)) return -1;
++ if(lpath[strlen(lpath) - 1] != '/') {
++ int tmplen = strlen(lpath)+2;
++ char *tmp = malloc(tmplen);
++ if(tmp == 0) return -1;
++ snprintf(tmp, tmplen, "%s/",lpath);
++ lpath = tmp;
++ }
++ if(rpath[strlen(rpath) - 1] != '/') {
++ int tmplen = strlen(rpath)+2;
++ char *tmp = malloc(tmplen);
++ if(tmp == 0) return -1;
++ snprintf(tmp, tmplen, "%s/",rpath);
++ rpath = tmp;
++ }
++
++ if(local_build_list(&filelist, lpath, rpath)) {
++ return -1;
++ }
++
++ if(checktimestamps){
++ for(ci = filelist; ci != 0; ci = ci->next) {
++ if(sync_start_readtime(fd, ci->dst)) {
++ return 1;
++ }
++ }
++ for(ci = filelist; ci != 0; ci = ci->next) {
++ unsigned int timestamp, mode, size;
++ if(sync_finish_readtime(fd, ×tamp, &mode, &size))
++ return 1;
++ if(size == ci->size) {
++ /* for links, we cannot update the atime/mtime */
++ if((S_ISREG(ci->mode & mode) && timestamp == ci->time) ||
++ (S_ISLNK(ci->mode & mode) && timestamp >= ci->time))
++ ci->flag = 1;
++ }
++ }
++ }
++ for(ci = filelist; ci != 0; ci = next) {
++ next = ci->next;
++ if(ci->flag == 0) {
++ fprintf(stderr,"%spush: %s -> %s\n", listonly ? "would " : "", ci->src, ci->dst);
++ if(!listonly &&
++ sync_send(fd, ci->src, ci->dst, ci->time, ci->mode, 0 /* no verify APK */)){
++ return 1;
++ }
++ pushed++;
++ } else {
++ skipped++;
++ }
++ free(ci);
++ }
++
++ fprintf(stderr,"%d file%s pushed. %d file%s skipped.\n",
++ pushed, (pushed == 1) ? "" : "s",
++ skipped, (skipped == 1) ? "" : "s");
++
++ return 0;
++}
++
++
++int do_sync_push(const char *lpath, const char *rpath, int verifyApk)
++{
++ struct stat st;
++ unsigned mode;
++ int fd;
++
++ fd = adb_connect("sync:");
++ if(fd < 0) {
++ fprintf(stderr,"error: %s\n", adb_error());
++ return 1;
++ }
++
++ if(stat(lpath, &st)) {
++ fprintf(stderr,"cannot stat '%s': %s\n", lpath, strerror(errno));
++ sync_quit(fd);
++ return 1;
++ }
++
++ if(S_ISDIR(st.st_mode)) {
++ BEGIN();
++ if(copy_local_dir_remote(fd, lpath, rpath, 0, 0)) {
++ return 1;
++ } else {
++ END();
++ sync_quit(fd);
++ }
++ } else {
++ if(sync_readmode(fd, rpath, &mode)) {
++ return 1;
++ }
++ if((mode != 0) && S_ISDIR(mode)) {
++ /* if we're copying a local file to a remote directory,
++ ** we *really* want to copy to remotedir + "/" + localfilename
++ */
++ const char *name = adb_dirstop(lpath);
++ if(name == 0) {
++ name = lpath;
++ } else {
++ name++;
++ }
++ int tmplen = strlen(name) + strlen(rpath) + 2;
++ char *tmp = malloc(strlen(name) + strlen(rpath) + 2);
++ if(tmp == 0) return 1;
++ snprintf(tmp, tmplen, "%s/%s", rpath, name);
++ rpath = tmp;
++ }
++ BEGIN();
++ if(sync_send(fd, lpath, rpath, st.st_mtime, st.st_mode, verifyApk)) {
++ return 1;
++ } else {
++ END();
++ sync_quit(fd);
++ return 0;
++ }
++ }
++
++ return 0;
++}
++
++
++typedef struct {
++ copyinfo **filelist;
++ copyinfo **dirlist;
++ const char *rpath;
++ const char *lpath;
++} sync_ls_build_list_cb_args;
++
++void
++sync_ls_build_list_cb(unsigned mode, unsigned size, unsigned time,
++ const char *name, void *cookie)
++{
++ sync_ls_build_list_cb_args *args = (sync_ls_build_list_cb_args *)cookie;
++ copyinfo *ci;
++
++ if (S_ISDIR(mode)) {
++ copyinfo **dirlist = args->dirlist;
++
++ /* Don't try recursing down "." or ".." */
++ if (name[0] == '.') {
++ if (name[1] == '\0') return;
++ if ((name[1] == '.') && (name[2] == '\0')) return;
++ }
++
++ ci = mkcopyinfo(args->rpath, args->lpath, name, 1);
++ ci->next = *dirlist;
++ *dirlist = ci;
++ } else if (S_ISREG(mode) || S_ISLNK(mode)) {
++ copyinfo **filelist = args->filelist;
++
++ ci = mkcopyinfo(args->rpath, args->lpath, name, 0);
++ ci->time = time;
++ ci->mode = mode;
++ ci->size = size;
++ ci->next = *filelist;
++ *filelist = ci;
++ } else {
++ fprintf(stderr, "skipping special file '%s'\n", name);
++ }
++}
++
++static int remote_build_list(int syncfd, copyinfo **filelist,
++ const char *rpath, const char *lpath)
++{
++ copyinfo *dirlist = NULL;
++ sync_ls_build_list_cb_args args;
++
++ args.filelist = filelist;
++ args.dirlist = &dirlist;
++ args.rpath = rpath;
++ args.lpath = lpath;
++
++ /* Put the files/dirs in rpath on the lists. */
++ if (sync_ls(syncfd, rpath, sync_ls_build_list_cb, (void *)&args)) {
++ return 1;
++ }
++
++ /* Recurse into each directory we found. */
++ while (dirlist != NULL) {
++ copyinfo *next = dirlist->next;
++ if (remote_build_list(syncfd, filelist, dirlist->src, dirlist->dst)) {
++ return 1;
++ }
++ free(dirlist);
++ dirlist = next;
++ }
++
++ return 0;
++}
++
++static int copy_remote_dir_local(int fd, const char *rpath, const char *lpath,
++ int checktimestamps)
++{
++ copyinfo *filelist = 0;
++ copyinfo *ci, *next;
++ int pulled = 0;
++ int skipped = 0;
++
++ /* Make sure that both directory paths end in a slash. */
++ if (rpath[0] == 0 || lpath[0] == 0) return -1;
++ if (rpath[strlen(rpath) - 1] != '/') {
++ int tmplen = strlen(rpath) + 2;
++ char *tmp = malloc(tmplen);
++ if (tmp == 0) return -1;
++ snprintf(tmp, tmplen, "%s/", rpath);
++ rpath = tmp;
++ }
++ if (lpath[strlen(lpath) - 1] != '/') {
++ int tmplen = strlen(lpath) + 2;
++ char *tmp = malloc(tmplen);
++ if (tmp == 0) return -1;
++ snprintf(tmp, tmplen, "%s/", lpath);
++ lpath = tmp;
++ }
++
++ fprintf(stderr, "pull: building file list...\n");
++ /* Recursively build the list of files to copy. */
++ if (remote_build_list(fd, &filelist, rpath, lpath)) {
++ return -1;
++ }
++
++#if 0
++ if (checktimestamps) {
++ for (ci = filelist; ci != 0; ci = ci->next) {
++ if (sync_start_readtime(fd, ci->dst)) {
++ return 1;
++ }
++ }
++ for (ci = filelist; ci != 0; ci = ci->next) {
++ unsigned int timestamp, mode, size;
++ if (sync_finish_readtime(fd, ×tamp, &mode, &size))
++ return 1;
++ if (size == ci->size) {
++ /* for links, we cannot update the atime/mtime */
++ if ((S_ISREG(ci->mode & mode) && timestamp == ci->time) ||
++ (S_ISLNK(ci->mode & mode) && timestamp >= ci->time))
++ ci->flag = 1;
++ }
++ }
++ }
++#endif
++ for (ci = filelist; ci != 0; ci = next) {
++ next = ci->next;
++ if (ci->flag == 0) {
++ fprintf(stderr, "pull: %s -> %s\n", ci->src, ci->dst);
++ if (sync_recv(fd, ci->src, ci->dst)) {
++ return 1;
++ }
++ pulled++;
++ } else {
++ skipped++;
++ }
++ free(ci);
++ }
++
++ fprintf(stderr, "%d file%s pulled. %d file%s skipped.\n",
++ pulled, (pulled == 1) ? "" : "s",
++ skipped, (skipped == 1) ? "" : "s");
++
++ return 0;
++}
++
++int do_sync_pull(const char *rpath, const char *lpath)
++{
++ unsigned mode;
++ struct stat st;
++
++ int fd;
++
++ fd = adb_connect("sync:");
++ if(fd < 0) {
++ fprintf(stderr,"error: %s\n", adb_error());
++ return 1;
++ }
++
++ if(sync_readmode(fd, rpath, &mode)) {
++ return 1;
++ }
++ if(mode == 0) {
++ fprintf(stderr,"remote object '%s' does not exist\n", rpath);
++ return 1;
++ }
++
++ if(S_ISREG(mode) || S_ISLNK(mode) || S_ISCHR(mode) || S_ISBLK(mode)) {
++ if(stat(lpath, &st) == 0) {
++ if(S_ISDIR(st.st_mode)) {
++ /* if we're copying a remote file to a local directory,
++ ** we *really* want to copy to localdir + "/" + remotefilename
++ */
++ const char *name = adb_dirstop(rpath);
++ if(name == 0) {
++ name = rpath;
++ } else {
++ name++;
++ }
++ int tmplen = strlen(name) + strlen(lpath) + 2;
++ char *tmp = malloc(tmplen);
++ if(tmp == 0) return 1;
++ snprintf(tmp, tmplen, "%s/%s", lpath, name);
++ lpath = tmp;
++ }
++ }
++ BEGIN();
++ if(sync_recv(fd, rpath, lpath)) {
++ return 1;
++ } else {
++ END();
++ sync_quit(fd);
++ return 0;
++ }
++ } else if(S_ISDIR(mode)) {
++ BEGIN();
++ if (copy_remote_dir_local(fd, rpath, lpath, 0)) {
++ return 1;
++ } else {
++ END();
++ sync_quit(fd);
++ return 0;
++ }
++ } else {
++ fprintf(stderr,"remote object '%s' not a file or directory\n", rpath);
++ return 1;
++ }
++}
++
++int do_sync_sync(const char *lpath, const char *rpath, int listonly)
++{
++ fprintf(stderr,"syncing %s...\n",rpath);
++
++ int fd = adb_connect("sync:");
++ if(fd < 0) {
++ fprintf(stderr,"error: %s\n", adb_error());
++ return 1;
++ }
++
++ BEGIN();
++ if(copy_local_dir_remote(fd, lpath, rpath, 1, listonly)){
++ return 1;
++ } else {
++ END();
++ sync_quit(fd);
++ return 0;
++ }
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/file_sync_service.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/file_sync_service.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,414 @@
++/*
++ * 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.
++ */
++
++#include <stdlib.h>
++#include <stdio.h>
++#include <string.h>
++
++#include <sys/stat.h>
++#include <sys/types.h>
++#include <dirent.h>
++#include <utime.h>
++
++#include <errno.h>
++
++#include "sysdeps.h"
++
++#define TRACE_TAG TRACE_SYNC
++#include "adb.h"
++#include "file_sync_service.h"
++
++static int mkdirs(char *name)
++{
++ int ret;
++ char *x = name + 1;
++
++ if(name[0] != '/') return -1;
++
++ for(;;) {
++ x = adb_dirstart(x);
++ if(x == 0) return 0;
++ *x = 0;
++ ret = adb_mkdir(name, 0775);
++ if((ret < 0) && (errno != EEXIST)) {
++ D("mkdir(\"%s\") -> %s\n", name, strerror(errno));
++ *x = '/';
++ return ret;
++ }
++ *x++ = '/';
++ }
++ return 0;
++}
++
++static int do_stat(int s, const char *path)
++{
++ syncmsg msg;
++ struct stat st;
++
++ msg.stat.id = ID_STAT;
++
++ if(lstat(path, &st)) {
++ msg.stat.mode = 0;
++ msg.stat.size = 0;
++ msg.stat.time = 0;
++ } else {
++ msg.stat.mode = htoll(st.st_mode);
++ msg.stat.size = htoll(st.st_size);
++ msg.stat.time = htoll(st.st_mtime);
++ }
++
++ return writex(s, &msg.stat, sizeof(msg.stat));
++}
++
++static int do_list(int s, const char *path)
++{
++ DIR *d;
++ struct dirent *de;
++ struct stat st;
++ syncmsg msg;
++ int len;
++
++ char tmp[1024 + 256 + 1];
++ char *fname;
++
++ len = strlen(path);
++ memcpy(tmp, path, len);
++ tmp[len] = '/';
++ fname = tmp + len + 1;
++
++ msg.dent.id = ID_DENT;
++
++ d = opendir(path);
++ if(d == 0) goto done;
++
++ while((de = readdir(d))) {
++ int len = strlen(de->d_name);
++
++ /* not supposed to be possible, but
++ if it does happen, let's not buffer overrun */
++ if(len > 256) continue;
++
++ strcpy(fname, de->d_name);
++ if(lstat(tmp, &st) == 0) {
++ msg.dent.mode = htoll(st.st_mode);
++ msg.dent.size = htoll(st.st_size);
++ msg.dent.time = htoll(st.st_mtime);
++ msg.dent.namelen = htoll(len);
++
++ if(writex(s, &msg.dent, sizeof(msg.dent)) ||
++ writex(s, de->d_name, len)) {
++ return -1;
++ }
++ }
++ }
++
++ closedir(d);
++
++done:
++ msg.dent.id = ID_DONE;
++ msg.dent.mode = 0;
++ msg.dent.size = 0;
++ msg.dent.time = 0;
++ msg.dent.namelen = 0;
++ return writex(s, &msg.dent, sizeof(msg.dent));
++}
++
++static int fail_message(int s, const char *reason)
++{
++ syncmsg msg;
++ int len = strlen(reason);
++
++ D("sync: failure: %s\n", reason);
++
++ msg.data.id = ID_FAIL;
++ msg.data.size = htoll(len);
++ if(writex(s, &msg.data, sizeof(msg.data)) ||
++ writex(s, reason, len)) {
++ return -1;
++ } else {
++ return 0;
++ }
++}
++
++static int fail_errno(int s)
++{
++ return fail_message(s, strerror(errno));
++}
++
++static int handle_send_file(int s, char *path, mode_t mode, char *buffer)
++{
++ syncmsg msg;
++ unsigned int timestamp = 0;
++ int fd;
++
++ fd = adb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL, mode);
++ if(fd < 0 && errno == ENOENT) {
++ mkdirs(path);
++ fd = adb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL, mode);
++ }
++ if(fd < 0 && errno == EEXIST) {
++ fd = adb_open_mode(path, O_WRONLY, mode);
++ }
++ if(fd < 0) {
++ if(fail_errno(s))
++ return -1;
++ fd = -1;
++ }
++
++ for(;;) {
++ unsigned int len;
++
++ if(readx(s, &msg.data, sizeof(msg.data)))
++ goto fail;
++
++ if(msg.data.id != ID_DATA) {
++ if(msg.data.id == ID_DONE) {
++ timestamp = ltohl(msg.data.size);
++ break;
++ }
++ fail_message(s, "invalid data message");
++ goto fail;
++ }
++ len = ltohl(msg.data.size);
++ if(len > SYNC_DATA_MAX) {
++ fail_message(s, "oversize data message");
++ goto fail;
++ }
++ if(readx(s, buffer, len))
++ goto fail;
++
++ if(fd < 0)
++ continue;
++ if(writex(fd, buffer, len)) {
++ int saved_errno = errno;
++ adb_close(fd);
++ adb_unlink(path);
++ fd = -1;
++ errno = saved_errno;
++ if(fail_errno(s)) return -1;
++ }
++ }
++
++ if(fd >= 0) {
++ struct utimbuf u;
++ adb_close(fd);
++ u.actime = timestamp;
++ u.modtime = timestamp;
++ utime(path, &u);
++
++ msg.status.id = ID_OKAY;
++ msg.status.msglen = 0;
++ if(writex(s, &msg.status, sizeof(msg.status)))
++ return -1;
++ }
++ return 0;
++
++fail:
++ if(fd >= 0)
++ adb_close(fd);
++ adb_unlink(path);
++ return -1;
++}
++
++#ifdef HAVE_SYMLINKS
++static int handle_send_link(int s, char *path, char *buffer)
++{
++ syncmsg msg;
++ unsigned int len;
++ int ret;
++
++ if(readx(s, &msg.data, sizeof(msg.data)))
++ return -1;
++
++ if(msg.data.id != ID_DATA) {
++ fail_message(s, "invalid data message: expected ID_DATA");
++ return -1;
++ }
++
++ len = ltohl(msg.data.size);
++ if(len > SYNC_DATA_MAX) {
++ fail_message(s, "oversize data message");
++ return -1;
++ }
++ if(readx(s, buffer, len))
++ return -1;
++
++ ret = symlink(buffer, path);
++ if(ret && errno == ENOENT) {
++ mkdirs(path);
++ ret = symlink(buffer, path);
++ }
++ if(ret) {
++ fail_errno(s);
++ return -1;
++ }
++
++ if(readx(s, &msg.data, sizeof(msg.data)))
++ return -1;
++
++ if(msg.data.id == ID_DONE) {
++ msg.status.id = ID_OKAY;
++ msg.status.msglen = 0;
++ if(writex(s, &msg.status, sizeof(msg.status)))
++ return -1;
++ } else {
++ fail_message(s, "invalid data message: expected ID_DONE");
++ return -1;
++ }
++
++ return 0;
++}
++#endif /* HAVE_SYMLINKS */
++
++static int do_send(int s, char *path, char *buffer)
++{
++ char *tmp;
++ mode_t mode;
++ int is_link, ret;
++
++ tmp = strrchr(path,',');
++ if(tmp) {
++ *tmp = 0;
++ errno = 0;
++ mode = strtoul(tmp + 1, NULL, 0);
++#ifndef HAVE_SYMLINKS
++ is_link = 0;
++#else
++ is_link = S_ISLNK(mode);
++#endif
++ mode &= 0777;
++ }
++ if(!tmp || errno) {
++ mode = 0644;
++ is_link = 0;
++ }
++
++ adb_unlink(path);
++
++
++#ifdef HAVE_SYMLINKS
++ if(is_link)
++ ret = handle_send_link(s, path, buffer);
++ else {
++#else
++ {
++#endif
++ /* copy user permission bits to "group" and "other" permissions */
++ mode |= ((mode >> 3) & 0070);
++ mode |= ((mode >> 3) & 0007);
++
++ ret = handle_send_file(s, path, mode, buffer);
++ }
++
++ return ret;
++}
++
++static int do_recv(int s, const char *path, char *buffer)
++{
++ syncmsg msg;
++ int fd, r;
++
++ fd = adb_open(path, O_RDONLY);
++ if(fd < 0) {
++ if(fail_errno(s)) return -1;
++ return 0;
++ }
++
++ msg.data.id = ID_DATA;
++ for(;;) {
++ r = adb_read(fd, buffer, SYNC_DATA_MAX);
++ if(r <= 0) {
++ if(r == 0) break;
++ if(errno == EINTR) continue;
++ r = fail_errno(s);
++ adb_close(fd);
++ return r;
++ }
++ msg.data.size = htoll(r);
++ if(writex(s, &msg.data, sizeof(msg.data)) ||
++ writex(s, buffer, r)) {
++ adb_close(fd);
++ return -1;
++ }
++ }
++
++ adb_close(fd);
++
++ msg.data.id = ID_DONE;
++ msg.data.size = 0;
++ if(writex(s, &msg.data, sizeof(msg.data))) {
++ return -1;
++ }
++
++ return 0;
++}
++
++void file_sync_service(int fd, void *cookie)
++{
++ syncmsg msg;
++ char name[1025];
++ unsigned namelen;
++
++ char *buffer = malloc(SYNC_DATA_MAX);
++ if(buffer == 0) goto fail;
++
++ for(;;) {
++ D("sync: waiting for command\n");
++
++ if(readx(fd, &msg.req, sizeof(msg.req))) {
++ fail_message(fd, "command read failure");
++ break;
++ }
++ namelen = ltohl(msg.req.namelen);
++ if(namelen > 1024) {
++ fail_message(fd, "invalid namelen");
++ break;
++ }
++ if(readx(fd, name, namelen)) {
++ fail_message(fd, "filename read failure");
++ break;
++ }
++ name[namelen] = 0;
++
++ msg.req.namelen = 0;
++ D("sync: '%s' '%s'\n", (char*) &msg.req, name);
++
++ switch(msg.req.id) {
++ case ID_STAT:
++ if(do_stat(fd, name)) goto fail;
++ break;
++ case ID_LIST:
++ if(do_list(fd, name)) goto fail;
++ break;
++ case ID_SEND:
++ if(do_send(fd, name, buffer)) goto fail;
++ break;
++ case ID_RECV:
++ if(do_recv(fd, name, buffer)) goto fail;
++ break;
++ case ID_QUIT:
++ goto fail;
++ default:
++ fail_message(fd, "unknown command");
++ goto fail;
++ }
++ }
++
++fail:
++ if(buffer != 0) free(buffer);
++ D("sync: done\n");
++ adb_close(fd);
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/file_sync_service.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/file_sync_service.h 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,87 @@
++/*
++ * 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 _FILE_SYNC_SERVICE_H_
++#define _FILE_SYNC_SERVICE_H_
++
++#ifdef HAVE_BIG_ENDIAN
++static inline unsigned __swap_uint32(unsigned x)
++{
++ return (((x) & 0xFF000000) >> 24)
++ | (((x) & 0x00FF0000) >> 8)
++ | (((x) & 0x0000FF00) << 8)
++ | (((x) & 0x000000FF) << 24);
++}
++#define htoll(x) __swap_uint32(x)
++#define ltohl(x) __swap_uint32(x)
++#define MKID(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((a) << 24))
++#else
++#define htoll(x) (x)
++#define ltohl(x) (x)
++#define MKID(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24))
++#endif
++
++#define ID_STAT MKID('S','T','A','T')
++#define ID_LIST MKID('L','I','S','T')
++#define ID_ULNK MKID('U','L','N','K')
++#define ID_SEND MKID('S','E','N','D')
++#define ID_RECV MKID('R','E','C','V')
++#define ID_DENT MKID('D','E','N','T')
++#define ID_DONE MKID('D','O','N','E')
++#define ID_DATA MKID('D','A','T','A')
++#define ID_OKAY MKID('O','K','A','Y')
++#define ID_FAIL MKID('F','A','I','L')
++#define ID_QUIT MKID('Q','U','I','T')
++
++typedef union {
++ unsigned id;
++ struct {
++ unsigned id;
++ unsigned namelen;
++ } req;
++ struct {
++ unsigned id;
++ unsigned mode;
++ unsigned size;
++ unsigned time;
++ } stat;
++ struct {
++ unsigned id;
++ unsigned mode;
++ unsigned size;
++ unsigned time;
++ unsigned namelen;
++ } dent;
++ struct {
++ unsigned id;
++ unsigned size;
++ } data;
++ struct {
++ unsigned id;
++ unsigned msglen;
++ } status;
++} syncmsg;
++
++
++void file_sync_service(int fd, void *cookie);
++int do_sync_ls(const char *path);
++int do_sync_push(const char *lpath, const char *rpath, int verifyApk);
++int do_sync_sync(const char *lpath, const char *rpath, int listonly);
++int do_sync_pull(const char *rpath, const char *lpath);
++
++#define SYNC_DATA_MAX (64*1024)
++
++#endif
+Index: android-tools-4.2.2+git20130218/core/adbd/framebuffer_service.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/framebuffer_service.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,180 @@
++/*
++ * 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.
++ */
++
++#include <stdlib.h>
++#include <stdio.h>
++#include <unistd.h>
++#include <string.h>
++#include <fcntl.h>
++#include <errno.h>
++#include <sys/types.h>
++#include <sys/wait.h>
++
++#include "fdevent.h"
++#include "adb.h"
++
++#include <linux/fb.h>
++#include <sys/ioctl.h>
++#include <sys/mman.h>
++
++/* TODO:
++** - sync with vsync to avoid tearing
++*/
++/* This version number defines the format of the fbinfo struct.
++ It must match versioning in ddms where this data is consumed. */
++#define DDMS_RAWIMAGE_VERSION 1
++struct fbinfo {
++ unsigned int version;
++ unsigned int bpp;
++ unsigned int size;
++ unsigned int width;
++ unsigned int height;
++ unsigned int red_offset;
++ unsigned int red_length;
++ unsigned int blue_offset;
++ unsigned int blue_length;
++ unsigned int green_offset;
++ unsigned int green_length;
++ unsigned int alpha_offset;
++ unsigned int alpha_length;
++} __attribute__((packed));
++
++void framebuffer_service(int fd, void *cookie)
++{
++ struct fbinfo fbinfo;
++ unsigned int i;
++ char buf[640];
++ int fd_screencap;
++ int w, h, f;
++ int fds[2];
++
++ if (pipe(fds) < 0) goto done;
++
++ pid_t pid = fork();
++ if (pid < 0) goto done;
++
++ if (pid == 0) {
++ dup2(fds[1], STDOUT_FILENO);
++ close(fds[0]);
++ close(fds[1]);
++ const char* command = "screencap";
++ const char *args[2] = {command, NULL};
++ execvp(command, (char**)args);
++ exit(1);
++ }
++
++ fd_screencap = fds[0];
++
++ /* read w, h & format */
++ if(readx(fd_screencap, &w, 4)) goto done;
++ if(readx(fd_screencap, &h, 4)) goto done;
++ if(readx(fd_screencap, &f, 4)) goto done;
++
++ fbinfo.version = DDMS_RAWIMAGE_VERSION;
++ /* see hardware/hardware.h */
++ switch (f) {
++ case 1: /* RGBA_8888 */
++ fbinfo.bpp = 32;
++ fbinfo.size = w * h * 4;
++ fbinfo.width = w;
++ fbinfo.height = h;
++ fbinfo.red_offset = 0;
++ fbinfo.red_length = 8;
++ fbinfo.green_offset = 8;
++ fbinfo.green_length = 8;
++ fbinfo.blue_offset = 16;
++ fbinfo.blue_length = 8;
++ fbinfo.alpha_offset = 24;
++ fbinfo.alpha_length = 8;
++ break;
++ case 2: /* RGBX_8888 */
++ fbinfo.bpp = 32;
++ fbinfo.size = w * h * 4;
++ fbinfo.width = w;
++ fbinfo.height = h;
++ fbinfo.red_offset = 0;
++ fbinfo.red_length = 8;
++ fbinfo.green_offset = 8;
++ fbinfo.green_length = 8;
++ fbinfo.blue_offset = 16;
++ fbinfo.blue_length = 8;
++ fbinfo.alpha_offset = 24;
++ fbinfo.alpha_length = 0;
++ break;
++ case 3: /* RGB_888 */
++ fbinfo.bpp = 24;
++ fbinfo.size = w * h * 3;
++ fbinfo.width = w;
++ fbinfo.height = h;
++ fbinfo.red_offset = 0;
++ fbinfo.red_length = 8;
++ fbinfo.green_offset = 8;
++ fbinfo.green_length = 8;
++ fbinfo.blue_offset = 16;
++ fbinfo.blue_length = 8;
++ fbinfo.alpha_offset = 24;
++ fbinfo.alpha_length = 0;
++ break;
++ case 4: /* RGB_565 */
++ fbinfo.bpp = 16;
++ fbinfo.size = w * h * 2;
++ fbinfo.width = w;
++ fbinfo.height = h;
++ fbinfo.red_offset = 11;
++ fbinfo.red_length = 5;
++ fbinfo.green_offset = 5;
++ fbinfo.green_length = 6;
++ fbinfo.blue_offset = 0;
++ fbinfo.blue_length = 5;
++ fbinfo.alpha_offset = 0;
++ fbinfo.alpha_length = 0;
++ break;
++ case 5: /* BGRA_8888 */
++ fbinfo.bpp = 32;
++ fbinfo.size = w * h * 4;
++ fbinfo.width = w;
++ fbinfo.height = h;
++ fbinfo.red_offset = 16;
++ fbinfo.red_length = 8;
++ fbinfo.green_offset = 8;
++ fbinfo.green_length = 8;
++ fbinfo.blue_offset = 0;
++ fbinfo.blue_length = 8;
++ fbinfo.alpha_offset = 24;
++ fbinfo.alpha_length = 8;
++ break;
++ default:
++ goto done;
++ }
++
++ /* write header */
++ if(writex(fd, &fbinfo, sizeof(fbinfo))) goto done;
++
++ /* write data */
++ for(i = 0; i < fbinfo.size; i += sizeof(buf)) {
++ if(readx(fd_screencap, buf, sizeof(buf))) goto done;
++ if(writex(fd, buf, sizeof(buf))) goto done;
++ }
++ if(readx(fd_screencap, buf, fbinfo.size % sizeof(buf))) goto done;
++ if(writex(fd, buf, fbinfo.size % sizeof(buf))) goto done;
++
++done:
++ TEMP_FAILURE_RETRY(waitpid(pid, NULL, 0));
++
++ close(fds[0]);
++ close(fds[1]);
++ close(fd);
++}
+Index: android-tools-4.2.2+git20130218/core/adbd/get_my_path_darwin.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/get_my_path_darwin.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,30 @@
++/*
++ * 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.
++ */
++
++#import <Carbon/Carbon.h>
++#include <unistd.h>
++
++void get_my_path(char *s, size_t maxLen)
++{
++ ProcessSerialNumber psn;
++ GetCurrentProcess(&psn);
++ CFDictionaryRef dict;
++ dict = ProcessInformationCopyDictionary(&psn, 0xffffffff);
++ CFStringRef value = (CFStringRef)CFDictionaryGetValue(dict,
++ CFSTR("CFBundleExecutable"));
++ CFStringGetCString(value, s, maxLen, kCFStringEncodingUTF8);
++}
++
+Index: android-tools-4.2.2+git20130218/core/adbd/get_my_path_freebsd.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/get_my_path_freebsd.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,36 @@
++/*
++ * Copyright (C) 2009 bsdroid project
++ * Alexey Tarasov <tarasov@dodologics.com>
++ *
++ * 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.
++ */
++
++#include <sys/types.h>
++#include <unistd.h>
++#include <limits.h>
++#include <stdio.h>
++
++void
++get_my_path(char *exe, size_t maxLen)
++{
++ char proc[64];
++
++ snprintf(proc, sizeof(proc), "/proc/%d/file", getpid());
++
++ int err = readlink(proc, exe, maxLen - 1);
++
++ exe[err > 0 ? err : 0] = '\0';
++}
++
+Index: android-tools-4.2.2+git20130218/core/adbd/get_my_path_linux.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/get_my_path_linux.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,33 @@
++/*
++ * 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.
++ */
++
++#include <sys/types.h>
++#include <unistd.h>
++#include <limits.h>
++#include <stdio.h>
++
++void get_my_path(char *exe, size_t maxLen)
++{
++ char proc[64];
++ snprintf(proc, sizeof proc, "/proc/%d/exe", getpid());
++ int err = readlink(proc, exe, maxLen - 1);
++ if(err > 0) {
++ exe[err] = '\0';
++ } else {
++ exe[0] = '\0';
++ }
++}
++
+Index: android-tools-4.2.2+git20130218/core/adbd/get_my_path_windows.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/get_my_path_windows.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,34 @@
++/*
++ * 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.
++ */
++
++#include <limits.h>
++#include <assert.h>
++#include <windows.h>
++
++void get_my_path(char *exe, size_t maxLen)
++{
++ char *r;
++
++ /* XXX: should be GetModuleFileNameA */
++ if (GetModuleFileName(NULL, exe, maxLen) > 0) {
++ r = strrchr(exe, '\\');
++ if (r != NULL)
++ *r = '\0';
++ } else {
++ exe[0] = '\0';
++ }
++}
++
+Index: android-tools-4.2.2+git20130218/core/adbd/jdwp_service.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ android-tools-4.2.2+git20130218/core/adbd/jdwp_service.c 2013-06-18 17:12:17.000000000 -0300
+@@ -0,0 +1,735 @@
++/* implement the "debug-ports" and "track-debug-ports" device services */
++#include "sysdeps.h"
++#define TRACE_TAG TRACE_JDWP
++#include "adb.h"
++#include <errno.h>
++#include <stdio.h>
++#include <string.h>
++#include <unistd.h>
++
++/* here's how these things work.
++
++ when adbd starts, it creates a unix server socket
++ named @vm-debug-control (@ is a shortcut for "first byte is zero"
++ to use the private namespace instead of the file system)
++
++ when a new JDWP daemon thread starts in a new VM process, it creates
++ a connection to @vm-debug-control to announce its availability.
++
++
++ JDWP thread @vm-debug-control
++ | |
++ |-------------------------------> |
++ | hello I'm in process <pid> |
++ | |
++ | |
++
++ the connection is kept alive. it will be closed automatically if
++ the JDWP process terminates (this allows adbd to detect dead
++ processes).
++
++ adbd thus maintains a list of "active" JDWP processes. it can send
++ its content to clients through the "device:debug-ports" service,
++ or even updates through the "device:track-debug-ports" service.
++
++ when a debugger wants to connect, it simply runs the command
++ equivalent to "adb forward tcp:<hostport> jdwp:<pid>"
++
++ "jdwp:<pid>" is a new forward destination format used to target
++ a given JDWP process on the device. when sutch a request arrives,
++ adbd does the following:
++
++ - first, it calls socketpair() to create a pair of equivalent
++ sockets.
++
++ - it attaches the first socket in the pair to a local socket
++ which is itself attached to the transport's remote socket:
++
++
++ - it sends the file descriptor of the second socket directly
++ to the JDWP process with the help of sendmsg()
++
++
++ JDWP thread @vm-debug-control
++ | |
++ | <----------------------|
++ | OK, try this file descriptor |
++ | |
++ | |
++
++ then, the JDWP thread uses this new socket descriptor as its
++ pass-through connection to the debugger (and receives the
++ JDWP-Handshake message, answers to it, etc...)
++
++ this gives the following graphics:
++ ____________________________________
++ | |
++ | ADB Server (host) |
++ | |
++ Debugger <---> LocalSocket <----> RemoteSocket |
++ | ^^ |
++ |___________________________||_______|
++ ||
++ Transport ||
++ (TCP for emulator - USB for device) ||
++ ||
++ ___________________________||_______
++ | || |
++ | ADBD (device) || |
++ | VV |
++ JDWP <======> LocalSocket <----> RemoteSocket |
++ | |
++ |____________________________________|
++
++ due to the way adb works, this doesn't need a special socket
++ type or fancy handling of socket termination if either the debugger
++ or the JDWP process closes the connection.
++
++ THIS IS THE SIMPLEST IMPLEMENTATION I COULD FIND, IF YOU HAPPEN
++ TO HAVE A BETTER IDEA, LET ME KNOW - Digit
++
++**********************************************************************/
++
++/** JDWP PID List Support Code
++ ** for each JDWP process, we record its pid and its connected socket
++ **/
++
++#define MAX_OUT_FDS 4
++
++#if !ADB_HOST
++
++#include <sys/socket.h>
++#include <sys/un.h>
++
++typedef struct JdwpProcess JdwpProcess;
++struct JdwpProcess {
++ JdwpProcess* next;
++ JdwpProcess* prev;
++ int pid;
++ int socket;
++ fdevent* fde;
++
++ char in_buff[4]; /* input character to read PID */
++ int in_len; /* number from JDWP process */
++
++ int out_fds[MAX_OUT_FDS]; /* output array of file descriptors */
++ int out_count; /* to send to the JDWP process */
++};
++
++static JdwpProcess _jdwp_list;
++
++static int
++jdwp_process_list( char* buffer, int bufferlen )
++{
++ char* end = buffer + bufferlen;
++ char* p = buffer;
++ JdwpProcess* proc = _jdwp_list.next;
++
++ for ( ; proc != &_jdwp_list; proc = proc->next ) {
++ int len;
++
++ /* skip transient connections */
++ if (proc->pid < 0)
++ continue;
++
++ len = snprintf(p, end-p, "%d\n", proc->pid);
++ if (p + len >= end)
++ break;
++ p += len;
++ }
++ p[0] = 0;
++ return (p - buffer);
++}
++
++
++static int
++jdwp_process_list_msg( char* buffer, int bufferlen )
++{
++ char head[5];
++ int len = jdwp_process_list( buffer+4, bufferlen-4 );
++ snprintf(head, sizeof head, "%04x", len);
++ memcpy(buffer, head, 4);
++ return len + 4;
++}
++
++
++static void jdwp_process_list_updated(void);
++
++static void
++jdwp_process_free( JdwpProcess* proc )
++{
++ if (proc) {
++ int n;
++
++ proc->prev->next = proc->next;
++ proc->next->prev = proc->prev;
++
++ if (proc->socket >= 0) {
++ adb_shutdown(proc->socket);
++ adb_close(proc->socket);
++ proc->socket = -1;
++ }
++
++ if (proc->fde != NULL) {
++ fdevent_destroy(proc->fde);
++ proc->fde = NULL;
++ }
++ proc->pid = -1;
++
++ for (n = 0; n < proc->out_count; n++) {
++ adb_close(proc->out_fds[n]);
++ }
++ proc->out_count = 0;
++
++ free(proc);
++
++ jdwp_process_list_updated();
++ }
++}
++
++
++static void jdwp_process_event(int, unsigned, void*); /* forward */
++
++
++static JdwpProcess*
++jdwp_process_alloc( int socket )
++{
++ JdwpProcess* proc = calloc(1,sizeof(*proc));
++
++ if (proc == NULL) {
++ D("not enough memory to create new JDWP process\n");
++ return NULL;
++ }
++
++ proc->socket = socket;
++ proc->pid = -1;
++ proc->next = proc;
++ proc->prev = proc;
++
++ proc->fde = fdevent_create( socket, jdwp_process_event, proc );
++ if (proc->fde == NULL) {
++ D("could not create fdevent for new JDWP process\n" );
++ free(proc);
++ return NULL;
++ }
++
++ proc->fde->state |= FDE_DONT_CLOSE;
++ proc->in_len = 0;
++ proc->out_count = 0;
++
++ /* append to list */
++ proc->next = &_jdwp_list;
++ proc->prev = proc->next->prev;
++
++ proc->prev->next = proc;
++ proc->next->prev = proc;
++
++ /* start by waiting for the PID */
++ fdevent_add(proc->fde, FDE_READ);
++
++ return proc;
++}
++
++
++static void
++jdwp_process_event( int socket, unsigned events, void* _proc )
++{
++ JdwpProcess* proc = _proc;
++
++ if (events & FDE_READ) {
++ if (proc->pid < 0) {
++ /* read the PID as a 4-hexchar string */
++ char* p = proc->in_buff + proc->in_len;
++ int size = 4 - proc->in_len;
++ char temp[5];
++ while (size > 0) {
++ int len = recv( socket, p, size, 0 );
++ if (len < 0) {
++ if (errno == EINTR)
++ continue;
++ if (errno == EAGAIN)
++ return;
++ /* this can fail here if the JDWP process crashes very fast */
++ D("weird unknown JDWP process failure: %s\n",
++ strerror(errno));
++
++ goto CloseProcess;
++ }
++ if (len == 0) { /* end of stream ? */
++ D("weird end-of-stream from unknown JDWP process\n");
++ goto CloseProcess;
++ }
++ p += len;
++ proc->in_len += len;
++ size -= len;
++ }
++ /* we have read 4 characters, now decode the pid */
++ memcpy(temp, proc->in_buff, 4);
++ temp[4] = 0;
++
++ if (sscanf( temp, "%04x", &proc->pid ) != 1) {
++ D("could not decode JDWP %p PID number: '%s'\n", proc, temp);
++ goto CloseProcess;
++ }
++
++ /* all is well, keep reading to detect connection closure */
++ D("Adding pid %d to jdwp process list\n", proc->pid);
++ jdwp_process_list_updated();
++ }
++ else
++ {
++ /* the pid was read, if we get there it's probably because the connection
++ * was closed (e.g. the JDWP process exited or crashed) */
++ char buf[32];
++
++ for (;;) {
++ int len = recv(socket, buf, sizeof(buf), 0);
++
++ if (len <= 0) {
++ if (len < 0 && errno == EINTR)
++ continue;
++ if (len < 0 && errno == EAGAIN)
++ return;
++ else {
++ D("terminating JDWP %d connection: %s\n", proc->pid,
++ strerror(errno));
++ break;
++ }
++ }
++ else {
++ D( "ignoring unexpected JDWP %d control socket activity (%d bytes)\n",
++ proc->pid, len );
++ }
++ }
++
++ CloseProcess:
++ if (proc->pid >= 0)
++ D( "remove pid %d to jdwp process list\n", proc->pid );
++ jdwp_process_free(proc);
++ return;
++ }
++ }
++
++ if (events & FDE_WRITE) {
++ D("trying to write to JDWP pid controli (count=%d first=%d) %d\n",
++ proc->pid, proc->out_count, proc->out_fds[0]);
++ if (proc->out_count > 0) {
++ int fd = proc->out_fds[0];
++ int n, ret;
++ struct cmsghdr* cmsg;
++ struct msghdr msg;
++ struct iovec iov;
++ char dummy = '!';
++ char buffer[sizeof(struct cmsghdr) + sizeof(int)];
++ int flags;
++
++ iov.iov_base = &dummy;
++ iov.iov_len = 1;
++ msg.msg_name = NULL;
++ msg.msg_namelen = 0;
++ msg.msg_iov = &iov;
++ msg.msg_iovlen = 1;
++ msg.msg_flags = 0;
++ msg.msg_control = buffer;
++ msg.msg_controllen = sizeof(buffer);
++
++ cmsg = CMSG_FIRSTHDR(&msg);
++ cmsg->cmsg_len = msg.msg_controllen;
++ cmsg->cmsg_level = SOL_SOCKET;
++ cmsg->cmsg_type = SCM_RIGHTS;
++ ((int*)CMSG_DATA(cmsg))[0] = fd;
++
++ flags = fcntl(proc->socket,F_GETFL,0);
++
++ if (flags == -1) {
++ D("failed to get cntl flags for socket %d: %s\n",
++ proc->pid, strerror(errno));
++ goto CloseProcess;
++
++ }
++
++ if (fcntl(proc->socket, F_SETFL, flags & ~O_NONBLOCK) == -1) {
++ D("failed to remove O_NONBLOCK flag for socket %d: %s\n",
++ proc->pid, strerror(errno));
++ goto CloseProcess;
++ }
++
++ for (;;) {
++ ret = sendmsg(proc->socket, &msg, 0);
++ if (ret >= 0) {
++ adb_close(fd);
++ break;
++ }
++ if (errno == EINTR)
++ continue;
++ D("sending new file descriptor to JDWP %d failed: %s\n",
++ proc->pid, strerror(errno));
++ goto CloseProcess;
++ }
++
++ D("sent file descriptor %d to JDWP process %d\n",
++ fd, proc->pid);
++
++ for (n = 1; n < proc->out_count; n++)
++ proc->out_fds[n-1] = proc->out_fds[n];
++
++ if (fcntl(proc->socket, F_SETFL, flags) == -1) {
++ D("failed to set O_NONBLOCK flag for socket %d: %s\n",
++ proc->pid, strerror(errno));
++ goto CloseProcess;
++ }
++
++ if (--proc->out_count == 0)
++ fdevent_del( proc->fde, FDE_WRITE );
++ }
++&nb
git.openpandora.org / openpandora.oe.git / commitdiff