src/type3_AndroidCloud/anbox-master/android/opengl/system/OpenglSystemCommon/QemuPipeStream.cpp

   1 /*
   2 * Copyright (C) 2011 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 #include "QemuPipeStream.h"
  17 #include <hardware/qemu_pipe.h>
  18 #include <errno.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23
  24 QemuPipeStream::QemuPipeStream(size_t bufSize) :
  25     IOStream(bufSize),
  26     m_sock(-1),
  27     m_bufsize(bufSize),
  28     m_buf(NULL)
  29 {
  30 }
  31
  32 QemuPipeStream::QemuPipeStream(int sock, size_t bufSize) :
  33     IOStream(bufSize),
  34     m_sock(sock),
  35     m_bufsize(bufSize),
  36     m_buf(NULL)
  37 {
  38 }
  39
  40 QemuPipeStream::~QemuPipeStream()
  41 {
  42     if (m_sock >= 0) {
  43         flush();
  44         ::close(m_sock);
  45     }
  46     if (m_buf != NULL) {
  47         free(m_buf);
  48     }
  49 }
  50
  51
  52 int QemuPipeStream::connect(void)
  53 {
  54     m_sock = qemu_pipe_open("opengles");
  55     if (!valid()) return -1;
  56     return 0;
  57 }
  58
  59 void *QemuPipeStream::allocBuffer(size_t minSize)
  60 {
  61     size_t allocSize = (m_bufsize < minSize ? minSize : m_bufsize);
  62     if (!m_buf) {
  63         m_buf = (unsigned char *)malloc(allocSize);
  64     }
  65     else if (m_bufsize < allocSize) {
  66         unsigned char *p = (unsigned char *)realloc(m_buf, allocSize);
  67         if (p != NULL) {
  68             m_buf = p;
  69             m_bufsize = allocSize;
  70         } else {
  71             ERR("realloc (%d) failed\n", allocSize);
  72             free(m_buf);
  73             m_buf = NULL;
  74             m_bufsize = 0;
  75         }
  76     }
  77
  78     return m_buf;
  79 };
  80
  81 int QemuPipeStream::commitBuffer(size_t size)
  82 {
  83     return writeFully(m_buf, size);
  84 }
  85
  86 int QemuPipeStream::writeFully(const void *buf, size_t len)
  87 {
  88     //DBG(">> QemuPipeStream::writeFully %d\n", len);
  89     if (!valid()) return -1;
  90     if (!buf) {
  91        if (len>0) {
  92             // If len is non-zero, buf must not be NULL. Otherwise the pipe would be
  93             // in a corrupted state, which is lethal for the emulator.
  94            ERR("QemuPipeStream::writeFully failed, buf=NULL, len %d,"
  95                    " lethal error, exiting", len);
  96            abort();
  97        }
  98        return 0;
  99     }
 100
 101     size_t res = len;
 102     int retval = 0;
 103
 104     while (res > 0) {
 105         ssize_t stat = ::write(m_sock, (const char *)(buf) + (len - res), res);
 106         if (stat > 0) {
 107             res -= stat;
 108             continue;
 109         }
 110         if (stat == 0) { /* EOF */
 111             ERR("QemuPipeStream::writeFully failed: premature EOF\n");
 112             retval = -1;
 113             break;
 114         }
 115         if (errno == EINTR) {
 116             continue;
 117         }
 118         retval =  stat;
 119         ERR("QemuPipeStream::writeFully failed: %s, lethal error, exiting.\n",
 120                 strerror(errno));
 121         abort();
 122     }
 123     //DBG("<< QemuPipeStream::writeFully %d\n", len );
 124     return retval;
 125 }
 126
 127 const unsigned char *QemuPipeStream::readFully(void *buf, size_t len)
 128 {
 129     //DBG(">> QemuPipeStream::readFully %d\n", len);
 130     if (!valid()) return NULL;
 131     if (!buf) {
 132         if (len > 0) {
 133             // If len is non-zero, buf must not be NULL. Otherwise the pipe would be
 134             // in a corrupted state, which is lethal for the emulator.
 135             ERR("QemuPipeStream::readFully failed, buf=NULL, len %zu, lethal"
 136                     " error, exiting.", len);
 137             abort();
 138         }
 139         return NULL;  // do not allow NULL buf in that implementation
 140     }
 141     size_t res = len;
 142     while (res > 0) {
 143         ssize_t stat = ::read(m_sock, (char *)(buf) + len - res, res);
 144         if (stat == 0) {
 145             // client shutdown;
 146             return NULL;
 147         } else if (stat < 0) {
 148             if (errno == EINTR) {
 149                 continue;
 150             } else {
 151                 ERR("QemuPipeStream::readFully failed (buf %p, len %zu"
 152                     ", res %zu): %s, lethal error, exiting.", buf, len, res,
 153                     strerror(errno));
 154                 abort();
 155             }
 156         } else {
 157             res -= stat;
 158         }
 159     }
 160     //DBG("<< QemuPipeStream::readFully %d\n", len);
 161     return (const unsigned char *)buf;
 162 }
 163
 164 const unsigned char *QemuPipeStream::read( void *buf, size_t *inout_len)
 165 {
 166     //DBG(">> QemuPipeStream::read %d\n", *inout_len);
 167     if (!valid()) return NULL;
 168     if (!buf) {
 169       ERR("QemuPipeStream::read failed, buf=NULL");
 170       return NULL;  // do not allow NULL buf in that implementation
 171     }
 172
 173     int n = recv(buf, *inout_len);
 174
 175     if (n > 0) {
 176         *inout_len = n;
 177         return (const unsigned char *)buf;
 178     }
 179
 180     //DBG("<< QemuPipeStream::read %d\n", *inout_len);
 181     return NULL;
 182 }
 183
 184 int QemuPipeStream::recv(void *buf, size_t len)
 185 {
 186     if (!valid()) return int(ERR_INVALID_SOCKET);
 187     char* p = (char *)buf;
 188     int ret = 0;
 189     while(len > 0) {
 190         int res = ::read(m_sock, p, len);
 191         if (res > 0) {
 192             p += res;
 193             ret += res;
 194             len -= res;
 195             continue;
 196         }
 197         if (res == 0) { /* EOF */
 198              break;
 199         }
 200         if (errno == EINTR)
 201             continue;
 202
 203         /* A real error */
 204         if (ret == 0)
 205             ret = -1;
 206         break;
 207     }
 208     return ret;
 209 }