adb: clang-format transport.cpp (1290fbf5) · Commits · e / os / android_system_core

adb/transport.cpp

+160 −207

Original line number	Diff line number	Diff line
		@@ -60,8 +60,7 @@ static std::string dump_packet(const char* name, const char* func, apacket* p) {

		for (n = 0; n < 4; n++) {
		int b = (command >> (n * 8)) & 255;
		if (b < 32 \|\| b >= 127)
		break;
		if (b < 32 \|\| b >= 127) break;
		cmd[n] = (char)b;
		}
		if (n == 4) {
		@@ -82,15 +81,13 @@ static std::string dump_packet(const char* name, const char* func, apacket* p) {
		else
		snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);

		std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
		name, func, cmd, arg0, arg1, len);
		std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ", name,
		func, cmd, arg0, arg1, len);
		result += dump_hex(p->data, len);
		return result;
		}

		static int
		read_packet(int fd, const char* name, apacket** ppacket)
		{
		static int read_packet(int fd, const char* name, apacket** ppacket) {
		char buff[8];
		if (!name) {
		snprintf(buff, sizeof buff, "fd=%d", fd);
		@@ -113,9 +110,7 @@ read_packet(int fd, const char* name, apacket** ppacket)
		return 0;
		}

		static int
		write_packet(int fd, const char* name, apacket** ppacket)
		{
		static int write_packet(int fd, const char* name, apacket** ppacket) {
		char buff[8];
		if (!name) {
		snprintf(buff, sizeof buff, "fd=%d", fd);
		@@ -137,8 +132,7 @@ write_packet(int fd, const char* name, apacket** ppacket)
		return 0;
		}

		static void transport_socket_events(int fd, unsigned events, void *_t)
		{
		static void transport_socket_events(int fd, unsigned events, void* _t) {
		atransport* t = reinterpret_cast<atransport*>(_t);
		D("transport_socket_events(fd=%d, events=%04x,...)", fd, events);
		if (events & FDE_READ) {
		@@ -183,10 +177,10 @@ static void read_transport_thread(void* _t) {
		atransport* t = reinterpret_cast<atransport*>(_t);
		apacket* p;

		adb_thread_setname(android::base::StringPrintf("<-%s",
		(t->serial != nullptr ? t->serial : "transport")));
		D("%s: starting read_transport thread on fd %d, SYNC online (%d)",
		t->serial, t->fd, t->sync_token + 1);
		adb_thread_setname(
		android::base::StringPrintf("<-%s", (t->serial != nullptr ? t->serial : "transport")));
		D("%s: starting read_transport thread on fd %d, SYNC online (%d)", t->serial, t->fd,
		t->sync_token + 1);
		p = get_apacket();
		p->msg.command = A_SYNC;
		p->msg.arg0 = 1;
		@@ -203,8 +197,7 @@ static void read_transport_thread(void* _t) {
		p = get_apacket();

		if (t->read_from_remote(p, t) == 0) {
		D("%s: received remote packet, sending to transport",
		t->serial);
		D("%s: received remote packet, sending to transport", t->serial);
		if (write_packet(t->fd, t->serial, &p)) {
		put_apacket(p);
		D("%s: failed to write apacket to transport", t->serial);
		@@ -241,15 +234,13 @@ static void write_transport_thread(void* _t) {
		apacket* p;
		int active = 0;

		adb_thread_setname(android::base::StringPrintf("->%s",
		(t->serial != nullptr ? t->serial : "transport")));
		D("%s: starting write_transport thread, reading from fd %d",
		t->serial, t->fd);
		adb_thread_setname(
		android::base::StringPrintf("->%s", (t->serial != nullptr ? t->serial : "transport")));
		D("%s: starting write_transport thread, reading from fd %d", t->serial, t->fd);

		for (;;) {
		if (read_packet(t->fd, t->serial, &p)) {
		D("%s: failed to read apacket from transport on fd %d",
		t->serial, t->fd );
		D("%s: failed to read apacket from transport on fd %d", t->serial, t->fd);
		break;
		}
		if (p->msg.command == A_SYNC) {
		@@ -262,8 +253,7 @@ static void write_transport_thread(void* _t) {
		D("%s: transport SYNC online", t->serial);
		active = 1;
		} else {
		D("%s: transport ignoring SYNC %d != %d",
		t->serial, p->msg.arg1, t->sync_token);
		D("%s: transport ignoring SYNC %d != %d", t->serial, p->msg.arg1, t->sync_token);
		}
		}
		} else {
		@@ -296,7 +286,6 @@ static int transport_registration_send = -1;
		static int transport_registration_recv = -1;
		static fdevent transport_registration_fde;


		#if ADB_HOST

		/* this adds support required by the 'track-devices' service.
		@@ -313,9 +302,7 @@ struct device_tracker {
		/* linked list of all device trackers */
		static device_tracker* device_tracker_list;

		static void
		device_tracker_remove( device_tracker* tracker )
		{
		static void device_tracker_remove(device_tracker* tracker) {
		device_tracker** pnode = &device_tracker_list;
		device_tracker* node = *pnode;

		@@ -330,9 +317,7 @@ device_tracker_remove( device_tracker* tracker )
		}
		}

		static void
		device_tracker_close( asocket* socket )
		{
		static void device_tracker_close(asocket* socket) {
		device_tracker* tracker = (device_tracker*)socket;
		asocket* peer = socket->peer;

		@@ -345,9 +330,7 @@ device_tracker_close( asocket* socket )
		free(tracker);
		}

		static int
		device_tracker_enqueue( asocket* socket, apacket* p )
		{
		static int device_tracker_enqueue(asocket* socket, apacket* p) {
		/* you can't read from a device tracker, close immediately */
		put_apacket(p);
		device_tracker_close(socket);
		@@ -377,9 +360,7 @@ static void device_tracker_ready(asocket* socket) {
		}
		}

		asocket*
		create_device_tracker(void)
		{
		asocket* create_device_tracker(void) {
		device_tracker* tracker = reinterpret_cast<device_tracker>(calloc(1, sizeof(tracker)));
		if (tracker == nullptr) fatal("cannot allocate device tracker");

		@@ -396,7 +377,6 @@ create_device_tracker(void)
		return &tracker->socket;
		}


		// Call this function each time the transport list has changed.
		void update_transports() {
		std::string transports = list_transports(false);
		@@ -418,15 +398,12 @@ void update_transports() {

		#endif // ADB_HOST

		struct tmsg
		{
		struct tmsg {
		atransport* transport;
		int action;
		};

		static int
		transport_read_action(int fd, struct tmsg* m)
		{
		static int transport_read_action(int fd, struct tmsg* m) {
		char* p = (char*)m;
		int len = sizeof(*m);
		int r;
		@@ -444,9 +421,7 @@ transport_read_action(int fd, struct tmsg* m)
		return 0;
		}

		static int
		transport_write_action(int fd, struct tmsg* m)
		{
		static int transport_write_action(int fd, struct tmsg* m) {
		char* p = (char*)m;
		int len = sizeof(*m);
		int r;
		@@ -464,8 +439,7 @@ transport_write_action(int fd, struct tmsg* m)
		return 0;
		}

		static void transport_registration_func(int _fd, unsigned ev, void *data)
		{
		static void transport_registration_func(int _fd, unsigned ev, void* data) {
		tmsg m;
		int s[2];
		atransport* t;
		@@ -494,16 +468,11 @@ static void transport_registration_func(int _fd, unsigned ev, void *data)
		transport_list.remove(t);
		}

		if (t->product)
		free(t->product);
		if (t->serial)
		free(t->serial);
		if (t->model)
		free(t->model);
		if (t->device)
		free(t->device);
		if (t->devpath)
		free(t->devpath);
		if (t->product) free(t->product);
		if (t->serial) free(t->serial);
		if (t->model) free(t->model);
		if (t->device) free(t->device);
		if (t->devpath) free(t->devpath);

		delete t;

		@@ -525,10 +494,7 @@ static void transport_registration_func(int _fd, unsigned ev, void *data)
		t->transport_socket = s[0];
		t->fd = s[1];

		fdevent_install(&(t->transport_fde),
		t->transport_socket,
		transport_socket_events,
		t);
		fdevent_install(&(t->transport_fde), t->transport_socket, transport_socket_events, t);

		fdevent_set(&(t->transport_fde), FDE_READ);

		@@ -550,8 +516,7 @@ static void transport_registration_func(int _fd, unsigned ev, void *data)
		update_transports();
		}

		void init_transport_registration(void)
		{
		void init_transport_registration(void) {
		int s[2];

		if (adb_socketpair(s)) {
		@@ -562,17 +527,14 @@ void init_transport_registration(void)
		transport_registration_send = s[0];
		transport_registration_recv = s[1];

		fdevent_install(&transport_registration_fde,
		transport_registration_recv,
		transport_registration_func,
		0);
		fdevent_install(&transport_registration_fde, transport_registration_recv,
		transport_registration_func, 0);

		fdevent_set(&transport_registration_fde, FDE_READ);
		}

		/* the fdevent select pump is single threaded */
		static void register_transport(atransport *transport)
		{
		static void register_transport(atransport* transport) {
		tmsg m;
		m.transport = transport;
		m.action = 1;
		@@ -582,8 +544,7 @@ static void register_transport(atransport *transport)
		}
		}

		static void remove_transport(atransport *transport)
		{
		static void remove_transport(atransport* transport) {
		tmsg m;
		m.transport = transport;
		m.action = 0;
		@@ -593,7 +554,6 @@ static void remove_transport(atransport *transport)
		}
		}


		static void transport_unref(atransport* t) {
		CHECK(t != nullptr);

		@@ -609,37 +569,31 @@ static void transport_unref(atransport* t) {
		}
		}

		static int qual_match(const char *to_test,
		const char prefix, const char qual, bool sanitize_qual)
		{
		if (!to_test \|\| !*to_test)
		/* Return true if both the qual and to_test are null strings. */
		static int qual_match(const char* to_test, const char* prefix, const char* qual,
		bool sanitize_qual) {
		if (!to_test \|\| !to_test) / Return true if both the qual and to_test are null strings. */
		return !qual \|\| !*qual;

		if (!qual)
		return 0;
		if (!qual) return 0;

		if (prefix) {
		while (*prefix) {
		if (prefix++ != to_test++)
		return 0;
		if (prefix++ != to_test++) return 0;
		}
		}

		while (*qual) {
		char ch = *qual++;
		if (sanitize_qual && !isalnum(ch))
		ch = '_';
		if (ch != *to_test++)
		return 0;
		if (sanitize_qual && !isalnum(ch)) ch = '_';
		if (ch != *to_test++) return 0;
		}

		/* Everything matched so far. Return true if to_test is a NUL. /
		return !*to_test;
		}

		atransport* acquire_one_transport(TransportType type, const char* serial,
		bool* is_ambiguous, std::string* error_out) {
		atransport* acquire_one_transport(TransportType type, const char* serial, bool* is_ambiguous,
		std::string* error_out) {
		atransport* result = nullptr;

		if (serial) {
		@@ -737,15 +691,24 @@ void atransport::Kick() {

		const std::string atransport::connection_state_name() const {
		switch (connection_state) {
		case kCsOffline: return "offline";
		case kCsBootloader: return "bootloader";
		case kCsDevice: return "device";
		case kCsHost: return "host";
		case kCsRecovery: return "recovery";
		case kCsNoPerm: return UsbNoPermissionsShortHelpText();
		case kCsSideload: return "sideload";
		case kCsUnauthorized: return "unauthorized";
		default: return "unknown";
		case kCsOffline:
		return "offline";
		case kCsBootloader:
		return "bootloader";
		case kCsDevice:
		return "device";
		case kCsHost:
		return "host";
		case kCsRecovery:
		return "recovery";
		case kCsNoPerm:
		return UsbNoPermissionsShortHelpText();
		case kCsSideload:
		return "sideload";
		case kCsUnauthorized:
		return "unauthorized";
		default:
		return "unknown";
		}
		}

		@@ -771,9 +734,7 @@ constexpr char kFeatureStringDelimiter = ',';
		const FeatureSet& supported_features() {
		// Local static allocation to avoid global non-POD variables.
		static const FeatureSet* features = new FeatureSet{
		kFeatureShell2,
		kFeatureCmd,
		kFeatureStat2,
		kFeatureShell2, kFeatureCmd, kFeatureStat2,
		// Increment ADB_SERVER_VERSION whenever the feature list changes to
		// make sure that the adb client and server features stay in sync
		// (http://b/24370690).
		@@ -791,14 +752,12 @@ FeatureSet StringToFeatureSet(const std::string& features_string) {
		return FeatureSet();
		}

		auto names = android::base::Split(features_string,
		{kFeatureStringDelimiter});
		auto names = android::base::Split(features_string, {kFeatureStringDelimiter});
		return FeatureSet(names.begin(), names.end());
		}

		bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature) {
		return feature_set.count(feature) > 0 &&
		supported_features().count(feature) > 0;
		return feature_set.count(feature) > 0 && supported_features().count(feature) > 0;
		}

		bool atransport::has_feature(const std::string& feature) const {
		@@ -841,8 +800,7 @@ bool atransport::MatchesTarget(const std::string& target) const {
		// Parse our \|serial\| and the given \|target\| to check if the hostnames and ports match.
		std::string serial_host, error;
		int serial_port = -1;
		if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr,
		&error)) {
		if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr, &error)) {
		// \|target\| may omit the port to default to ours.
		std::string target_host;
		int target_port = serial_port;
		@@ -863,8 +821,8 @@ bool atransport::MatchesTarget(const std::string& target) const {

		#if ADB_HOST

		static void append_transport_info(std::string* result, const char* key,
		const char* value, bool sanitize) {
		static void append_transport_info(std::string* result, const char* key, const char* value,
		bool sanitize) {
		if (value == nullptr \|\| *value == '\0') {
		return;
		}
		@@ -877,8 +835,7 @@ static void append_transport_info(std::string* result, const char* key,
		}
		}

		static void append_transport(const atransport* t, std::string* result,
		bool long_listing) {
		static void append_transport(const atransport* t, std::string* result, bool long_listing) {
		const char* serial = t->serial;
		if (!serial \|\| !serial[0]) {
		serial = "(no serial number)";
		@@ -889,8 +846,7 @@ static void append_transport(const atransport* t, std::string* result,
		*result += '\t';
		*result += t->connection_state_name();
		} else {
		android::base::StringAppendF(result, "%-22s %s", serial,
		t->connection_state_name().c_str());
		android::base::StringAppendF(result, "%-22s %s", serial, t->connection_state_name().c_str());

		append_transport_info(result, "", t->devpath, false);
		append_transport_info(result, "product:", t->product, false);
		@@ -998,12 +954,11 @@ void kick_all_tcp_devices() {

		#endif

		void register_usb_transport(usb_handle* usb, const char* serial,
		const char* devpath, unsigned writeable) {
		void register_usb_transport(usb_handle* usb, const char* serial, const char* devpath,
		unsigned writeable) {
		atransport* t = new atransport();

		D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb,
		serial ? serial : "");
		D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb, serial ? serial : "");
		init_usb_transport(t, usb, (writeable ? kCsOffline : kCsNoPerm));
		if (serial) {
		t->serial = strdup(serial);
		@@ -1024,21 +979,19 @@ void register_usb_transport(usb_handle* usb, const char* serial,
		// This should only be used for transports with connection_state == kCsNoPerm.
		void unregister_usb_transport(usb_handle* usb) {
		std::lock_guard<std::mutex> lock(transport_lock);
		transport_list.remove_if([usb](atransport* t) {
		return t->usb == usb && t->connection_state == kCsNoPerm;
		});
		transport_list.remove_if(
		[usb](atransport* t) { return t->usb == usb && t->connection_state == kCsNoPerm; });
		}

		int check_header(apacket p, atransport t)
		{
		int check_header(apacket* p, atransport* t) {
		if (p->msg.magic != (p->msg.command ^ 0xffffffff)) {
		VLOG(RWX) << "check_header(): invalid magic";
		return -1;
		}

		if (p->msg.data_length > t->get_max_payload()) {
		VLOG(RWX) << "check_header(): " << p->msg.data_length << " atransport::max_payload = "
		<< t->get_max_payload();
		VLOG(RWX) << "check_header(): " << p->msg.data_length
		<< " atransport::max_payload = " << t->get_max_payload();
		return -1;
		}