/*
 * Copyright (C) 2017 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 <errno.h>
#include <fcntl.h>
#include <pthread.h>
#if !defined(__MINGW32__)
#include <pwd.h>
#endif
#include <log/uio.h>
#include <sched.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>

#include <cutils/list.h> /* template, no library dependency */
#include <log/log_transport.h>
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
#include <system/thread_defs.h>

#include "config_read.h"
#include "config_write.h"
#include "log_portability.h"
#include "logger.h"

static const char baseServiceName[] = "android.logd";

static int writeToLocalInit();
static int writeToLocalAvailable(log_id_t logId);
static void writeToLocalReset();
static int writeToLocalWrite(log_id_t logId, struct timespec* ts,
                             struct iovec* vec, size_t nr);

LIBLOG_HIDDEN struct android_log_transport_write localLoggerWrite = {
  .node = { &localLoggerWrite.node, &localLoggerWrite.node },
  .context.priv = NULL,
  .name = "local",
  .available = writeToLocalAvailable,
  .open = writeToLocalInit,
  .close = writeToLocalReset,
  .write = writeToLocalWrite,
};

static int writeToLocalVersion(struct android_log_logger* logger,
                               struct android_log_transport_context* transp);
static int writeToLocalRead(struct android_log_logger_list* logger_list,
                            struct android_log_transport_context* transp,
                            struct log_msg* log_msg);
static int writeToLocalPoll(struct android_log_logger_list* logger_list,
                            struct android_log_transport_context* transp);
static void writeToLocalClose(struct android_log_logger_list* logger_list,
                              struct android_log_transport_context* transp);
static int writeToLocalClear(struct android_log_logger* logger,
                             struct android_log_transport_context* transp);
static ssize_t writeToLocalGetSize(struct android_log_logger* logger,
                                   struct android_log_transport_context* transp);
static ssize_t writeToLocalSetSize(
    struct android_log_logger* logger,
    struct android_log_transport_context* transp __unused, size_t size);
static ssize_t writeToLocalGetReadbleSize(
    struct android_log_logger* logger,
    struct android_log_transport_context* transp);

struct android_log_transport_read localLoggerRead = {
  .node = { &localLoggerRead.node, &localLoggerRead.node },
  .name = "local",
  .available = writeToLocalAvailable,
  .version = writeToLocalVersion,
  .read = writeToLocalRead,
  .poll = writeToLocalPoll,
  .close = writeToLocalClose,
  .clear = writeToLocalClear,
  .getSize = writeToLocalGetSize,
  .setSize = writeToLocalSetSize,
  .getReadableSize = writeToLocalGetReadbleSize,
  .getPrune = NULL,
  .setPrune = NULL,
  .getStats = NULL,
};

struct LogBufferElement {
  struct listnode node;
  log_id_t logId;
  pid_t tid;
  log_time timestamp;
  unsigned short len;
  char msg[];
};

static const size_t MAX_SIZE_DEFAULT = 32768;

/*
 * Number of log buffers we support with the following assumption:
 *  . . .
 *   LOG_ID_SECURITY = 5, // security logs go to the system logs only
 *   LOG_ID_KERNEL = 6,   // place last, third-parties can not use it
 *   LOG_ID_MAX
 * } log_id_t;
 *
 * Confirm the following should <log/log_id.h> be adjusted in the future.
 */
#define NUMBER_OF_LOG_BUFFERS \
  ((LOG_ID_SECURITY == (LOG_ID_MAX - 2)) ? LOG_ID_SECURITY : LOG_ID_KERNEL)
#define BLOCK_LOG_BUFFERS(id) \
  (((id) == LOG_ID_SECURITY) || ((id) == LOG_ID_KERNEL))

static struct LogBuffer {
  struct listnode head;
  pthread_rwlock_t listLock;
  char* serviceName; /* Also indicates ready by having a value */
  /* Order and proximity important for memset */
  size_t number[NUMBER_OF_LOG_BUFFERS];         /* clear memset          */
  size_t size[NUMBER_OF_LOG_BUFFERS];           /* clear memset          */
  size_t totalSize[NUMBER_OF_LOG_BUFFERS];      /* init memset           */
  size_t maxSize[NUMBER_OF_LOG_BUFFERS];        /* init MAX_SIZE_DEFAULT */
  struct listnode* last[NUMBER_OF_LOG_BUFFERS]; /* init &head            */
} logbuf = {
  .head = { &logbuf.head, &logbuf.head }, .listLock = PTHREAD_RWLOCK_INITIALIZER,
};

