Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 93d63c01 authored by Josh Gao's avatar Josh Gao
Browse files

Add a way to turn off unique_fd's operator int. 

unique_fd's implicit conversion to int has led to tons of problems (see
all of the overloads for close, fdopen, fdopendir, etc.). Add a switch
that can turn it off, and reduce the ridiculous amount of work to fix up
callers by introducing a borrowed_fd type that can be constructed from
either int or unique_fd.

Test: treehugger
Change-Id: If77cf5cbcaddacdaec5919a15b3520fb68f51a62
parent 499601b9

adb/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ cc_defaults { 
        "-Wvla",

        "-DADB_HOST=1",         // overridden by adbd_defaults

        "-DALLOW_ADBD_ROOT=0",  // overridden by adbd_defaults

        "-DANDROID_BASE_UNIQUE_FD_DISABLE_IMPLICIT_CONVERSION=1",

    ],

    cpp_std: "experimental",

adb/adb_io.cpp

+20 −20
Original line number Diff line number Diff line
@@ -34,7 +34,7 @@ 
#include "adb_utils.h"

#include "sysdeps.h"



bool SendProtocolString(int fd, std::string_view s) {

bool SendProtocolString(borrowed_fd fd, std::string_view s) {

    unsigned int length = s.size();

    if (length > MAX_PAYLOAD - 4) {

        errno = EMSGSIZE;
@@ -47,7 +47,7 @@ bool SendProtocolString(int fd, std::string_view s) { 
    return WriteFdExactly(fd, str);

}



bool ReadProtocolString(int fd, std::string* s, std::string* error) {

bool ReadProtocolString(borrowed_fd fd, std::string* s, std::string* error) {

    char buf[5];

    if (!ReadFdExactly(fd, buf, 4)) {

        *error = perror_str("protocol fault (couldn't read status length)");
@@ -65,57 +65,57 @@ bool ReadProtocolString(int fd, std::string* s, std::string* error) { 
    return true;

}



bool SendOkay(int fd) {

bool SendOkay(borrowed_fd fd) {

    return WriteFdExactly(fd, "OKAY", 4);

}



bool SendFail(int fd, std::string_view reason) {

bool SendFail(borrowed_fd fd, std::string_view reason) {

    return WriteFdExactly(fd, "FAIL", 4) && SendProtocolString(fd, reason);

}



bool ReadFdExactly(int fd, void* buf, size_t len) {

bool ReadFdExactly(borrowed_fd fd, void* buf, size_t len) {

    char* p = reinterpret_cast<char*>(buf);



    size_t len0 = len;



    D("readx: fd=%d wanted=%zu", fd, len);

    D("readx: fd=%d wanted=%zu", fd.get(), len);

    while (len > 0) {

        int r = adb_read(fd, p, len);

        if (r > 0) {

            len -= r;

            p += r;

        } else if (r == -1) {

            D("readx: fd=%d error %d: %s", fd, errno, strerror(errno));

            D("readx: fd=%d error %d: %s", fd.get(), errno, strerror(errno));

            return false;

        } else {

            D("readx: fd=%d disconnected", fd);

            D("readx: fd=%d disconnected", fd.get());

            errno = 0;

            return false;

        }

    }



    VLOG(RWX) << "readx: fd=" << fd << " wanted=" << len0 << " got=" << (len0 - len)

              << " " << dump_hex(reinterpret_cast<const unsigned char*>(buf), len0);

    VLOG(RWX) << "readx: fd=" << fd.get() << " wanted=" << len0 << " got=" << (len0 - len) << " "

              << dump_hex(reinterpret_cast<const unsigned char*>(buf), len0);



    return true;

}



bool WriteFdExactly(int fd, const void* buf, size_t len) {

bool WriteFdExactly(borrowed_fd fd, const void* buf, size_t len) {

    const char* p = reinterpret_cast<const char*>(buf);

    int r;



    VLOG(RWX) << "writex: fd=" << fd << " len=" << len

              << " " << dump_hex(reinterpret_cast<const unsigned char*>(buf), len);

    VLOG(RWX) << "writex: fd=" << fd.get() << " len=" << len << " "

              << dump_hex(reinterpret_cast<const unsigned char*>(buf), len);



    while (len > 0) {

        r = adb_write(fd, p, len);

        if (r == -1) {

            D("writex: fd=%d error %d: %s", fd, errno, strerror(errno));

            D("writex: fd=%d error %d: %s", fd.get(), errno, strerror(errno));

            if (errno == EAGAIN) {

                std::this_thread::yield();

                continue;

            } else if (errno == EPIPE) {

                D("writex: fd=%d disconnected", fd);

                D("writex: fd=%d disconnected", fd.get());

                errno = 0;

                return false;

            } else {
@@ -129,15 +129,15 @@ bool WriteFdExactly(int fd, const void* buf, size_t len) { 
    return true;

}



bool WriteFdExactly(int fd, const char* str) {

bool WriteFdExactly(borrowed_fd fd, const char* str) {

    return WriteFdExactly(fd, str, strlen(str));

}



bool WriteFdExactly(int fd, const std::string& str) {

bool WriteFdExactly(borrowed_fd fd, const std::string& str) {

    return WriteFdExactly(fd, str.c_str(), str.size());

}



bool WriteFdFmt(int fd, const char* fmt, ...) {

bool WriteFdFmt(borrowed_fd fd, const char* fmt, ...) {

    std::string str;



    va_list ap;
@@ -148,7 +148,7 @@ bool WriteFdFmt(int fd, const char* fmt, ...) { 
    return WriteFdExactly(fd, str);

}



bool ReadOrderlyShutdown(int fd) {

bool ReadOrderlyShutdown(borrowed_fd fd) {

    char buf[16];



    // Only call this function if you're sure that the peer does
@@ -178,7 +178,7 @@ bool ReadOrderlyShutdown(int fd) { 
        // data. We don't repeatedly call adb_read() until we get zero because

        // we don't know how long that would take, but we do know that the

        // caller wants to close the socket soon.

        VLOG(RWX) << "ReadOrderlyShutdown(" << fd << ") unexpectedly read "

        VLOG(RWX) << "ReadOrderlyShutdown(" << fd.get() << ") unexpectedly read "

                  << dump_hex(buf, result);

        // Shutdown the socket to prevent the caller from reading or writing to

        // it which doesn't make sense if we just read and discarded some data.

adb/adb_io.h

+10 −10
Original line number Diff line number Diff line
@@ -25,16 +25,16 @@ 
#include "adb_unique_fd.h"



// Sends the protocol "OKAY" message.

bool SendOkay(int fd);

bool SendOkay(borrowed_fd fd);



// Sends the protocol "FAIL" message, with the given failure reason.

bool SendFail(int fd, std::string_view reason);

bool SendFail(borrowed_fd fd, std::string_view reason);



// Writes a protocol-format string; a four hex digit length followed by the string data.

bool SendProtocolString(int fd, std::string_view s);

bool SendProtocolString(borrowed_fd fd, std::string_view s);



// Reads a protocol-format string; a four hex digit length followed by the string data.

bool ReadProtocolString(int fd, std::string* s, std::string* error);

bool ReadProtocolString(borrowed_fd fd, std::string* s, std::string* error);



// Reads exactly len bytes from fd into buf.

//
@@ -42,7 +42,7 @@ bool ReadProtocolString(int fd, std::string* s, std::string* error); 
// were read. If EOF was found, errno will be set to 0.

//

// If this function fails, the contents of buf are undefined.

bool ReadFdExactly(int fd, void* buf, size_t len);

bool ReadFdExactly(borrowed_fd fd, void* buf, size_t len);



// Given a client socket, wait for orderly/graceful shutdown. Call this:

//
@@ -60,19 +60,19 @@ bool ReadFdExactly(int fd, void* buf, size_t len); 
// connect()s from the client to fail with WSAEADDRINUSE on Windows.

// Returns true if it is sure that orderly/graceful shutdown has occurred with

// no additional data read from the server.

bool ReadOrderlyShutdown(int fd);

bool ReadOrderlyShutdown(borrowed_fd fd);



// Writes exactly len bytes from buf to fd.

//

// Returns false if there is an error or if the fd was closed before the write

// completed. If the other end of the fd (such as in a socket, pipe, or fifo),

// is closed, errno will be set to 0.

bool WriteFdExactly(int fd, const void* buf, size_t len);

bool WriteFdExactly(borrowed_fd fd, const void* buf, size_t len);



// Same as above, but for strings.

bool WriteFdExactly(int fd, const char* s);

bool WriteFdExactly(int fd, const std::string& s);

bool WriteFdExactly(borrowed_fd fd, const char* s);

bool WriteFdExactly(borrowed_fd fd, const std::string& s);



// Same as above, but formats the string to send.

bool WriteFdFmt(int fd, const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3)));

bool WriteFdFmt(borrowed_fd fd, const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3)));

#endif /* ADB_IO_H */

adb/adb_unique_fd.h

+2 −0
Original line number Diff line number Diff line
@@ -32,6 +32,8 @@ using unique_fd = android::base::unique_fd_impl<AdbCloser>; 
using unique_fd = android::base::unique_fd;

#endif



using android::base::borrowed_fd;



template <typename T>

int adb_close(const android::base::unique_fd_impl<T>&)

        __attribute__((__unavailable__("adb_close called on unique_fd")));

adb/adb_utils.cpp

+5 −5
Original line number Diff line number Diff line
@@ -234,15 +234,15 @@ std::string perror_str(const char* msg) { 


#if !defined(_WIN32)

// Windows version provided in sysdeps_win32.cpp

bool set_file_block_mode(int fd, bool block) {

    int flags = fcntl(fd, F_GETFL, 0);

bool set_file_block_mode(borrowed_fd fd, bool block) {

    int flags = fcntl(fd.get(), F_GETFL, 0);

    if (flags == -1) {

        PLOG(ERROR) << "failed to fcntl(F_GETFL) for fd " << fd;

        PLOG(ERROR) << "failed to fcntl(F_GETFL) for fd " << fd.get();

        return false;

    }

    flags = block ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK);

    if (fcntl(fd, F_SETFL, flags) != 0) {

        PLOG(ERROR) << "failed to fcntl(F_SETFL) for fd " << fd << ", flags " << flags;

    if (fcntl(fd.get(), F_SETFL, flags) != 0) {

        PLOG(ERROR) << "failed to fcntl(F_SETFL) for fd " << fd.get() << ", flags " << flags;

        return false;

    }

    return true;