M7350/system/core/libcutils/abort_socket.c

294 lines
7.1 KiB
C
Raw Normal View History

2024-09-09 08:52:07 +00:00
/*
* Copyright 2009, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/poll.h>
#include "cutils/abort_socket.h"
struct asocket *asocket_init(int fd) {
int abort_fd[2];
int flags;
struct asocket *s;
/* set primary socket to non-blocking */
flags = fcntl(fd, F_GETFL);
if (flags == -1)
return NULL;
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK))
return NULL;
/* create pipe with non-blocking write, so that asocket_close() cannot
block */
if (pipe(abort_fd))
return NULL;
flags = fcntl(abort_fd[1], F_GETFL);
if (flags == -1)
return NULL;
if (fcntl(abort_fd[1], F_SETFL, flags | O_NONBLOCK))
return NULL;
s = malloc(sizeof(struct asocket));
if (!s)
return NULL;
s->fd = fd;
s->abort_fd[0] = abort_fd[0];
s->abort_fd[1] = abort_fd[1];
return s;
}
int asocket_connect(struct asocket *s, const struct sockaddr *addr,
socklen_t addrlen, int timeout) {
int ret;
do {
ret = connect(s->fd, addr, addrlen);
} while (ret && errno == EINTR);
if (ret && errno == EINPROGRESS) {
/* ready to poll() */
socklen_t retlen;
struct pollfd pfd[2];
pfd[0].fd = s->fd;
pfd[0].events = POLLOUT;
pfd[0].revents = 0;
pfd[1].fd = s->abort_fd[0];
pfd[1].events = POLLIN;
pfd[1].revents = 0;
do {
ret = poll(pfd, 2, timeout);
} while (ret < 0 && errno == EINTR);
if (ret < 0)
return -1;
else if (ret == 0) {
/* timeout */
errno = ETIMEDOUT;
return -1;
}
if (pfd[1].revents) {
/* abort due to asocket_abort() */
errno = ECANCELED;
return -1;
}
if (pfd[0].revents) {
if (pfd[0].revents & POLLOUT) {
/* connect call complete, read return code */
retlen = sizeof(ret);
if (getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &ret, &retlen))
return -1;
/* got connect() return code */
if (ret) {
errno = ret;
}
} else {
/* some error event on this fd */
errno = ECONNABORTED;
return -1;
}
}
}
return ret;
}
int asocket_accept(struct asocket *s, struct sockaddr *addr,
socklen_t *addrlen, int timeout) {
int ret;
struct pollfd pfd[2];
pfd[0].fd = s->fd;
pfd[0].events = POLLIN;
pfd[0].revents = 0;
pfd[1].fd = s->abort_fd[0];
pfd[1].events = POLLIN;
pfd[1].revents = 0;
do {
ret = poll(pfd, 2, timeout);
} while (ret < 0 && errno == EINTR);
if (ret < 0)
return -1;
else if (ret == 0) {
/* timeout */
errno = ETIMEDOUT;
return -1;
}
if (pfd[1].revents) {
/* abort due to asocket_abort() */
errno = ECANCELED;
return -1;
}
if (pfd[0].revents) {
if (pfd[0].revents & POLLIN) {
/* ready to accept() without blocking */
do {
ret = accept(s->fd, addr, addrlen);
} while (ret < 0 && errno == EINTR);
} else {
/* some error event on this fd */
errno = ECONNABORTED;
return -1;
}
}
return ret;
}
int asocket_read(struct asocket *s, void *buf, size_t count, int timeout) {
int ret;
struct pollfd pfd[2];
pfd[0].fd = s->fd;
pfd[0].events = POLLIN;
pfd[0].revents = 0;
pfd[1].fd = s->abort_fd[0];
pfd[1].events = POLLIN;
pfd[1].revents = 0;
do {
ret = poll(pfd, 2, timeout);
} while (ret < 0 && errno == EINTR);
if (ret < 0)
return -1;
else if (ret == 0) {
/* timeout */
errno = ETIMEDOUT;
return -1;
}
if (pfd[1].revents) {
/* abort due to asocket_abort() */
errno = ECANCELED;
return -1;
}
if (pfd[0].revents) {
if (pfd[0].revents & POLLIN) {
/* ready to read() without blocking */
do {
ret = read(s->fd, buf, count);
} while (ret < 0 && errno == EINTR);
} else {
/* some error event on this fd */
errno = ECONNABORTED;
return -1;
}
}
return ret;
}
int asocket_write(struct asocket *s, const void *buf, size_t count,
int timeout) {
int ret;
struct pollfd pfd[2];
pfd[0].fd = s->fd;
pfd[0].events = POLLOUT;
pfd[0].revents = 0;
pfd[1].fd = s->abort_fd[0];
pfd[1].events = POLLIN;
pfd[1].revents = 0;
do {
ret = poll(pfd, 2, timeout);
} while (ret < 0 && errno == EINTR);
if (ret < 0)
return -1;
else if (ret == 0) {
/* timeout */
errno = ETIMEDOUT;
return -1;
}
if (pfd[1].revents) {
/* abort due to asocket_abort() */
errno = ECANCELED;
return -1;
}
if (pfd[0].revents) {
if (pfd[0].revents & POLLOUT) {
/* ready to write() without blocking */
do {
ret = write(s->fd, buf, count);
} while (ret < 0 && errno == EINTR);
} else {
/* some error event on this fd */
errno = ECONNABORTED;
return -1;
}
}
return ret;
}
void asocket_abort(struct asocket *s) {
int ret;
char buf = 0;
/* Prevent further use of fd, without yet releasing the fd */
shutdown(s->fd, SHUT_RDWR);
/* wake up calls blocked at poll() */
do {
ret = write(s->abort_fd[1], &buf, 1);
} while (ret < 0 && errno == EINTR);
}
void asocket_destroy(struct asocket *s) {
struct asocket s_copy = *s;
/* Clients should *not* be using these fd's after calling
asocket_destroy(), but in case they do, set to -1 so they cannot use a
stale fd */
s->fd = -1;
s->abort_fd[0] = -1;
s->abort_fd[1] = -1;
/* Call asocket_abort() in case there are still threads blocked on this
socket. Clients should not rely on this behavior - it is racy because we
are about to close() these sockets - clients should instead make sure
all threads are done with the socket before calling asocket_destory().
*/
asocket_abort(&s_copy);
/* enough safety checks, close and release memory */
close(s_copy.abort_fd[1]);
close(s_copy.abort_fd[0]);
close(s_copy.fd);
free(s);
}