Merge branch 'jb-mr1-release' of https://android.googlesource.com/platform/system/core into mr1 (39d33d8d) · Commits · e / os / android_system_core

adb/Android.mk

+14 −6

Original line number	Diff line number	Diff line
		@@ -33,16 +33,16 @@ endif

		ifeq ($(HOST_OS),windows)
		USB_SRCS := usb_windows.c
		EXTRA_SRCS := get_my_path_windows.c
		EXTRA_SRCS := get_my_path_windows.c ../libcutils/list.c
		EXTRA_STATIC_LIBS := AdbWinApi
		ifneq ($(strip $(USE_CYGWIN)),)
		# Pure cygwin case
		LOCAL_LDLIBS += -lpthread
		LOCAL_LDLIBS += -lpthread -lgdi32
		LOCAL_C_INCLUDES += /usr/include/w32api/ddk
		endif
		ifneq ($(strip $(USE_MINGW)),)
		# MinGW under Linux case
		LOCAL_LDLIBS += -lws2_32
		LOCAL_LDLIBS += -lws2_32 -lgdi32
		USE_SYSDEPS_WIN32 := 1
		LOCAL_C_INCLUDES += /usr/i586-mingw32msvc/include/ddk
		endif
		@@ -57,6 +57,7 @@ LOCAL_SRC_FILES := \
		transport_usb.c \
		commandline.c \
		adb_client.c \
		adb_auth_host.c \
		sockets.c \
		services.c \
		file_sync_client.c \
		@@ -65,6 +66,7 @@ LOCAL_SRC_FILES := \
		utils.c \
		usb_vendors.c

		LOCAL_C_INCLUDES += external/openssl/include

		ifneq ($(USE_SYSDEPS_WIN32),)
		LOCAL_SRC_FILES += sysdeps_win32.c
		@@ -85,14 +87,14 @@ endif
		LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE
		LOCAL_MODULE := adb

		LOCAL_STATIC_LIBRARIES := libzipfile libunz $(EXTRA_STATIC_LIBS)
		LOCAL_STATIC_LIBRARIES := libzipfile libunz libcrypto_static $(EXTRA_STATIC_LIBS)
		ifeq ($(USE_SYSDEPS_WIN32),)
		LOCAL_STATIC_LIBRARIES += libcutils
		endif

		include $(BUILD_HOST_EXECUTABLE)

		$(call dist-for-goals,dist_files,$(LOCAL_BUILT_MODULE))
		$(call dist-for-goals,dist_files sdk,$(LOCAL_BUILT_MODULE))

		ifeq ($(HOST_OS),windows)
		$(LOCAL_INSTALLED_MODULE): \
		@@ -113,6 +115,7 @@ LOCAL_SRC_FILES := \
		transport.c \
		transport_local.c \
		transport_usb.c \
		adb_auth_client.c \
		sockets.c \
		services.c \
		file_sync_service.c \
		@@ -149,7 +152,7 @@ LOCAL_FORCE_STATIC_EXECUTABLE := true
		LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT_SBIN)
		LOCAL_UNSTRIPPED_PATH := $(TARGET_ROOT_OUT_SBIN_UNSTRIPPED)

		LOCAL_STATIC_LIBRARIES := libcutils libc
		LOCAL_STATIC_LIBRARIES := libcutils libc libmincrypt
		include $(BUILD_EXECUTABLE)


		@@ -168,6 +171,7 @@ LOCAL_SRC_FILES := \
		transport_usb.c \
		commandline.c \
		adb_client.c \
		adb_auth_host.c \
		sockets.c \
		services.c \
		file_sync_client.c \
		@@ -196,9 +200,13 @@ ifneq ($(findstring -O0, $(TARGET_GLOBAL_CFLAGS)),)
		LOCAL_CFLAGS += -O2
		endif

		LOCAL_C_INCLUDES += external/openssl/include

		LOCAL_MODULE := adb

		LOCAL_STATIC_LIBRARIES := libzipfile libunz libcutils

		LOCAL_SHARED_LIBRARIES := libcrypto

		include $(BUILD_EXECUTABLE)
		endif

adb/SERVICES.TXT

+6 −1

