Revision 00aa0040
| b/block/sheepdog.c | ||
|---|---|---|
| 496 | 496 |
} |
| 497 | 497 |
buf = qemu_malloc(size); |
| 498 | 498 |
|
| 499 |
ret = recv(s, buf, size, flags); |
|
| 499 |
ret = qemu_recv(s, buf, size, flags);
|
|
| 500 | 500 |
if (ret < 0) {
|
| 501 | 501 |
goto out; |
| 502 | 502 |
} |
| b/gdbstub.c | ||
|---|---|---|
| 319 | 319 |
int ret; |
| 320 | 320 |
|
| 321 | 321 |
for(;;) {
|
| 322 |
ret = recv(s->fd, &ch, 1, 0); |
|
| 322 |
ret = qemu_recv(s->fd, &ch, 1, 0);
|
|
| 323 | 323 |
if (ret < 0) {
|
| 324 | 324 |
if (errno == ECONNRESET) |
| 325 | 325 |
s->fd = -1; |
| b/linux-user/syscall.c | ||
|---|---|---|
| 2004 | 2004 |
ret = get_errno(recvfrom(fd, host_msg, len, flags, addr, &addrlen)); |
| 2005 | 2005 |
} else {
|
| 2006 | 2006 |
addr = NULL; /* To keep compiler quiet. */ |
| 2007 |
ret = get_errno(recv(fd, host_msg, len, flags)); |
|
| 2007 |
ret = get_errno(qemu_recv(fd, host_msg, len, flags));
|
|
| 2008 | 2008 |
} |
| 2009 | 2009 |
if (!is_error(ret)) {
|
| 2010 | 2010 |
if (target_addr) {
|
| b/nbd.c | ||
|---|---|---|
| 78 | 78 |
ssize_t len; |
| 79 | 79 |
|
| 80 | 80 |
if (do_read) {
|
| 81 |
len = recv(fd, buffer + offset, size - offset, 0); |
|
| 81 |
len = qemu_recv(fd, buffer + offset, size - offset, 0);
|
|
| 82 | 82 |
} else {
|
| 83 | 83 |
len = send(fd, buffer + offset, size - offset, 0); |
| 84 | 84 |
} |
| b/net/socket.c | ||
|---|---|---|
| 76 | 76 |
uint8_t buf1[4096]; |
| 77 | 77 |
const uint8_t *buf; |
| 78 | 78 |
|
| 79 |
size = recv(s->fd, (void *)buf1, sizeof(buf1), 0);
|
|
| 79 |
size = qemu_recv(s->fd, buf1, sizeof(buf1), 0);
|
|
| 80 | 80 |
if (size < 0) {
|
| 81 | 81 |
err = socket_error(); |
| 82 | 82 |
if (err != EWOULDBLOCK) |
| ... | ... | |
| 138 | 138 |
NetSocketState *s = opaque; |
| 139 | 139 |
int size; |
| 140 | 140 |
|
| 141 |
size = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
|
|
| 141 |
size = qemu_recv(s->fd, s->buf, sizeof(s->buf), 0);
|
|
| 142 | 142 |
if (size < 0) |
| 143 | 143 |
return; |
| 144 | 144 |
if (size == 0) {
|
| b/qemu-char.c | ||
|---|---|---|
| 1860 | 1860 |
|
| 1861 | 1861 |
if (s->max_size == 0) |
| 1862 | 1862 |
return; |
| 1863 |
s->bufcnt = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
|
|
| 1863 |
s->bufcnt = qemu_recv(s->fd, s->buf, sizeof(s->buf), 0);
|
|
| 1864 | 1864 |
s->bufptr = s->bufcnt; |
| 1865 | 1865 |
if (s->bufcnt <= 0) |
| 1866 | 1866 |
return; |
| ... | ... | |
| 2078 | 2078 |
static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len) |
| 2079 | 2079 |
{
|
| 2080 | 2080 |
TCPCharDriver *s = chr->opaque; |
| 2081 |
return recv(s->fd, buf, len, 0); |
|
| 2081 |
return qemu_recv(s->fd, buf, len, 0);
|
|
| 2082 | 2082 |
} |
| 2083 | 2083 |
#endif |
| 2084 | 2084 |
|
| b/qemu-common.h | ||
|---|---|---|
| 200 | 200 |
int qemu_pipe(int pipefd[2]); |
| 201 | 201 |
#endif |
| 202 | 202 |
|
| 203 |
#ifdef _WIN32 |
|
| 204 |
#define qemu_recv(sockfd, buf, len, flags) recv(sockfd, (void *)buf, len, flags) |
|
| 205 |
#else |
|
| 206 |
#define qemu_recv(sockfd, buf, len, flags) recv(sockfd, buf, len, flags) |
|
| 207 |
#endif |
|
| 208 |
|
|
| 203 | 209 |
/* Error handling. */ |
| 204 | 210 |
|
| 205 | 211 |
void QEMU_NORETURN hw_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2); |
| b/savevm.c | ||
|---|---|---|
| 194 | 194 |
ssize_t len; |
| 195 | 195 |
|
| 196 | 196 |
do {
|
| 197 |
len = recv(s->fd, (void *)buf, size, 0);
|
|
| 197 |
len = qemu_recv(s->fd, buf, size, 0);
|
|
| 198 | 198 |
} while (len == -1 && socket_error() == EINTR); |
| 199 | 199 |
|
| 200 | 200 |
if (len == -1) |
| b/slirp/ip_icmp.c | ||
|---|---|---|
| 415 | 415 |
icp = mtod(m, struct icmp *); |
| 416 | 416 |
|
| 417 | 417 |
id = icp->icmp_id; |
| 418 |
len = recv(so->s, icp, m->m_len, 0); |
|
| 418 |
len = qemu_recv(so->s, icp, m->m_len, 0);
|
|
| 419 | 419 |
icp->icmp_id = id; |
| 420 | 420 |
|
| 421 | 421 |
m->m_data -= hlen; |
| b/slirp/slirp.c | ||
|---|---|---|
| 522 | 522 |
*/ |
| 523 | 523 |
#ifdef PROBE_CONN |
| 524 | 524 |
if (so->so_state & SS_ISFCONNECTING) {
|
| 525 |
ret = recv(so->s, (char *)&ret, 0,0);
|
|
| 525 |
ret = qemu_recv(so->s, &ret, 0,0);
|
|
| 526 | 526 |
|
| 527 | 527 |
if (ret < 0) {
|
| 528 | 528 |
/* XXX */ |
| b/slirp/socket.c | ||
|---|---|---|
| 166 | 166 |
nn = readv(so->s, (struct iovec *)iov, n); |
| 167 | 167 |
DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn)); |
| 168 | 168 |
#else |
| 169 |
nn = recv(so->s, iov[0].iov_base, iov[0].iov_len,0); |
|
| 169 |
nn = qemu_recv(so->s, iov[0].iov_base, iov[0].iov_len,0);
|
|
| 170 | 170 |
#endif |
| 171 | 171 |
if (nn <= 0) {
|
| 172 | 172 |
if (nn < 0 && (errno == EINTR || errno == EAGAIN)) |
| ... | ... | |
| 191 | 191 |
*/ |
| 192 | 192 |
if (n == 2 && nn == iov[0].iov_len) {
|
| 193 | 193 |
int ret; |
| 194 |
ret = recv(so->s, iov[1].iov_base, iov[1].iov_len,0); |
|
| 194 |
ret = qemu_recv(so->s, iov[1].iov_base, iov[1].iov_len,0);
|
|
| 195 | 195 |
if (ret > 0) |
| 196 | 196 |
nn += ret; |
| 197 | 197 |
} |
| b/ui/vnc-tls.c | ||
|---|---|---|
| 89 | 89 |
int ret; |
| 90 | 90 |
|
| 91 | 91 |
retry: |
| 92 |
ret = recv(vs->csock, data, len, 0); |
|
| 92 |
ret = qemu_recv(vs->csock, data, len, 0);
|
|
| 93 | 93 |
if (ret < 0) {
|
| 94 | 94 |
if (errno == EINTR) |
| 95 | 95 |
goto retry; |
| b/ui/vnc.c | ||
|---|---|---|
| 1199 | 1199 |
} |
| 1200 | 1200 |
} else |
| 1201 | 1201 |
#endif /* CONFIG_VNC_TLS */ |
| 1202 |
ret = recv(vs->csock, (void *)data, datalen, 0);
|
|
| 1202 |
ret = qemu_recv(vs->csock, data, datalen, 0);
|
|
| 1203 | 1203 |
VNC_DEBUG("Read wire %p %zd -> %ld\n", data, datalen, ret);
|
| 1204 | 1204 |
return vnc_client_io_error(vs, ret, socket_error()); |
| 1205 | 1205 |
} |
Also available in: Unified diff