1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef __ADB_SOCKET_H 18 #define __ADB_SOCKET_H 19 20 #include <stddef.h> 21 22 #include <deque> 23 #include <memory> 24 #include <string> 25 26 #include "adb_unique_fd.h" 27 #include "fdevent/fdevent.h" 28 #include "types.h" 29 30 class atransport; 31 32 /* An asocket represents one half of a connection between a local and 33 * remote entity. A local asocket is bound to a file descriptor. A 34 * remote asocket is bound to the protocol engine. 35 */ 36 struct asocket { 37 /* the unique identifier for this asocket 38 */ 39 unsigned id = 0; 40 41 /* flag: set when the socket's peer has closed 42 * but packets are still queued for delivery 43 */ 44 int closing = 0; 45 46 // flag: set when the socket failed to write, so the socket will not wait to 47 // write packets and close directly. 48 bool has_write_error = 0; 49 50 /* flag: quit adbd when both ends close the 51 * local service socket 52 */ 53 int exit_on_close = 0; 54 55 // the asocket we are connected to 56 asocket* peer = nullptr; 57 58 /* For local asockets, the fde is used to bind 59 * us to our fd event system. For remote asockets 60 * these fields are not used. 61 */ 62 fdevent* fde = nullptr; 63 int fd = -1; 64 65 // queue of data waiting to be written 66 IOVector packet_queue; 67 68 std::string smart_socket_data; 69 70 /* enqueue is called by our peer when it has data 71 * for us. It should return 0 if we can accept more 72 * data or 1 if not. If we return 1, we must call 73 * peer->ready() when we once again are ready to 74 * receive data. 75 */ 76 int (*enqueue)(asocket* s, apacket::payload_type data) = nullptr; 77 78 /* ready is called by the peer when it is ready for 79 * us to send data via enqueue again 80 */ 81 void (*ready)(asocket* s) = nullptr; 82 83 /* shutdown is called by the peer before it goes away. 84 * the socket should not do any further calls on its peer. 85 * Always followed by a call to close. Optional, i.e. can be NULL. 86 */ 87 void (*shutdown)(asocket* s) = nullptr; 88 89 /* close is called by the peer when it has gone away. 90 * we are not allowed to make any further calls on the 91 * peer once our close method is called. 92 */ 93 void (*close)(asocket* s) = nullptr; 94 95 /* A socket is bound to atransport */ 96 atransport* transport = nullptr; 97 98 size_t get_max_payload() const; 99 }; 100 101 asocket *find_local_socket(unsigned local_id, unsigned remote_id); 102 void install_local_socket(asocket *s); 103 void remove_socket(asocket *s); 104 void close_all_sockets(atransport *t); 105 106 asocket* create_local_socket(unique_fd fd); 107 asocket* create_local_service_socket(std::string_view destination, atransport* transport); 108 109 asocket *create_remote_socket(unsigned id, atransport *t); 110 void connect_to_remote(asocket* s, std::string_view destination); 111 112 #if ADB_HOST 113 void connect_to_smartsocket(asocket *s); 114 #endif 115 116 // Internal functions that are only made available here for testing purposes. 117 namespace internal { 118 119 #if ADB_HOST 120 bool parse_host_service(std::string_view* out_serial, std::string_view* out_command, 121 std::string_view service); 122 #endif 123 124 } // namespace internal 125 126 #endif // __ADB_SOCKET_H 127