Original line number	Diff line number	Diff line
		@@ -17,8 +17,10 @@ host:kill
		upgrade.

		host:devices
		host:devices-l
		Ask to return the list of available Android devices and their
		state. After the OKAY, this is followed by a 4-byte hex len,
		state. devices-l includes the device paths in the state.
		After the OKAY, this is followed by a 4-byte hex len,
		and a string that will be dumped as-is by the client, then
		the connection is closed

		@@ -88,6 +90,9 @@ host:<request>
		Returns the serial number of the corresponding device/emulator.
		Note that emulator serial numbers are of the form "emulator-5554"

		<host-prefix>:get-devpath
		Returns the device path of the corresponding device/emulator.

		<host-prefix>:get-state
		Returns the state of a given device as a string.

adb/adb.c

+245 −56

Original line number	Diff line number	Diff line
		@@ -21,17 +21,22 @@
		#include <ctype.h>
		#include <stdarg.h>
		#include <errno.h>
		#include <stddef.h>
		#include <string.h>
		#include <time.h>
		#include <sys/time.h>

		#include "sysdeps.h"
		#include "adb.h"
		#include "adb_auth.h"

		#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

		#if !ADB_HOST
		#include <private/android_filesystem_config.h>
		#include <linux/capability.h>
		#include <linux/prctl.h>
		#include <sys/mount.h>
		#else
		#include "usb_vendors.h"
		#endif
		@@ -42,7 +47,11 @@ ADB_MUTEX_DEFINE( D_lock );

		int HOST = 0;

		static int auth_enabled = 0;

		#if !ADB_HOST
		static const char *adb_device_banner = "device";
		#endif

		void fatal(const char *fmt, ...)
		{
		@@ -94,6 +103,7 @@ void adb_trace_init(void)
		{ "transport", TRACE_TRANSPORT },
		{ "jdwp", TRACE_JDWP },
		{ "services", TRACE_SERVICES },
		{ "auth", TRACE_AUTH },
		{ NULL, 0 }
		};

		@@ -197,19 +207,21 @@ void put_apacket(apacket *p)
		free(p);
		}

		void handle_online(void)
		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 TRACE_PACKETS
		#if DEBUG_PACKETS
		#define DUMPMAX 32
		void print_packet(const char label, apacket p)
		{
		@@ -224,6 +236,7 @@ void print_packet(const char label, apacket p)
		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;
		}

		@@ -245,7 +258,7 @@ void print_packet(const char label, apacket p)
		}
		x++;
		}
		fprintf(stderr, tag);
		fputs(tag, stderr);
		}
		#endif

		@@ -269,6 +282,36 @@ static void send_close(unsigned local, unsigned remote, atransport *t)
		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);
		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], value);
		remaining -= len;
		buf += len;
		}

		return bufsize - remaining + 1;
		#endif
		}

		static void send_connect(atransport *t)
		{
		D("Calling send_connect \n");
		@@ -276,15 +319,73 @@ static void send_connect(atransport *t)
		cp->msg.command = A_CNXN;
		cp->msg.arg0 = A_VERSION;
		cp->msg.arg1 = MAX_PAYLOAD;
		snprintf((char*) cp->data, sizeof cp->data, "%s::",
		HOST ? "host" : adb_device_banner);
		cp->msg.data_length = strlen((char*) cp->data) + 1;
		cp->msg.data_length = fill_connect_data((char *)cp->data,
		sizeof(cp->data));
		send_packet(cp, t);
		#if ADB_HOST
		/* XXX why sleep here? */
		// allow the device some time to respond to the connect message
		adb_sleep_ms(1000);
		#endif
		}

		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)
		@@ -305,29 +406,56 @@ static char connection_state_name(atransport t)
		}
		}

		/* 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)
		{
		char type, product, *end;
		static const char *prop_seps = ";";
		static const char key_val_sep = '=';
		char *cp;
		char *type;

		D("parse_banner: %s\n", banner);
		type = banner;
		product = strchr(type, ':');
		if(product) {
		*product++ = 0;
		} else {
		product = "";
		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);
		}
		}

		/* remove trailing ':' */
		end = strchr(product, ':');
		if(end) *end = 0;

		/* save product name in device structure */
		if (t->product == NULL) {
		t->product = strdup(product);
		} else if (strcmp(product, t->product) != 0) {
		free(t->product);
		t->product = strdup(product);
		}

		if(!strcmp(type, "bootloader")){
		@@ -389,13 +517,42 @@ void handle_packet(apacket p, atransport t)
		t->connection_state = CS_OFFLINE;
		handle_offline(t);
		}

		parse_banner((char*) p->data, t);
		handle_online();

		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->connection_state != CS_OFFLINE) {
		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);
		@@ -411,7 +568,7 @@ void handle_packet(apacket p, atransport t)
		break;

		case A_OKAY: /* READY(local-id, remote-id, "") */
		if(t->connection_state != CS_OFFLINE) {
		if (t->online) {
		if((s = find_local_socket(p->msg.arg1))) {
		if(s->peer == 0) {
		s->peer = create_remote_socket(p->msg.arg0, t);
		@@ -423,7 +580,7 @@ void handle_packet(apacket p, atransport t)
		break;

		case A_CLSE: /* CLOSE(local-id, remote-id, "") */
		if(t->connection_state != CS_OFFLINE) {
		if (t->online) {
		if((s = find_local_socket(p->msg.arg1))) {
		s->close(s);
		}
		@@ -431,7 +588,7 @@ void handle_packet(apacket p, atransport t)
		break;

		case A_WRTE:
		if(t->connection_state != CS_OFFLINE) {
		if (t->online) {
		if((s = find_local_socket(p->msg.arg1))) {
		unsigned rid = p->msg.arg0;
		p->len = p->msg.data_length;
		@@ -947,12 +1104,12 @@ int adb_main(int is_daemon, int server_port)

		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);
		@@ -960,6 +1117,20 @@ int adb_main(int is_daemon, int server_port)
		exit(1);
		}
		#else
		property_get("ro.adb.secure", value, "0");
		auth_enabled = !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 */
		@@ -1014,24 +1185,29 @@ int adb_main(int is_daemon, int server_port)
		}
		}

		/* for the device, start the usb transport if the
		** android usb device exists and the "service.adb.tcp.port" and
		** "persist.adb.tcp.port" properties are not set.
		** Otherwise start the network transport.
		*/
		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])
		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 (access("/dev/android_adb", F_OK) == 0) {
		// listen on USB
		usb_init();
		} else {
		} else if (!usb) {
		// 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");
		@@ -1067,7 +1243,7 @@ void connect_device(char* host, char* buffer, int buffer_size)

		strncpy(hostbuf, host, sizeof(hostbuf) - 1);
		if (portstr) {
		if (portstr - host >= sizeof(hostbuf)) {
		if (portstr - host >= (ptrdiff_t)sizeof(hostbuf)) {
		snprintf(buffer, buffer_size, "bad host name %s", host);
		return;
		}
		@@ -1201,17 +1377,20 @@ int handle_host_request(char service, transport_type ttype, char serial, int r
		}

		// return a list of all connected devices
		if (!strcmp(service, "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));
		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)) {
		@@ -1276,6 +1455,16 @@ int handle_host_request(char service, transport_type ttype, char serial, int r
		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);

adb/adb.h

+28 −4

Original line number	Diff line number	Diff line
		@@ -29,13 +29,14 @@
		#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 29 // Increment this when we want to force users to start a new adb server
		#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;
		@@ -165,6 +166,8 @@ typedef enum transport_type {
		kTransportHost,
		} transport_type;

		#define TOKEN_SIZE 20

		struct atransport
		{
		atransport *next;
		@@ -181,6 +184,7 @@ struct atransport
		int ref_count;
		unsigned sync_token;
		int connection_state;
		int online;
		transport_type type;

		/* usb handle or socket fd as needed */
		@@ -190,11 +194,19 @@ struct atransport
		/* 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;
		};


		@@ -253,7 +265,7 @@ int adb_main(int is_daemon, int server_port);
		** 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 list_transports(char *buf, size_t bufsize, int long_listing);
		void update_transports(void);

		asocket* create_device_tracker(void);
		@@ -286,7 +298,7 @@ void register_socket_transport(int s, const char *serial, int port, int local);
		void unregister_transport(atransport *t);
		void unregister_all_tcp_transports();

		void register_usb_transport(usb_handle h, const char serial, unsigned writeable);
		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);
		@@ -346,6 +358,7 @@ typedef enum {
		TRACE_SYSDEPS,
		TRACE_JDWP, /* 0x100 */
		TRACE_SERVICES,
		TRACE_AUTH,
		} AdbTrace;

		#if ADB_TRACE
		@@ -405,7 +418,7 @@ void adb_qemu_trace(const char* fmt, ...);
		#endif


		#if !TRACE_PACKETS
		#if !DEBUG_PACKETS
		#define print_packet(tag,p) do {} while (0)
		#endif

		@@ -461,6 +474,17 @@ 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);

adb/adb_auth.h

0 → 100644

+54 −0

Original line number	Diff line number	Diff line
		/*
		* 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