| /* |
| * 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 : "<null>"); |
| 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 : "<null>"); |
| 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); |
| } |
| } |
| } |
