blob: fbb1112fae76cfc87af90ec9244baff80ff395c9 [file] [log] [blame]
* 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
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
/* Helper to perform abortable blocking operations on a socket:
* asocket_connect()
* asocket_accept()
* asocket_read()
* asocket_write()
* These calls are similar to the regular syscalls, but can be aborted with:
* asocket_abort()
* Calling close() on a regular POSIX socket does not abort blocked syscalls on
* that socket in other threads.
* After calling asocket_abort() the socket cannot be reused.
* Call asocket_destory() *after* all threads have finished with the socket to
* finish closing the socket and free the asocket structure.
* The helper is implemented by setting the socket non-blocking to initiate
* syscalls connect(), accept(), read(), write(), then using a blocking poll()
* on both the primary socket and a local pipe. This makes the poll() abortable
* by writing a byte to the local pipe in asocket_abort().
* asocket_create() sets the fd to non-blocking mode. It must not be changed to
* blocking mode.
* Using asocket will triple the number of file descriptors required per
* socket, due to the local pipe. It may be possible to use a global pipe per
* process rather than per socket, but we have not been able to come up with a
* race-free implementation yet.
* All functions except asocket_init() and asocket_destroy() are thread safe.
#include <stdlib.h>
#include <sys/socket.h>
#ifdef __cplusplus
extern "C" {
struct asocket {
int fd; /* primary socket fd */
int abort_fd[2]; /* pipe used to abort */
/* Create an asocket from fd.
* Sets the socket to non-blocking mode.
* Returns NULL on error with errno set.
struct asocket *asocket_init(int fd);
/* Blocking socket I/O with timeout.
* Calling asocket_abort() from another thread will cause each of these
* functions to immediately return with value -1 and errno ECANCELED.
* timeout is in ms, use -1 to indicate no timeout. On timeout -1 is returned
* with errno ETIMEDOUT.
* EINTR is handled in-call.
* Other semantics are identical to the regular syscalls.
int asocket_connect(struct asocket *s, const struct sockaddr *addr,
socklen_t addrlen, int timeout);
int asocket_accept(struct asocket *s, struct sockaddr *addr,
socklen_t *addrlen, int timeout);
int asocket_read(struct asocket *s, void *buf, size_t count, int timeout);
int asocket_write(struct asocket *s, const void *buf, size_t count,
int timeout);
/* Abort above calls and shutdown socket.
* Further I/O operations on this socket will immediately fail after this call.
* asocket_destroy() should be used to release resources once all threads
* have returned from blocking calls on the socket.
void asocket_abort(struct asocket *s);
/* Close socket and free asocket structure.
* Must not be called until all calls on this structure have completed.
void asocket_destroy(struct asocket *s);
#ifdef __cplusplus