static void LogBufferInit(struct LogBuffer* log) {
  size_t i;

  pthread_rwlock_wrlock(&log->listLock);
  list_init(&log->head);
  memset(log->number, 0,
         sizeof(log->number) + sizeof(log->size) + sizeof(log->totalSize));
  for (i = 0; i < NUMBER_OF_LOG_BUFFERS; ++i) {
    log->maxSize[i] = MAX_SIZE_DEFAULT;
    log->last[i] = &log->head;
  }
#ifdef __BIONIC__
  asprintf(&log->serviceName, "%s@%d:%d", baseServiceName, __android_log_uid(),
           getpid());
#else
  char buffer[sizeof(baseServiceName) + 1 + 5 + 1 + 5 + 8];
  snprintf(buffer, sizeof(buffer), "%s@%d:%d", baseServiceName,
           __android_log_uid(), getpid());
  log->serviceName = strdup(buffer);
#endif
  pthread_rwlock_unlock(&log->listLock);
}

static void LogBufferClear(struct LogBuffer* log) {
  size_t i;
  struct listnode* node;

  pthread_rwlock_wrlock(&log->listLock);
  memset(log->number, 0, sizeof(log->number) + sizeof(log->size));
  for (i = 0; i < NUMBER_OF_LOG_BUFFERS; ++i) {
    log->last[i] = &log->head;
  }
  while ((node = list_head(&log->head)) != &log->head) {
    struct LogBufferElement* element;

    element = node_to_item(node, struct LogBufferElement, node);
    list_remove(node);
    free(element);
  }
  pthread_rwlock_unlock(&log->listLock);
}

static inline void LogBufferFree(struct LogBuffer* log) {
  pthread_rwlock_wrlock(&log->listLock);
  free(log->serviceName);
  log->serviceName = NULL;
  pthread_rwlock_unlock(&log->listLock);
  LogBufferClear(log);
}

static int LogBufferLog(struct LogBuffer* log,
                        struct LogBufferElement* element) {
  log_id_t logId = element->logId;

  pthread_rwlock_wrlock(&log->listLock);
  log->number[logId]++;
  log->size[logId] += element->len;
  log->totalSize[logId] += element->len;
  /* prune entry(s) until enough space is available */
  if (log->last[logId] == &log->head) {
    log->last[logId] = list_tail(&log->head);
  }
  while (log->size[logId] > log->maxSize[logId]) {
    struct listnode* node = log->last[logId];
    struct LogBufferElement* e;
    struct android_log_logger_list* logger_list;

    e = node_to_item(node, struct LogBufferElement, node);
    log->number[logId]--;
    log->size[logId] -= e->len;
    logger_list_rdlock();
    logger_list_for_each(logger_list) {
      struct android_log_transport_context* transp;

      transport_context_for_each(transp, logger_list) {
        if ((transp->transport == &localLoggerRead) &&
            (transp->context.node == node)) {
          if (node == &log->head) {
            transp->context.node = &log->head;
          } else {
            transp->context.node = node->next;
          }
        }
      }
    }
    logger_list_unlock();
    if (node != &log->head) {
      log->last[logId] = node->prev;
    }
    list_remove(node);
    LOG_ALWAYS_FATAL_IF(node == log->last[logId], "corrupted list");
    free(e);
  }
  /* add entry to list */
  list_add_head(&log->head, &element->node);
  /* ToDo: wake up all readers */
  pthread_rwlock_unlock(&log->listLock);

  return element->len;
}

/*
 * return zero if permitted to log directly to logd,
 * return 1 if binder server started and
 * return negative error number if failed to start binder server.
 */
static int writeToLocalInit() {
  pthread_attr_t attr;
  struct LogBuffer* log;

  if (writeToLocalAvailable(LOG_ID_MAIN) < 0) {
    return -EPERM;
  }

  log = &logbuf;
  if (!log->serviceName) {
    LogBufferInit(log);
  }

  if (!log->serviceName) {
    LogBufferFree(log);
    return -ENOMEM;
  }

  return EPERM; /* successful local-only logging */
}

static void writeToLocalReset() {
  LogBufferFree(&logbuf);
}

