/* * 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 "qemu-common.h" #include "android/globals.h" /* for android_hw */ #include "android/hw-qemud.h" #include "android/utils/misc.h" #include "android/utils/system.h" #include "android/utils/debug.h" #include "android/adb-server.h" #include "android/adb-qemud.h" #define E(...) derror(__VA_ARGS__) #define W(...) dwarning(__VA_ARGS__) #define D(...) VERBOSE_PRINT(adbclient,__VA_ARGS__) #define DD(...) VERBOSE_PRINT(adb,__VA_ARGS__) #define D_ACTIVE VERBOSE_CHECK(adbclient) #define DD_ACTIVE VERBOSE_CHECK(adb) #define QB(b, s) quote_bytes((const char*)b, (s < 32) ? s : 32) #define SERVICE_NAME "adb" #define DEBUG_SERVICE_NAME "adb-debug" /* Maximum length of the message that can be received from the guest. */ #define ADB_MAX_MSG_LEN 8 /* Enumerates ADB client state values. */ typedef enum AdbClientState { /* Waiting on a connection from ADB host. */ ADBC_STATE_WAIT_ON_HOST, /* ADB host is connected. Waiting on the transport initialization completion * in the guest. */ ADBC_STATE_HOST_CONNECTED, /* Connection between ADB host and ADB guest is fully established. */ ADBC_STATE_CONNECTED, /* ADB host has been disconnected. */ ADBC_STATE_HOST_DISCONNECTED, /* ADB guest has been disconnected. */ ADBC_STATE_GUEST_DISCONNECTED, } AdbClientState; /* ADB client descriptor. */ typedef struct AdbClient AdbClient; struct AdbClient { /* Opaque pointer returned from adb_server_register_guest API. */ void* opaque; /* QEMUD client pipe for this client. */ QemudClient* qemud_client; /* Connection state. */ AdbClientState state; /* Buffer, collecting accept / stop messages from client. */ char msg_buffer[ADB_MAX_MSG_LEN]; /* Current position in message buffer. */ int msg_cur; }; /* ADB debugging client descriptor. */ typedef struct AdbDbgClient AdbDbgClient; struct AdbDbgClient { /* QEMUD client pipe for this client. */ QemudClient* qemud_client; }; /******************************************************************************** * ADB host communication. *******************************************************************************/ /* A callback that is invoked when the host is connected. * Param: * opaque - AdbClient instance. * connection - An opaque pointer that identifies connection with the ADB host. */ static void _adb_on_host_connected(void* opaque, void* connection) { AdbClient* const adb_client = (AdbClient*)opaque; if (adb_client->state == ADBC_STATE_WAIT_ON_HOST) { D("ADB client %p(o=%p) is connected to the host %p", adb_client, adb_client->opaque, connection); /* Bump the state up. */ adb_client->state = ADBC_STATE_HOST_CONNECTED; /* Notify the ADB guest that host has been connected.This will unblock * the guest from a 'read', then guest will register the transport, and * will send 'setart' request, indicating that it is ready to receive * data from the host. */ qemud_client_send(adb_client->qemud_client, (const uint8_t*)"ok", 2); } else { D("Unexpected ADB host connection while state is %d", adb_client->state); } } /* A callback that is invoked when the host gets disconnected. * Param: * opaque - AdbClient instance. * connection - An opaque pointer that identifies connection with the ADB host. */ static void _adb_on_host_disconnect(void* opaque, void* connection) { AdbClient* const adb_client = (AdbClient*)opaque; D("ADB client %p(o=%p) is disconnected from the host %p", adb_client, adb_client->opaque, connection); adb_client->state = ADBC_STATE_HOST_DISCONNECTED; } /* A callback that is invoked when the host sends data. * Param: * opaque - AdbClient instance. * connection - An opaque pointer that identifies connection with the ADB host. * buff, size - Buffer containing the host data. */ static void _adb_on_host_data(void* opaque, void* connection, const void* buff, int size) { AdbClient* const adb_client = (AdbClient*)opaque; D("ADB client %p(o=%p) received from the host %p %d bytes in %s", adb_client, adb_client->opaque, connection, size, QB(buff, size)); if (adb_client->state == ADBC_STATE_CONNECTED) { /* Dispatch data down to the guest. */ qemud_client_send(adb_client->qemud_client, (const uint8_t*)buff, size); } else { D("Unexpected data from ADB host %p while client %p(o=%p) is in state %d", connection, adb_client, adb_client->opaque, adb_client->state); } } /* ADB guest API required for adb_server_register_guest */ static AdbGuestRoutines _adb_client_routines = { /* A callback that is invoked when the host is connected. */ _adb_on_host_connected, /* A callback that is invoked when the host gets disconnected. */ _adb_on_host_disconnect, /* A callback that is invoked when the host sends data. */ _adb_on_host_data, }; /******************************************************************************** * ADB guest communication. *******************************************************************************/ /* Allocates AdbClient instance. */ static AdbClient* _adb_client_new(void) { AdbClient* adb_client; ANEW0(adb_client); return adb_client; } /* Frees AdbClient instance, allocated with _adb_client_new */ static void _adb_client_free(AdbClient* adb_client) { if (adb_client != NULL) { free(adb_client); } } /* A callback that is invoked when ADB guest sends data to the service. * Param: * opaque - AdbClient instance. * msg, msglen - Message received from the ADB guest. * client - adb QEMUD client. */ static void _adb_client_recv(void* opaque, uint8_t* msg, int msglen, QemudClient* client) { AdbClient* const adb_client = (AdbClient*)opaque; D("ADB client %p(o=%p) received from guest %d bytes in %s", adb_client, adb_client->opaque, msglen, QB(msg, msglen)); if (adb_client->state == ADBC_STATE_CONNECTED) { /* Connection is fully established. Dispatch the message to the host. */ adb_server_on_guest_message(adb_client->opaque, msg, msglen); return; } /* * At this point we expect either "accept", or "start" messages. Depending * on the state of the pipe (although small) these messages could be broken * into pieces. So, simply checking msg for "accept", or "start" may not * work. Lets collect them first in internal buffer, and then will see. */ /* Make sure tha message doesn't overflow the buffer. */ if ((msglen + adb_client->msg_cur) > sizeof(adb_client->msg_buffer)) { D("Unexpected message in ADB client."); adb_client->msg_cur = 0; return; } /* Append to current message. */ memcpy(adb_client->msg_buffer + adb_client->msg_cur, msg, msglen); adb_client->msg_cur += msglen; /* Properly dispatch the message, depending on the client state. */ switch (adb_client->state) { case ADBC_STATE_WAIT_ON_HOST: /* At this state the only message that is allowed is 'accept' */ if (adb_client->msg_cur == 6 && !memcmp(adb_client->msg_buffer, "accept", 6)) { adb_client->msg_cur = 0; /* Register ADB guest connection with the ADB server. */ adb_client->opaque = adb_server_register_guest(adb_client, &_adb_client_routines); if (adb_client->opaque == NULL) { D("Unable to register ADB guest with the ADB server."); /* KO the guest. */ qemud_client_send(adb_client->qemud_client, (const uint8_t*)"ko", 2); } } else { D("Unexpected guest request while waiting on ADB host to connect."); } break; case ADBC_STATE_HOST_CONNECTED: /* At this state the only message that is allowed is 'start' */ if (adb_client->msg_cur && !memcmp(adb_client->msg_buffer, "start", 5)) { adb_client->msg_cur = 0; adb_client->state = ADBC_STATE_CONNECTED; adb_server_complete_connection(adb_client->opaque); } else { D("Unexpected request while waiting on connection to start."); } break; default: D("Unexpected ADB guest request '%s' while client state is %d.", QB(msg, msglen), adb_client->state); break; } } /* A callback that is invoked when ADB guest disconnects from the service. */ static void _adb_client_close(void* opaque) { AdbClient* const adb_client = (AdbClient*)opaque; D("ADB client %p(o=%p) is disconnected from the guest.", adb_client, adb_client->opaque); adb_client->state = ADBC_STATE_GUEST_DISCONNECTED; if (adb_client->opaque != NULL) { /* Close connection with the host. */ adb_server_on_guest_closed(adb_client->opaque); } _adb_client_free(adb_client); } /* A callback that is invoked when ADB daemon running inside the guest connects * to the service. * Client parameters are ignored here. Typically they contain the ADB port number * which is always 5555 for the device / emulated system. */ static QemudClient* _adb_service_connect(void* opaque, QemudService* serv, int channel, const char* client_param) { /* Create new QEMUD client for the connection with ADB daemon. */ AdbClient* const adb_client = _adb_client_new(); D("Connecting ADB guest: '%s'", client_param ? client_param : ""); adb_client->qemud_client = qemud_client_new(serv, channel, client_param, adb_client, _adb_client_recv, _adb_client_close, NULL, NULL); if (adb_client->qemud_client == NULL) { D("Unable to create QEMUD client for ADB guest."); _adb_client_free(adb_client); return NULL; } return adb_client->qemud_client; } /******************************************************************************** * Debugging ADB guest communication. *******************************************************************************/ /* Allocates AdbDbgClient instance. */ static AdbDbgClient* _adb_dbg_client_new(void) { AdbDbgClient* adb_dbg_client; ANEW0(adb_dbg_client); return adb_dbg_client; } /* Frees AdbDbgClient instance, allocated with _adb_dbg_client_new */ static void _adb_dbg_client_free(AdbDbgClient* adb_dbg_client) { if (adb_dbg_client != NULL) { free(adb_dbg_client); } } /* A callback that is invoked when ADB debugging guest sends data to the service. * Param: * opaque - AdbDbgClient instance. * msg, msglen - Message received from the ADB guest. * client - adb-debug QEMUD client. */ static void _adb_dbg_client_recv(void* opaque, uint8_t* msg, int msglen, QemudClient* client) { if (DD_ACTIVE) { fprintf(stderr, "ADB: %s", (const char*)msg); } } /* A callback that is invoked when ADB debugging guest disconnects from the * service. */ static void _adb_dbg_client_close(void* opaque) { AdbDbgClient* const adb_dbg_client = (AdbDbgClient*)opaque; DD("ADB debugging client %p is disconnected from the guest.", adb_dbg_client); _adb_dbg_client_free(adb_dbg_client); } /* A callback that is invoked when ADB daemon running inside the guest connects * to the debugging service. * Client parameters are ignored here. */ static QemudClient* _adb_debug_service_connect(void* opaque, QemudService* serv, int channel, const char* client_param) { /* Create new QEMUD client for the connection with ADB debugger. */ AdbDbgClient* const adb_dbg_client = _adb_dbg_client_new(); DD("Connecting ADB debugging guest: '%s'", client_param ? client_param : ""); adb_dbg_client->qemud_client = qemud_client_new(serv, channel, client_param, adb_dbg_client, _adb_dbg_client_recv, _adb_dbg_client_close, NULL, NULL); if (adb_dbg_client->qemud_client == NULL) { DD("Unable to create QEMUD client for ADB debugging guest."); _adb_dbg_client_free(adb_dbg_client); return NULL; } return adb_dbg_client->qemud_client; } /******************************************************************************** * ADB service API. *******************************************************************************/ void android_adb_service_init(void) { static int _inited = 0; if (!adb_server_is_initialized()) { return; } if (!_inited) { /* Register main ADB service. */ QemudService* serv = qemud_service_register(SERVICE_NAME, 0, NULL, _adb_service_connect, NULL, NULL); if (serv == NULL) { derror("%s: Could not register '%s' service", __FUNCTION__, SERVICE_NAME); return; } D("%s: Registered '%s' qemud service", __FUNCTION__, SERVICE_NAME); /* Register debugging ADB service. */ serv = qemud_service_register(DEBUG_SERVICE_NAME, 0, NULL, _adb_debug_service_connect, NULL, NULL); if (serv != NULL) { DD("Registered '%s' qemud service", DEBUG_SERVICE_NAME); } else { dwarning("%s: Could not register '%s' service", __FUNCTION__, DEBUG_SERVICE_NAME); } } }