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

Commit f7d64fd8 authored by bohu's avatar bohu
Browse files

DO NOT MERGE ANYWHERE Qemu: make the qemu_pipe_open compatible with old apis 

Commit c7b098ce has changed
the qemu_pipe_open interface to require the "pipe:" prefix in
the service name.

However in APIs 24 and before, the "pipe:" prefix is not required
This causes quite some confusion and bugs since it is very common
to forget the difference when working across differnet APIs.

This CL is meant to make qemu_pipe_open work in both cases by
doing the following:
1. try the service name as is;
2. if it fails, add 'pipe:' prefix and try the service name again.

Change-Id: If9782396c03780fad1aadeb8374eb308517dc963
parent f099dce4

qemu_pipe/include/qemu_pipe.h

+4 −2
Original line number Diff line number Diff line
@@ -28,8 +28,10 @@ extern "C" { 
// This file descriptor can be used as a standard pipe/socket descriptor.

//

// 'pipeName' is the name of the emulator service you want to connect to,

// and must begin with 'pipe:' (e.g. 'pipe:camera' or 'pipe:opengles').

//

// and should begin with 'pipe:' (e.g. 'pipe:camera' or 'pipe:opengles').

// For backward compatibility, the 'pipe:' prefix can be omitted, and in

// that case, qemu_pipe_open will add it for you.



// On success, return a valid file descriptor, or -1/errno on failure. E.g.:

//

// EINVAL  -> unknown/unsupported pipeName

qemu_pipe/qemu_pipe.cpp

+16 −35
Original line number Diff line number Diff line
@@ -34,29 +34,9 @@ using android::base::WriteFully; 
#  define  QEMU_PIPE_DEBUG(...)   (void)0

#endif



// Try to open a new Qemu fast-pipe. This function returns a file descriptor

// that can be used to communicate with a named service managed by the

// emulator.

//

// This file descriptor can be used as a standard pipe/socket descriptor.

//

// 'pipeName' is the name of the emulator service you want to connect to,

// and must begin with 'pipe:' (e.g. 'pipe:camera' or 'pipe:opengles').

//

// On success, return a valid file descriptor, or -1/errno on failure. E.g.:

//

// EINVAL  -> unknown/unsupported pipeName

// ENOSYS  -> fast pipes not available in this system.

//

// ENOSYS should never happen, except if you're trying to run within a

// misconfigured emulator.

//

// You should be able to open several pipes to the same pipe service,

// except for a few special cases (e.g. GSM modem), where EBUSY will be

// returned if more than one client tries to connect to it.

int qemu_pipe_open(const char* pipeName) {

    // Sanity check.

    if (!pipeName || memcmp(pipeName, "pipe:", 5) != 0) {

    if (!pipeName) {

        errno = EINVAL;

        return -1;

    }
@@ -70,18 +50,24 @@ int qemu_pipe_open(const char* pipeName) { 


    // Write the pipe name, *including* the trailing zero which is necessary.

    size_t pipeNameLen = strlen(pipeName);

    if (!WriteFully(fd, pipeName, pipeNameLen + 1U)) {

        QEMU_PIPE_DEBUG("%s: Could not connect to %s pipe service: %s",

    if (WriteFully(fd, pipeName, pipeNameLen + 1U)) {

        return fd;

    }



    // now, add 'pipe:' prefix and try again

    // Note: host side will wait for the trailing '\0' to start

    // service lookup.

    const char pipe_prefix[] = "pipe:";

    if (WriteFully(fd, pipe_prefix, strlen(pipe_prefix)) &&

            WriteFully(fd, pipeName, pipeNameLen + 1U)) {

        return fd;

    }

    QEMU_PIPE_DEBUG("%s: Could not write to %s pipe service: %s",

            __FUNCTION__, pipeName, strerror(errno));

    close(fd);

    return -1;

}

    return fd;

}



// Send a framed message |buff| of |len| bytes through the |fd| descriptor.

// This really adds a 4-hexchar prefix describing the payload size.

// Returns 0 on success, and -1 on error.

int qemu_pipe_frame_send(int fd, const void* buff, size_t len) {

    char header[5];

    snprintf(header, sizeof(header), "%04zx", len);
@@ -96,11 +82,6 @@ int qemu_pipe_frame_send(int fd, const void* buff, size_t len) { 
    return 0;

}



// Read a frame message from |fd|, and store it into |buff| of |len| bytes.

// If the framed message is larger than |len|, then this returns -1 and the

// content is lost. Otherwise, this returns the size of the message. NOTE:

// empty messages are possible in a framed wire protocol and do not mean

// end-of-stream.

int qemu_pipe_frame_recv(int fd, void* buff, size_t len) {

    char header[5];

    if (!ReadFully(fd, header, 4)) {