static int writeToLocalAvailable(log_id_t logId) {
#if !defined(__MINGW32__)
  uid_t uid;
#endif

  if ((logId >= NUMBER_OF_LOG_BUFFERS) || BLOCK_LOG_BUFFERS(logId)) {
    return -EINVAL;
  }

/* Android hard coded permitted, system goes to logd */
#if !defined(__MINGW32__)
  if (__android_log_transport == LOGGER_DEFAULT) {
    uid = __android_log_uid();
    if ((uid < AID_APP) && (getpwuid(uid) != NULL)) {
      return -EPERM;
    }
  }
#endif

  /* ToDo: Ask package manager for LOGD permissions */
  /* Assume we do _not_ have permissions to go to LOGD, so must go local */
  return 0;
}

static int writeToLocalWrite(log_id_t logId, struct timespec* ts,
                             struct iovec* vec, size_t nr) {
  size_t len, i;
  struct LogBufferElement* element;

  if ((logId >= NUMBER_OF_LOG_BUFFERS) || BLOCK_LOG_BUFFERS(logId)) {
    return -EINVAL;
  }

  len = 0;
  for (i = 0; i < nr; ++i) {
    len += vec[i].iov_len;
  }

  if (len > LOGGER_ENTRY_MAX_PAYLOAD) {
    len = LOGGER_ENTRY_MAX_PAYLOAD;
  }
  element = (struct LogBufferElement*)calloc(
      1, sizeof(struct LogBufferElement) + len + 1);
  if (!element) {
    return errno ? -errno : -ENOMEM;
  }
  element->timestamp.tv_sec = ts->tv_sec;
  element->timestamp.tv_nsec = ts->tv_nsec;
#ifdef __BIONIC__
  element->tid = gettid();
#else
  element->tid = getpid();
#endif
  element->logId = logId;
  element->len = len;

  char* cp = element->msg;
  for (i = 0; i < nr; ++i) {
    size_t iov_len = vec[i].iov_len;
    if (iov_len > len) {
      iov_len = len;
    }
    memcpy(cp, vec[i].iov_base, iov_len);
    len -= iov_len;
    if (len == 0) {
      break;
    }
    cp += iov_len;
  }

  return LogBufferLog(&logbuf, element);
}

static int writeToLocalVersion(struct android_log_logger* logger __unused,
                               struct android_log_transport_context* transp
                                   __unused) {
  return 3;
}

/* within reader lock, serviceName already validated */
static struct listnode* writeToLocalNode(
    struct android_log_logger_list* logger_list,
    struct android_log_transport_context* transp) {
  struct listnode* node;
  unsigned logMask;
  unsigned int tail;

  node = transp->context.node;
  if (node) {
    return node;
  }

  if (!logger_list->tail) {
    return transp->context.node = &logbuf.head;
  }

  logMask = transp->logMask;
  tail = logger_list->tail;

  for (node = list_head(&logbuf.head); node != &logbuf.head; node = node->next) {
    struct LogBufferElement* element;
    log_id_t logId;

    element = node_to_item(node, struct LogBufferElement, node);
    logId = element->logId;

    if ((logMask & (1 << logId)) && !--tail) {
      node = node->next;
      break;
    }
  }
  return transp->context.node = node;
}

static int writeToLocalRead(struct android_log_logger_list* logger_list,
                            struct android_log_transport_context* transp,
                            struct log_msg* log_msg) {
  int ret;
  struct listnode* node;
  unsigned logMask;

  pthread_rwlock_rdlock(&logbuf.listLock);
  if (!logbuf.serviceName) {
    pthread_rwlock_unlock(&logbuf.listLock);
    return (logger_list->mode & ANDROID_LOG_NONBLOCK) ? -ENODEV : 0;
  }

  logMask = transp->logMask;

  node = writeToLocalNode(logger_list, transp);

  ret = 0;

  while (node != list_head(&logbuf.head)) {
    struct LogBufferElement* element;
    log_id_t logId;

    node = node->prev;
    element = node_to_item(node, struct LogBufferElement, node);
    logId = element->logId;

    if (logMask & (1 << logId)) {
      ret = log_msg->entry_v3.len = element->len;
      log_msg->entry_v3.hdr_size = sizeof(log_msg->entry_v3);
      log_msg->entry_v3.pid = getpid();
      log_msg->entry_v3.tid = element->tid;
      log_msg->entry_v3.sec = element->timestamp.tv_sec;
      log_msg->entry_v3.nsec = element->timestamp.tv_nsec;
      log_msg->entry_v3.lid = logId;
      memcpy(log_msg->entry_v3.msg, element->msg, ret);
      ret += log_msg->entry_v3.hdr_size;
      break;
    }
  }

  transp->context.node = node;

  /* ToDo: if blocking, and no entry, put reader to sleep */
  pthread_rwlock_unlock(&logbuf.listLock);
  return ret;
}

