__attribute_nonnull__
int
main (int argc, char *argv[])
{
int nfd;
struct sockaddr_storage addr;
struct addrinfo ai = { .ai_flags = 0,
.ai_addr = (struct sockaddr *)&addr,
.ai_addrlen = sizeof(addr) };
struct bsock_addrinfo_strs aistr;
if (6 != argc) {
fprintf(stderr, "invalid args\n");
return EXIT_FAILURE;
}
aistr.family = argv[1];
aistr.socktype = argv[2];
aistr.protocol = argv[3];
aistr.service = argv[4];
aistr.addr = argv[5];
#if 1
if ( bsock_addrinfo_from_strs(&ai, &aistr)
&&-1 != (nfd = socket(ai.ai_family, ai.ai_socktype, ai.ai_protocol))
&& 0 == bsock_bind_addrinfo(nfd, &ai))
return EXIT_SUCCESS;
#else /* load test (serial requests) */
/* Use 'bsock -d' (no -F unless redirecting output to file) */
/* Timing inaccurate and much slower if output to terminal (bsock -d -F) */
int i;
struct timeval tva, tvb;
bsock_addrinfo_from_strs(&ai, &aistr);
gettimeofday(&tva, NULL);
for (i=0; i<10000; ++i) {
if (-1 == (nfd = socket(ai.ai_family, ai.ai_socktype, ai.ai_protocol))
|| 0 != bsock_bind_addrinfo(nfd, &ai))
break;
close(nfd);
}
gettimeofday(&tvb, NULL);
time_t secs = tvb.tv_sec - tva.tv_sec;
long usecs = tvb.tv_usec - tva.tv_usec;
if (usecs < 0) {
usecs += 1000000;
--secs;
}
fprintf(stderr, "count: %d in %u usecs\n", i,
(unsigned)secs*1000000u + (unsigned)usecs);
if (i == 10000)
return EXIT_SUCCESS;
#endif
perror("bsock");
return EXIT_FAILURE;
}
/* nointr_close() - make effort to avoid leaking open file descriptors */
static int
nointr_close (const int fd)
{
int r;
do {
r = close(fd);
}
while (r != 0 && errno == EINTR);
return r;
}
static int __attribute__((noinline)) /*(most client time is spent waiting)*/
retry_poll_fd (const int fd, const short events, const int timeout)
{
struct pollfd pfd = { .fd = fd, .events = events, .revents = 0 };
int n; /*EINTR results in retrying poll with same timeout again and again*/
do {
n = poll(&pfd, 1, timeout);
}
while (-1 == n && errno == EINTR);
if (0 == n) errno = ETIME; /* specific for bsock; not generic */
return n;
}
static int __attribute__((nonnull))
bsock_bind_send_addr_and_recv (const int fd,
const struct addrinfo * const restrict ai,
const int sfd)
{
/* bsock_unix_recv_fds() fills errnum to indicate remote success/failure
* (no poll before sending addrinfo since this is first write to socket)
* (dup2 rfd to fd if rfd != -1; indicates persistent reserved addr,port) */
int rfd = -1;
unsigned int nrfd = 1;
int errnum = 0;
struct iovec iov = { .iov_base = &errnum, .iov_len = sizeof(errnum) };
if (bsock_addrinfo_send(sfd, ai, fd)
&& 1 == retry_poll_fd(sfd, POLLIN, BSOCK_POLL_TIMEOUT)
&& -1 != bsock_unix_recv_fds(sfd, &rfd, &nrfd, &iov, 1)) {
if (-1 != rfd) {
/* assert(rfd != fd); *//*(should not happen)*/
if (0 == errnum) {
do {
errnum = dup2(rfd, fd);
} while (errnum == -1 && (errno == EINTR || errno == EBUSY));
errnum = (errnum == fd) ? 0 : errno;
}
nointr_close(rfd);
}
}
else {
errnum = errno;
/* server might have responded and closed socket before client sendmsg*/
if (EPIPE == errnum && -1 == bsock_unix_recv_fds(sfd,NULL,NULL,&iov,1))
errnum = EPIPE;
}
return errnum;
}
static bool __attribute__((nonnull))
bsock_bind_viafork (const int fd, const struct addrinfo * const restrict ai)
{
/* (ai->ai_next is ignored) */
int sv[2];
int errnum;
pid_t pid;
struct stat st;
if (0 != stat(BSOCK_EXE, &st))
return false;
if (!(st.st_mode & S_ISUID))
return (errno = EPERM, false);
if (0 != socketpair(AF_UNIX, SOCK_STREAM, 0, sv))
return false;
pid = fork(); /*(bsock_bind_resvaddr() retries on EAGAIN)*/
if (0 == pid) { /* child; no retry if child signalled, errno==EINTR */
static char bsock_exe[] = BSOCK_EXE;
static char *args[] = { bsock_exe, NULL };
if ( dup2(sv[0], STDIN_FILENO) != STDIN_FILENO
|| (sv[0] != STDIN_FILENO && 0 != close(sv[0]))
|| (sv[1] != STDIN_FILENO && 0 != close(sv[1])))
_exit(errno);
fcntl(STDIN_FILENO, F_SETFD, 0);/* unset all fdflags, incl FD_CLOEXEC */
execve(args[0], args, environ);
_exit(errno); /*(not reached unless execve() failed)*/
}
else if (-1 != pid) { /* parent */
nointr_close(sv[0]);
errnum = bsock_bind_send_addr_and_recv(fd, ai, sv[1]);
while (pid != waitpid(pid,NULL,0) && errno == EINTR) ;
/* reap child process but ignore exit status; program might be ignoring
* SIGCHLD or might have custom SIGCHLD handler, either of which would
* prevent waitpid() above from reliably obtaining child status */
}
else { /* fork() error */
errnum = errno;
nointr_close(sv[0]);
}
nointr_close(sv[1]);
errno = errnum;
return (0 == errnum);
}
static bool __attribute__((nonnull))
bsock_bind_viasock (const int fd, const struct addrinfo * const restrict ai)
{
int errnum;
int sfd;
do {
sfd = bsock_unix_socket_connect(BSOCK_SOCKET);
if (-1 == sfd)
return false;
errnum = bsock_bind_send_addr_and_recv(fd, ai, sfd);
nointr_close(sfd);
if (errnum == EAGAIN) {
/*(sched_yield() results in non-productive spin on my uniprocessor
* during performance tests sending lots of requests by same uid,
* since bsock defers if uid already has request in progress)*/
static const struct timespec ts = { 0, 10L };
nanosleep(&ts, NULL);
}
} while (errnum == EAGAIN || errnum == ETIME);
errno = errnum;
return (0 == errnum);
}
int __attribute__((nonnull))
bsock_bind_addrinfo (const int fd, const struct addrinfo * const restrict ai)
{
/* (return value 0 for success, -1 upon error; match return value of bind())
* (ai->ai_next is ignored) */
if (bsock_bind_viasock(fd, ai) || bsock_bind_viafork(fd, ai))
return 0;
switch (errno) {
default:
errno = EACCES; /*FALLTHRU*/
case EACCES:
case EADDRINUSE:
case EBADF:
case EINVAL:
case ENOTSOCK:
return -1;
}
}
static int (*bind_rtld_next)(int, const struct sockaddr *, socklen_t);
static int __attribute__((nonnull))
bind_rtld_findnext (int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
bind_rtld_next = (int(*)(int,const struct sockaddr *,socklen_t))(uintptr_t)
dlsym((void *)-1L, "bind"); /* RTLD_NEXT=(void *)-1L is glibc extension */
return (NULL != bind_rtld_next)
? bind_rtld_next(sockfd, addr, addrlen)
: (bind_rtld_next = bind_rtld_findnext, errno = ENOSYS, -1);
}
static int (*bind_rtld_next)(int, const struct sockaddr *, socklen_t) =
bind_rtld_findnext;
int __attribute__((nonnull))
bsock_bind_intercept (int sockfd, const struct sockaddr *addr,
const socklen_t addrlen)
{
struct addrinfo ai = {
.ai_flags = 0,
.ai_family = addr->sa_family,
.ai_socktype = 0,
.ai_protocol = 0,
.ai_addrlen = addrlen,
.ai_addr = (struct sockaddr *)(uintptr_t)addr,
.ai_canonname= NULL,
.ai_next = NULL
};
socklen_t optlen;
/* bsock supports only AF_INET, AF_INET6, AF_UNIX;
* simply bind if address family is otherwise */
if (ai.ai_family == AF_INET || ai.ai_family == AF_INET6) {
/* simply bind if port < IPPORT_RESERVED; no root privileges needed */
const int port = (ai.ai_family == AF_INET)
? ntohs(((struct sockaddr_in *)ai.ai_addr)->sin_port)
: ntohs(((struct sockaddr_in6 *)ai.ai_addr)->sin6_port);
if (port >= IPPORT_RESERVED
&& 0 == bind_rtld_next(sockfd, ai.ai_addr, ai.ai_addrlen))
return 0;
/*(fall through if bind() fails in case persistent reserved addr)*/
#if 0 /* getnameinfo() is overkill for simple port check */
char host[INET6_ADDRSTRLEN];
char port[6];
switch (getnameinfo(ai.ai_addr, ai.ai_addrlen, host, sizeof(host),
port, sizeof(port), NI_NUMERICHOST|NI_NUMERICSERV)) {
case 0:
if (atoi(port) < IPPORT_RESERVED) break;
else return bind_rtld_next(sockfd, ai.ai_addr, ai.ai_addrlen);
case default:
errno = EINVAL;
return -1;
case EAI_MEMORY:
errno = ENOMEM;
return -1;
case EAI_SYSTEM:
return -1;
}
#endif
}
else if (ai.ai_family != AF_UNIX)
return bind_rtld_next(sockfd, ai.ai_addr, ai.ai_addrlen);
if (0 == geteuid() && 0 == bind_rtld_next(sockfd,ai.ai_addr,ai.ai_addrlen))
return 0;
/*(fall through if bind() fails in case persistent reserved addr)*/
optlen = sizeof(ai.ai_socktype);
if (-1 == getsockopt(sockfd,SOL_SOCKET,SO_TYPE,&ai.ai_socktype,&optlen))
return -1;
#ifdef SO_PROTOCOL
optlen = sizeof(ai.ai_protocol);
if (-1 == getsockopt(sockfd,SOL_SOCKET,SO_PROTOCOL,&ai.ai_socktype,&optlen))
return -1;
#else
/* else pass ai_protocol == 0, which will typically work as expected (tcp)
* since bsock calls getaddrinfo() and uses first entry returned */
#endif
return bsock_bind_addrinfo(sockfd, &ai);
}
