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_IO_H 18 #define ADB_IO_H 19 20 #include <sys/types.h> 21 22 #include <string> 23 #include <string_view> 24 25 #include "adb_unique_fd.h" 26 27 // Sends the protocol "OKAY" message. 28 bool SendOkay(borrowed_fd fd); 29 30 // Sends the protocol "FAIL" message, with the given failure reason. 31 bool SendFail(borrowed_fd fd, std::string_view reason); 32 33 // Writes a protocol-format string; a four hex digit length followed by the string data. 34 bool SendProtocolString(borrowed_fd fd, std::string_view s); 35 36 // Reads a protocol-format string; a four hex digit length followed by the string data. 37 bool ReadProtocolString(borrowed_fd fd, std::string* s, std::string* error); 38 39 // Reads exactly len bytes from fd into buf. 40 // 41 // Returns false if there is an error or if EOF was reached before len bytes 42 // were read. If EOF was found, errno will be set to 0. 43 // 44 // If this function fails, the contents of buf are undefined. 45 bool ReadFdExactly(borrowed_fd fd, void* buf, size_t len); 46 47 // Given a client socket, wait for orderly/graceful shutdown. Call this: 48 // 49 // * Before closing a client socket. 50 // * Only when no more data is expected to come in. 51 // * Only when the server is not waiting for data from the client (because then 52 // the client and server will deadlock waiting for each other). 53 // * Only when the server is expected to close its socket right now. 54 // * Don't call shutdown(SHUT_WR) before calling this because that will shutdown 55 // the client socket early, defeating the purpose of calling this. 56 // 57 // Waiting for orderly/graceful shutdown of the server socket will cause the 58 // server socket to close before the client socket. That prevents the client 59 // socket from staying in TIME_WAIT which eventually causes subsequent 60 // connect()s from the client to fail with WSAEADDRINUSE on Windows. 61 // Returns true if it is sure that orderly/graceful shutdown has occurred with 62 // no additional data read from the server. 63 bool ReadOrderlyShutdown(borrowed_fd fd); 64 65 // Writes exactly len bytes from buf to fd. 66 // 67 // Returns false if there is an error or if the fd was closed before the write 68 // completed. If the other end of the fd (such as in a socket, pipe, or fifo), 69 // is closed, errno will be set to 0. 70 bool WriteFdExactly(borrowed_fd fd, const void* buf, size_t len); 71 72 // Same as above, but for strings. 73 bool WriteFdExactly(borrowed_fd fd, const char* s); 74 bool WriteFdExactly(borrowed_fd fd, const std::string& s); 75 76 // Same as above, but formats the string to send. 77 bool WriteFdFmt(borrowed_fd fd, const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3))); 78 #endif /* ADB_IO_H */ 79