static int writeToLocalPoll(struct android_log_logger_list* logger_list,
                            struct android_log_transport_context* transp) {
  int ret = (logger_list->mode & ANDROID_LOG_NONBLOCK) ? -ENODEV : 0;

  pthread_rwlock_rdlock(&logbuf.listLock);

  if (logbuf.serviceName) {
    unsigned logMask = transp->logMask;
    struct listnode* node = writeToLocalNode(logger_list, transp);

    ret = (node != list_head(&logbuf.head));
    if (ret) {
      do {
        ret = !!(logMask &
                 (1 << (node_to_item(node->prev, struct LogBufferElement, node))
                           ->logId));
      } while (!ret && ((node = node->prev) != list_head(&logbuf.head)));
    }

    transp->context.node = node;
  }

  pthread_rwlock_unlock(&logbuf.listLock);

  return ret;
}

static void writeToLocalClose(struct android_log_logger_list* logger_list
                                  __unused,
                              struct android_log_transport_context* transp) {
  pthread_rwlock_wrlock(&logbuf.listLock);
  transp->context.node = list_head(&logbuf.head);
  pthread_rwlock_unlock(&logbuf.listLock);
}

static int writeToLocalClear(struct android_log_logger* logger,
                             struct android_log_transport_context* unused
                                 __unused) {
  log_id_t logId = logger->logId;
  struct listnode *node, *n;

  if ((logId >= NUMBER_OF_LOG_BUFFERS) || BLOCK_LOG_BUFFERS(logId)) {
    return -EINVAL;
  }

  pthread_rwlock_wrlock(&logbuf.listLock);
  logbuf.number[logId] = 0;
  logbuf.last[logId] = &logbuf.head;
  list_for_each_safe(node, n, &logbuf.head) {
    struct LogBufferElement* element;
    element = node_to_item(node, struct LogBufferElement, node);

    if (logId == element->logId) {
      struct android_log_logger_list* logger_list;

      logger_list_rdlock();
      logger_list_for_each(logger_list) {
        struct android_log_transport_context* transp;

        transport_context_for_each(transp, logger_list) {
          if ((transp->transport == &localLoggerRead) &&
              (transp->context.node == node)) {
            transp->context.node = node->next;
          }
        }
      }
      logger_list_unlock();
      list_remove(node);
      free(element);
    }
  }

  pthread_rwlock_unlock(&logbuf.listLock);

  return 0;
}

static ssize_t writeToLocalGetSize(struct android_log_logger* logger,
                                   struct android_log_transport_context* transp
                                       __unused) {
  ssize_t ret = -EINVAL;
  log_id_t logId = logger->logId;

  if ((logId < NUMBER_OF_LOG_BUFFERS) && !BLOCK_LOG_BUFFERS(logId)) {
    pthread_rwlock_rdlock(&logbuf.listLock);
    ret = logbuf.maxSize[logId];
    pthread_rwlock_unlock(&logbuf.listLock);
  }

  return ret;
}

static ssize_t writeToLocalSetSize(
    struct android_log_logger* logger,
    struct android_log_transport_context* transp __unused, size_t size) {
  ssize_t ret = -EINVAL;

  if ((size > LOGGER_ENTRY_MAX_LEN) || (size < (4 * 1024 * 1024))) {
    log_id_t logId = logger->logId;
    if ((logId < NUMBER_OF_LOG_BUFFERS) || !BLOCK_LOG_BUFFERS(logId)) {
      pthread_rwlock_wrlock(&logbuf.listLock);
      ret = logbuf.maxSize[logId] = size;
      pthread_rwlock_unlock(&logbuf.listLock);
    }
  }

  return ret;
}

static ssize_t writeToLocalGetReadbleSize(
    struct android_log_logger* logger,
    struct android_log_transport_context* transp __unused) {
  ssize_t ret = -EINVAL;
  log_id_t logId = logger->logId;

  if ((logId < NUMBER_OF_LOG_BUFFERS) && !BLOCK_LOG_BUFFERS(logId)) {
    pthread_rwlock_rdlock(&logbuf.listLock);
    ret = logbuf.serviceName ? (ssize_t)logbuf.size[logId] : -EBADF;
    pthread_rwlock_unlock(&logbuf.listLock);
  }

  return ret;
}