osi/src/socket.c

/******************************************************************************
 *
 *  Copyright (C) 2014 Google, Inc.
 *
 *  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.
 *
 ******************************************************************************/

#define LOG_TAG "bt_osi_socket"

#include <asm/ioctls.h>
#include <assert.h>
#include <errno.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <utils/Log.h>

#include "allocator.h"
#include "osi.h"
#include "reactor.h"
#include "socket.h"

struct socket_t {
  int fd;
  reactor_object_t *reactor_object;
  socket_cb read_ready;
  socket_cb write_ready;
  void *context;                     // Not owned, do not free.
};

static void internal_read_ready(void *context);
static void internal_write_ready(void *context);

socket_t *socket_new(void) {
  socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t));
  if (!ret) {
    ALOGE("%s unable to allocate memory for socket.", __func__);
    goto error;
  }

  ret->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (ret->fd == INVALID_FD) {
    ALOGE("%s unable to create socket: %s", __func__, strerror(errno));
    goto error;
  }

  int enable = 1;
  if (setsockopt(ret->fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)) == -1) {
    ALOGE("%s unable to set SO_REUSEADDR: %s", __func__, strerror(errno));
    goto error;
  }

  return ret;

error:;
  if (ret)
    close(ret->fd);
  osi_free(ret);
  return NULL;
}

socket_t *socket_new_from_fd(int fd) {
  assert(fd != INVALID_FD);

  socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t));
  if (!ret) {
    ALOGE("%s unable to allocate memory for socket.", __func__);
    return NULL;
  }

  ret->fd = fd;
  return ret;
}

void socket_free(socket_t *socket) {
  if (!socket)
    return;

  socket_unregister(socket);
  close(socket->fd);
  osi_free(socket);
}

bool socket_listen(const socket_t *socket, port_t port) {
  assert(socket != NULL);

  struct sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_addr.s_addr = 0;
  addr.sin_port = htons(port);
  if (bind(socket->fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
    ALOGE("%s unable to bind socket to port %u: %s", __func__, port, strerror(errno));
    return false;
  }

  if (listen(socket->fd, 10) == -1) {
    ALOGE("%s unable to listen on port %u: %s", __func__, port, strerror(errno));
    return false;
  }

  return true;
}

socket_t *socket_accept(const socket_t *socket) {
  assert(socket != NULL);

  int fd = accept(socket->fd, NULL, NULL);
  if (fd == INVALID_FD) {
    ALOGE("%s unable to accept socket: %s", __func__, strerror(errno));
    return NULL;
  }

  socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t));
  if (!ret) {
    close(fd);
    ALOGE("%s unable to allocate memory for socket.", __func__);
    return NULL;
  }

  ret->fd = fd;
  return ret;
}

ssize_t socket_read(const socket_t *socket, void *buf, size_t count) {
  assert(socket != NULL);
  assert(buf != NULL);

  return recv(socket->fd, buf, count, MSG_DONTWAIT);
}

ssize_t socket_write(const socket_t *socket, const void *buf, size_t count) {
  assert(socket != NULL);
  assert(buf != NULL);

  return send(socket->fd, buf, count, MSG_DONTWAIT);
}

ssize_t socket_write_and_transfer_fd(const socket_t *socket, const void *buf, size_t count, int fd) {
  assert(socket != NULL);
  assert(buf != NULL);

  if (fd == INVALID_FD)
    return socket_write(socket, buf, count);

  struct msghdr msg;
  struct iovec iov;
  char control_buf[CMSG_SPACE(sizeof(int))];

  iov.iov_base = (void *)buf;
  iov.iov_len = count;

  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;
  msg.msg_control = control_buf;
  msg.msg_controllen = sizeof(control_buf);
  msg.msg_name = NULL;
  msg.msg_namelen = 0;

  struct cmsghdr *header = CMSG_FIRSTHDR(&msg);
  header->cmsg_level = SOL_SOCKET;
  header->cmsg_type = SCM_RIGHTS;
  header->cmsg_len = CMSG_LEN(sizeof(int));
  *(int *)CMSG_DATA(header) = fd;

  ssize_t ret = sendmsg(socket->fd, &msg, MSG_DONTWAIT);
  close(fd);
  return ret;
}

ssize_t socket_bytes_available(const socket_t *socket) {
  assert(socket != NULL);

  int size = 0;
  if (ioctl(socket->fd, FIONREAD, &size) == -1)
    return -1;
  return size;
}

void socket_register(socket_t *socket, reactor_t *reactor, void *context, socket_cb read_cb, socket_cb write_cb) {
  assert(socket != NULL);

  // Make sure the socket isn't currently registered.
  socket_unregister(socket);

  socket->read_ready = read_cb;
  socket->write_ready = write_cb;
  socket->context = context;

  void (*read_fn)(void *) = (read_cb != NULL) ? internal_read_ready : NULL;
  void (*write_fn)(void *) = (write_cb != NULL) ? internal_write_ready : NULL;

  socket->reactor_object = reactor_register(reactor, socket->fd, socket, read_fn, write_fn);
}

void socket_unregister(socket_t *socket) {
  assert(socket != NULL);

  if (socket->reactor_object)
    reactor_unregister(socket->reactor_object);
  socket->reactor_object = NULL;
}

static void internal_read_ready(void *context) {
  assert(context != NULL);

  socket_t *socket = (void *)context;
  socket->read_ready(socket, socket->context);
}

static void internal_write_ready(void *context) {
  assert(context != NULL);

  socket_t *socket = (void *)context;
  socket->write_ready(socket, socket->context);
}