host/common/test/chre_test_client.cc - platform/system/chre - Git at Google

 /*
  * Copyright (C) 2017 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 "chre/util/nanoapp/app_id.h"
 #include "chre/util/system/napp_header_utils.h"
 #include "chre_host/host_protocol_host.h"
 #include "chre_host/log.h"
 #include "chre_host/socket_client.h"

 #include <inttypes.h>
 #include <sys/socket.h>
 #include <sys/types.h>

 #include <fstream>
 #include <sstream>
 #include <thread>

 #include <cutils/sockets.h>
 #include <utils/StrongPointer.h>

 /**
  * @file
  * A test utility that connects to the CHRE daemon that runs on the apps
  * processor of MSM chipsets, which is used to help test basic functionality.
  *
  * Usage:
  *  chre_test_client load <nanoapp-id> <nanoapp-path> \
  *      [app-version] [api-version] [tcm-capable]
  *  chre_test_client unload <nanoapp-id>
  */

 using android::sp;
 using android::chre::FragmentedLoadTransaction;
 using android::chre::getStringFromByteVector;
 using android::chre::HostProtocolHost;
 using android::chre::IChreMessageHandlers;
 using android::chre::SocketClient;
 using flatbuffers::FlatBufferBuilder;

 // Aliased for consistency with the way these symbols are referenced in
 // CHRE-side code
 namespace fbs = ::chre::fbs;

 namespace {

 //! The host endpoint we use when sending; set to CHRE_HOST_ENDPOINT_UNSPECIFIED
 //! Other clients below the HAL may use a value above 0x8000 to enable unicast
 //! messaging (currently requires internal coordination to avoid conflict;
 //! in the future these should be assigned by the daemon).
 constexpr uint16_t kHostEndpoint = 0xfffe;

 constexpr uint32_t kDefaultAppVersion = 1;
 constexpr uint32_t kDefaultApiVersion = 0x01000000;

 class SocketCallbacks : public SocketClient::ICallbacks,
                         public IChreMessageHandlers {
  public:
   void onMessageReceived(const void *data, size_t length) override {
     if (!HostProtocolHost::decodeMessageFromChre(data, length, *this)) {
       LOGE("Failed to decode message");
     }
   }

   void onConnected() override {
     LOGI("Socket (re)connected");
   }

   void onConnectionAborted() override {
     LOGI("Socket (re)connection aborted");
   }

   void onDisconnected() override {
     LOGI("Socket disconnected");
   }

   void handleNanoappMessage(const fbs::NanoappMessageT &message) override {
     LOGI("Got message from nanoapp 0x%" PRIx64 " to endpoint 0x%" PRIx16
          " with type 0x%" PRIx32 " and length %zu",
          message.app_id, message.host_endpoint, message.message_type,
          message.message.size());
   }

   void handleHubInfoResponse(const fbs::HubInfoResponseT &rsp) override {
     LOGI("Got hub info response:");
     LOGI("  Name: '%s'", getStringFromByteVector(rsp.name));
     LOGI("  Vendor: '%s'", getStringFromByteVector(rsp.vendor));
     LOGI("  Toolchain: '%s'", getStringFromByteVector(rsp.toolchain));
     LOGI("  Legacy versions: platform 0x%08" PRIx32 " toolchain 0x%08" PRIx32,
          rsp.platform_version, rsp.toolchain_version);
     LOGI("  MIPS %.2f Power (mW): stopped %.2f sleep %.2f peak %.2f",
          rsp.peak_mips, rsp.stopped_power, rsp.sleep_power, rsp.peak_power);
     LOGI("  Max message len: %" PRIu32, rsp.max_msg_len);
     LOGI("  Platform ID: 0x%016" PRIx64 " Version: 0x%08" PRIx32,
          rsp.platform_id, rsp.chre_platform_version);
   }

   void handleNanoappListResponse(
       const fbs::NanoappListResponseT &response) override {
     LOGI("Got nanoapp list response with %zu apps:", response.nanoapps.size());
     for (const std::unique_ptr<fbs::NanoappListEntryT> &nanoapp :
          response.nanoapps) {
       LOGI("  App ID 0x%016" PRIx64 " version 0x%" PRIx32
            " enabled %d system "
            "%d",
            nanoapp->app_id, nanoapp->version, nanoapp->enabled,
            nanoapp->is_system);
     }
   }

   void handleLoadNanoappResponse(
       const fbs::LoadNanoappResponseT &response) override {
     LOGI("Got load nanoapp response, transaction ID 0x%" PRIx32 " result %d",
          response.transaction_id, response.success);
   }

   void handleUnloadNanoappResponse(
       const fbs::UnloadNanoappResponseT &response) override {
     LOGI("Got unload nanoapp response, transaction ID 0x%" PRIx32 " result %d",
          response.transaction_id, response.success);
   }
 };

 void requestHubInfo(SocketClient &client) {
   FlatBufferBuilder builder(64);
   HostProtocolHost::encodeHubInfoRequest(builder);

   LOGI("Sending hub info request (%" PRIu32 " bytes)", builder.GetSize());
   if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
     LOGE("Failed to send message");
   }
 }

 void requestNanoappList(SocketClient &client) {
   FlatBufferBuilder builder(64);
   HostProtocolHost::encodeNanoappListRequest(builder);

   LOGI("Sending app list request (%" PRIu32 " bytes)", builder.GetSize());
   if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
     LOGE("Failed to send message");
   }
 }

 void sendMessageToNanoapp(SocketClient &client) {
   FlatBufferBuilder builder(64);
   uint8_t messageData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
   HostProtocolHost::encodeNanoappMessage(builder, chre::kMessageWorldAppId,
                                          1234 /* messageType */, kHostEndpoint,
                                          messageData, sizeof(messageData));

   LOGI("Sending message to nanoapp (%" PRIu32 " bytes w/%zu bytes of payload)",
        builder.GetSize(), sizeof(messageData));
   if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
     LOGE("Failed to send message");
   }
 }

 void sendLoadNanoappRequest(SocketClient &client, const char *filename,
                             uint64_t appId, uint32_t appVersion,
                             uint32_t apiVersion, bool tcmApp) {
   std::ifstream file(filename, std::ios::binary | std::ios::ate);
   if (!file) {
     LOGE("Couldn't open file '%s': %s", filename, strerror(errno));
     return;
   }
   ssize_t size = file.tellg();
   file.seekg(0, std::ios::beg);

   std::vector<uint8_t> buffer(size);
   if (!file.read(reinterpret_cast<char *>(buffer.data()), size)) {
     LOGE("Couldn't read from file: %s", strerror(errno));
     return;
   }

   // All loaded nanoapps must be signed currently.
   uint32_t appFlags = CHRE_NAPP_HEADER_SIGNED;
   if (tcmApp) {
     appFlags |= CHRE_NAPP_HEADER_TCM_CAPABLE;
   }

   // Perform loading with 1 fragment for simplicity
   FlatBufferBuilder builder(size + 128);
   FragmentedLoadTransaction transaction = FragmentedLoadTransaction(
       1 /* transactionId */, appId, appVersion, appFlags, apiVersion, buffer,
       buffer.size() /* fragmentSize */);
   HostProtocolHost::encodeFragmentedLoadNanoappRequest(
       builder, transaction.getNextRequest());

   LOGI("Sending load nanoapp request (%" PRIu32
        " bytes total w/%zu bytes of "
        "payload)",
        builder.GetSize(), buffer.size());
   if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
     LOGE("Failed to send message");
   }
 }

 void sendUnloadNanoappRequest(SocketClient &client, uint64_t appId) {
   FlatBufferBuilder builder(48);
   constexpr uint32_t kTransactionId = 4321;
   HostProtocolHost::encodeUnloadNanoappRequest(
       builder, kTransactionId, appId, true /* allowSystemNanoappUnload */);

   LOGI("Sending unload request for nanoapp 0x%016" PRIx64 " (size %" PRIu32 ")",
        appId, builder.GetSize());
   if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
     LOGE("Failed to send message");
   }
 }

 }  // anonymous namespace

 static void usage(const std::string &name) {
   std::string output;

   output =
       "\n"
       "Usage:\n  " +
       name +
       " load <nanoapp-id> <nanoapp-path> "
       "[app-version] [api-version]\n  " +
       name + " unload <nanoapp-id>\n";

   LOGI("%s", output.c_str());
 }

 int main(int argc, char *argv[]) {
   int argi = 0;
   const std::string name{argv[argi++]};
   const std::string cmd{argi < argc ? argv[argi++] : ""};
   const std::string idstr{argi < argc ? argv[argi++] : ""};
   const std::string path{argi < argc ? argv[argi++] : ""};
   const std::string appVerStr{argi < argc ? argv[argi++] : ""};
   const std::string apiVerStr{argi < argc ? argv[argi++] : ""};
   const std::string tcmCapStr{argi < argc ? argv[argi++] : ""};

   SocketClient client;
   sp<SocketCallbacks> callbacks = new SocketCallbacks();

   if (!client.connect("chre", callbacks)) {
     LOGE("Couldn't connect to socket");
     return -1;
   }

   if (cmd.empty()) {
     requestHubInfo(client);
     requestNanoappList(client);
     sendMessageToNanoapp(client);
     sendLoadNanoappRequest(client, "/data/activity.so",
                            0x476f6f676c00100b /* appId */, 0 /* appVersion */,
                            0x01000000 /* targetApiVersion */,
                            false /* tcmCapable */);
     sendUnloadNanoappRequest(client, 0x476f6f676c00100b /* appId */);

     LOGI("Sleeping, waiting on responses");
     std::this_thread::sleep_for(std::chrono::seconds(5));
   } else if (cmd == "load") {
     uint64_t id = 0;
     uint32_t appVersion = kDefaultAppVersion;
     uint32_t apiVersion = kDefaultApiVersion;
     bool tcmApp = false;

     if (idstr.empty() || path.empty()) {
       LOGE("Arguments not provided!");
       usage(name);
       return -1;
     }
     std::istringstream(idstr) >> std::setbase(0) >> id;
     if (!appVerStr.empty()) {
       std::istringstream(appVerStr) >> std::setbase(0) >> appVersion;
     }
     if (!apiVerStr.empty()) {
       std::istringstream(apiVerStr) >> std::setbase(0) >> apiVersion;
     }
     if (!tcmCapStr.empty()) {
       std::istringstream(tcmCapStr) >> tcmApp;
     }
     sendLoadNanoappRequest(client, path.c_str(), id, appVersion, apiVersion,
                            tcmApp);
   } else if (cmd == "unload") {
     uint64_t id = 0;

     if (idstr.empty()) {
       LOGE("Arguments not provided!");
       usage(name);
       return -1;
     }
     std::istringstream(idstr) >> std::setbase(0) >> id;
     sendUnloadNanoappRequest(client, id);
   } else {
     LOGE("Invalid command provided!");
     usage(name);
     return -1;
   }

   return 0;
 }
	/*
	* Copyright (C) 2017 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 "chre/util/nanoapp/app_id.h"
	#include "chre/util/system/napp_header_utils.h"
	#include "chre_host/host_protocol_host.h"
	#include "chre_host/log.h"
	#include "chre_host/socket_client.h"

	#include <inttypes.h>
	#include <sys/socket.h>
	#include <sys/types.h>

	#include <fstream>
	#include <sstream>
	#include <thread>

	#include <cutils/sockets.h>
	#include <utils/StrongPointer.h>

	/**
	* @file
	* A test utility that connects to the CHRE daemon that runs on the apps
	* processor of MSM chipsets, which is used to help test basic functionality.
	*
	* Usage:
	* chre_test_client load <nanoapp-id> <nanoapp-path> \
	* [app-version] [api-version] [tcm-capable]
	* chre_test_client unload <nanoapp-id>
	*/

	using android::sp;
	using android::chre::FragmentedLoadTransaction;
	using android::chre::getStringFromByteVector;
	using android::chre::HostProtocolHost;
	using android::chre::IChreMessageHandlers;
	using android::chre::SocketClient;
	using flatbuffers::FlatBufferBuilder;

	// Aliased for consistency with the way these symbols are referenced in
	// CHRE-side code
	namespace fbs = ::chre::fbs;

	namespace {

	//! The host endpoint we use when sending; set to CHRE_HOST_ENDPOINT_UNSPECIFIED
	//! Other clients below the HAL may use a value above 0x8000 to enable unicast
	//! messaging (currently requires internal coordination to avoid conflict;
	//! in the future these should be assigned by the daemon).
	constexpr uint16_t kHostEndpoint = 0xfffe;

	constexpr uint32_t kDefaultAppVersion = 1;
	constexpr uint32_t kDefaultApiVersion = 0x01000000;

	class SocketCallbacks : public SocketClient::ICallbacks,
	public IChreMessageHandlers {
	public:
	void onMessageReceived(const void *data, size_t length) override {
	if (!HostProtocolHost::decodeMessageFromChre(data, length, *this)) {
	LOGE("Failed to decode message");
	}
	}

	void onConnected() override {
	LOGI("Socket (re)connected");
	}

	void onConnectionAborted() override {
	LOGI("Socket (re)connection aborted");
	}

	void onDisconnected() override {
	LOGI("Socket disconnected");
	}

	void handleNanoappMessage(const fbs::NanoappMessageT &message) override {
	LOGI("Got message from nanoapp 0x%" PRIx64 " to endpoint 0x%" PRIx16
	" with type 0x%" PRIx32 " and length %zu",
	message.app_id, message.host_endpoint, message.message_type,
	message.message.size());
	}

	void handleHubInfoResponse(const fbs::HubInfoResponseT &rsp) override {
	LOGI("Got hub info response:");
	LOGI(" Name: '%s'", getStringFromByteVector(rsp.name));
	LOGI(" Vendor: '%s'", getStringFromByteVector(rsp.vendor));
	LOGI(" Toolchain: '%s'", getStringFromByteVector(rsp.toolchain));
	LOGI(" Legacy versions: platform 0x%08" PRIx32 " toolchain 0x%08" PRIx32,
	rsp.platform_version, rsp.toolchain_version);
	LOGI(" MIPS %.2f Power (mW): stopped %.2f sleep %.2f peak %.2f",
	rsp.peak_mips, rsp.stopped_power, rsp.sleep_power, rsp.peak_power);
	LOGI(" Max message len: %" PRIu32, rsp.max_msg_len);
	LOGI(" Platform ID: 0x%016" PRIx64 " Version: 0x%08" PRIx32,
	rsp.platform_id, rsp.chre_platform_version);
	}

	void handleNanoappListResponse(
	const fbs::NanoappListResponseT &response) override {
	LOGI("Got nanoapp list response with %zu apps:", response.nanoapps.size());
	for (const std::unique_ptr<fbs::NanoappListEntryT> &nanoapp :
	response.nanoapps) {
	LOGI(" App ID 0x%016" PRIx64 " version 0x%" PRIx32
	" enabled %d system "
	"%d",
	nanoapp->app_id, nanoapp->version, nanoapp->enabled,
	nanoapp->is_system);
	}
	}

	void handleLoadNanoappResponse(
	const fbs::LoadNanoappResponseT &response) override {
	LOGI("Got load nanoapp response, transaction ID 0x%" PRIx32 " result %d",
	response.transaction_id, response.success);
	}

	void handleUnloadNanoappResponse(
	const fbs::UnloadNanoappResponseT &response) override {
	LOGI("Got unload nanoapp response, transaction ID 0x%" PRIx32 " result %d",
	response.transaction_id, response.success);
	}
	};

	void requestHubInfo(SocketClient &client) {
	FlatBufferBuilder builder(64);
	HostProtocolHost::encodeHubInfoRequest(builder);

	LOGI("Sending hub info request (%" PRIu32 " bytes)", builder.GetSize());
	if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
	LOGE("Failed to send message");
	}
	}

	void requestNanoappList(SocketClient &client) {
	FlatBufferBuilder builder(64);
	HostProtocolHost::encodeNanoappListRequest(builder);

	LOGI("Sending app list request (%" PRIu32 " bytes)", builder.GetSize());
	if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
	LOGE("Failed to send message");
	}
	}

	void sendMessageToNanoapp(SocketClient &client) {
	FlatBufferBuilder builder(64);
	uint8_t messageData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
	HostProtocolHost::encodeNanoappMessage(builder, chre::kMessageWorldAppId,
	1234 /* messageType */, kHostEndpoint,
	messageData, sizeof(messageData));

	LOGI("Sending message to nanoapp (%" PRIu32 " bytes w/%zu bytes of payload)",
	builder.GetSize(), sizeof(messageData));
	if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
	LOGE("Failed to send message");
	}
	}

	void sendLoadNanoappRequest(SocketClient &client, const char *filename,
	uint64_t appId, uint32_t appVersion,
	uint32_t apiVersion, bool tcmApp) {
	std::ifstream file(filename, std::ios::binary \| std::ios::ate);
	if (!file) {
	LOGE("Couldn't open file '%s': %s", filename, strerror(errno));
	return;
	}
	ssize_t size = file.tellg();
	file.seekg(0, std::ios::beg);

	std::vector<uint8_t> buffer(size);
	if (!file.read(reinterpret_cast<char *>(buffer.data()), size)) {
	LOGE("Couldn't read from file: %s", strerror(errno));
	return;
	}

	// All loaded nanoapps must be signed currently.
	uint32_t appFlags = CHRE_NAPP_HEADER_SIGNED;
	if (tcmApp) {
	appFlags \|= CHRE_NAPP_HEADER_TCM_CAPABLE;
	}

	// Perform loading with 1 fragment for simplicity
	FlatBufferBuilder builder(size + 128);
	FragmentedLoadTransaction transaction = FragmentedLoadTransaction(
	1 /* transactionId */, appId, appVersion, appFlags, apiVersion, buffer,
	buffer.size() /* fragmentSize */);
	HostProtocolHost::encodeFragmentedLoadNanoappRequest(
	builder, transaction.getNextRequest());

	LOGI("Sending load nanoapp request (%" PRIu32
	" bytes total w/%zu bytes of "
	"payload)",
	builder.GetSize(), buffer.size());
	if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
	LOGE("Failed to send message");
	}
	}

	void sendUnloadNanoappRequest(SocketClient &client, uint64_t appId) {
	FlatBufferBuilder builder(48);
	constexpr uint32_t kTransactionId = 4321;
	HostProtocolHost::encodeUnloadNanoappRequest(
	builder, kTransactionId, appId, true /* allowSystemNanoappUnload */);

	LOGI("Sending unload request for nanoapp 0x%016" PRIx64 " (size %" PRIu32 ")",
	appId, builder.GetSize());
	if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
	LOGE("Failed to send message");
	}
	}

	} // anonymous namespace

	static void usage(const std::string &name) {
	std::string output;

	output =
	"\n"
	"Usage:\n " +
	name +
	" load <nanoapp-id> <nanoapp-path> "
	"[app-version] [api-version]\n " +
	name + " unload <nanoapp-id>\n";

	LOGI("%s", output.c_str());
	}

	int main(int argc, char *argv[]) {
	int argi = 0;
	const std::string name{argv[argi++]};
	const std::string cmd{argi < argc ? argv[argi++] : ""};
	const std::string idstr{argi < argc ? argv[argi++] : ""};
	const std::string path{argi < argc ? argv[argi++] : ""};
	const std::string appVerStr{argi < argc ? argv[argi++] : ""};
	const std::string apiVerStr{argi < argc ? argv[argi++] : ""};
	const std::string tcmCapStr{argi < argc ? argv[argi++] : ""};

	SocketClient client;
	sp<SocketCallbacks> callbacks = new SocketCallbacks();

	if (!client.connect("chre", callbacks)) {
	LOGE("Couldn't connect to socket");
	return -1;
	}

	if (cmd.empty()) {
	requestHubInfo(client);
	requestNanoappList(client);
	sendMessageToNanoapp(client);
	sendLoadNanoappRequest(client, "/data/activity.so",
	0x476f6f676c00100b /* appId /, 0 / appVersion */,
	0x01000000 /* targetApiVersion */,
	false /* tcmCapable */);
	sendUnloadNanoappRequest(client, 0x476f6f676c00100b /* appId */);

	LOGI("Sleeping, waiting on responses");
	std::this_thread::sleep_for(std::chrono::seconds(5));
	} else if (cmd == "load") {
	uint64_t id = 0;
	uint32_t appVersion = kDefaultAppVersion;
	uint32_t apiVersion = kDefaultApiVersion;
	bool tcmApp = false;

	if (idstr.empty() \|\| path.empty()) {
	LOGE("Arguments not provided!");
	usage(name);
	return -1;
	}
	std::istringstream(idstr) >> std::setbase(0) >> id;
	if (!appVerStr.empty()) {
	std::istringstream(appVerStr) >> std::setbase(0) >> appVersion;
	}
	if (!apiVerStr.empty()) {
	std::istringstream(apiVerStr) >> std::setbase(0) >> apiVersion;
	}
	if (!tcmCapStr.empty()) {
	std::istringstream(tcmCapStr) >> tcmApp;
	}
	sendLoadNanoappRequest(client, path.c_str(), id, appVersion, apiVersion,
	tcmApp);
	} else if (cmd == "unload") {
	uint64_t id = 0;

	if (idstr.empty()) {
	LOGE("Arguments not provided!");
	usage(name);
	return -1;
	}
	std::istringstream(idstr) >> std::setbase(0) >> id;
	sendUnloadNanoappRequest(client, id);
	} else {
	LOGE("Invalid command provided!");
	usage(name);
	return -1;
	}

	return 0;
	}