liblog/log_event_list.cpp

/*
 * Copyright (C) 2016 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 <inttypes.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <log/log_event_list.h>
#include <private/android_logger.h>

#include "log_portability.h"

#define MAX_EVENT_PAYLOAD (LOGGER_ENTRY_MAX_PAYLOAD - sizeof(int32_t))

enum ReadWriteFlag {
  kAndroidLoggerRead = 1,
  kAndroidLoggerWrite = 2,
};

struct android_log_context_internal {
  uint32_t tag;
  unsigned pos;                                    /* Read/write position into buffer */
  unsigned count[ANDROID_MAX_LIST_NEST_DEPTH + 1]; /* Number of elements   */
  unsigned list[ANDROID_MAX_LIST_NEST_DEPTH + 1];  /* pos for list counter */
  unsigned list_nest_depth;
  unsigned len; /* Length or raw buffer. */
  bool overflow;
  bool list_stop; /* next call decrement list_nest_depth and issue a stop */
  ReadWriteFlag read_write_flag;
  uint8_t storage[LOGGER_ENTRY_MAX_PAYLOAD];
};

// TODO(tomcherry): real C++ structs.
typedef struct android_log_context_internal android_log_context_internal;

static void init_context(android_log_context_internal* context, uint32_t tag) {
  size_t needed;

  context->tag = tag;
  context->read_write_flag = kAndroidLoggerWrite;
  needed = sizeof(uint8_t) + sizeof(uint8_t);
  if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
    context->overflow = true;
  }
  /* Everything is a list */
  context->storage[context->pos + 0] = EVENT_TYPE_LIST;
  context->list[0] = context->pos + 1;
  context->pos += needed;
}

static void init_parser_context(android_log_context_internal* context, const char* msg,
                                size_t len) {
  len = (len <= MAX_EVENT_PAYLOAD) ? len : MAX_EVENT_PAYLOAD;
  context->len = len;
  memcpy(context->storage, msg, len);
  context->read_write_flag = kAndroidLoggerRead;
}

android_log_context create_android_logger(uint32_t tag) {
  android_log_context_internal* context;

  context =
      static_cast<android_log_context_internal*>(calloc(1, sizeof(android_log_context_internal)));
  if (!context) {
    return NULL;
  }
  init_context(context, tag);

  return (android_log_context)context;
}

android_log_context create_android_log_parser(const char* msg, size_t len) {
  android_log_context_internal* context;
  size_t i;

  context =
      static_cast<android_log_context_internal*>(calloc(1, sizeof(android_log_context_internal)));
  if (!context) {
    return NULL;
  }
  init_parser_context(context, msg, len);

  return (android_log_context)context;
}

int android_log_destroy(android_log_context* ctx) {
  android_log_context_internal* context;

  context = (android_log_context_internal*)*ctx;
  if (!context) {
    return -EBADF;
  }
  memset(context, 0, sizeof(*context));
  free(context);
  *ctx = NULL;
  return 0;
}

int android_log_reset(android_log_context ctx) {
  android_log_context_internal* context;
  uint32_t tag;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }

  tag = context->tag;
  memset(context, 0, sizeof(*context));
  init_context(context, tag);

  return 0;
}

int android_log_parser_reset(android_log_context ctx, const char* msg, size_t len) {
  android_log_context_internal* context;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerRead != context->read_write_flag)) {
    return -EBADF;
  }

  memset(context, 0, sizeof(*context));
  init_parser_context(context, msg, len);

  return 0;
}

int android_log_write_list_begin(android_log_context ctx) {
  size_t needed;
  android_log_context_internal* context;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }
  if (context->list_nest_depth > ANDROID_MAX_LIST_NEST_DEPTH) {
    context->overflow = true;
    return -EOVERFLOW;
  }
  needed = sizeof(uint8_t) + sizeof(uint8_t);
  if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
    context->overflow = true;
    return -EIO;
  }
  context->count[context->list_nest_depth]++;
  context->list_nest_depth++;
  if (context->list_nest_depth > ANDROID_MAX_LIST_NEST_DEPTH) {
    context->overflow = true;
    return -EOVERFLOW;
  }
  if (context->overflow) {
    return -EIO;
  }
  context->storage[context->pos + 0] = EVENT_TYPE_LIST;
  context->storage[context->pos + 1] = 0;
  context->list[context->list_nest_depth] = context->pos + 1;
  context->count[context->list_nest_depth] = 0;
  context->pos += needed;
  return 0;
}

static inline void copy4LE(uint8_t* buf, uint32_t val) {
  buf[0] = val & 0xFF;
  buf[1] = (val >> 8) & 0xFF;
  buf[2] = (val >> 16) & 0xFF;
  buf[3] = (val >> 24) & 0xFF;
}

int android_log_write_int32(android_log_context ctx, int32_t value) {
  size_t needed;
  android_log_context_internal* context;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }
  if (context->overflow) {
    return -EIO;
  }
  needed = sizeof(uint8_t) + sizeof(value);
  if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
    context->overflow = true;
    return -EIO;
  }
  context->count[context->list_nest_depth]++;
  context->storage[context->pos + 0] = EVENT_TYPE_INT;
  copy4LE(&context->storage[context->pos + 1], value);
  context->pos += needed;
  return 0;
}

static inline void copy8LE(uint8_t* buf, uint64_t val) {
  buf[0] = val & 0xFF;
  buf[1] = (val >> 8) & 0xFF;
  buf[2] = (val >> 16) & 0xFF;
  buf[3] = (val >> 24) & 0xFF;
  buf[4] = (val >> 32) & 0xFF;
  buf[5] = (val >> 40) & 0xFF;
  buf[6] = (val >> 48) & 0xFF;
  buf[7] = (val >> 56) & 0xFF;
}

int android_log_write_int64(android_log_context ctx, int64_t value) {
  size_t needed;
  android_log_context_internal* context;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }
  if (context->overflow) {
    return -EIO;
  }
  needed = sizeof(uint8_t) + sizeof(value);
  if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
    context->overflow = true;
    return -EIO;
  }
  context->count[context->list_nest_depth]++;
  context->storage[context->pos + 0] = EVENT_TYPE_LONG;
  copy8LE(&context->storage[context->pos + 1], value);
  context->pos += needed;
  return 0;
}

int android_log_write_string8_len(android_log_context ctx, const char* value, size_t maxlen) {
  size_t needed;
  ssize_t len;
  android_log_context_internal* context;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }
  if (context->overflow) {
    return -EIO;
  }
  if (!value) {
    value = "";
  }
  len = strnlen(value, maxlen);
  needed = sizeof(uint8_t) + sizeof(int32_t) + len;
  if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
    /* Truncate string for delivery */
    len = MAX_EVENT_PAYLOAD - context->pos - 1 - sizeof(int32_t);
    if (len <= 0) {
      context->overflow = true;
      return -EIO;
    }
  }
  context->count[context->list_nest_depth]++;
  context->storage[context->pos + 0] = EVENT_TYPE_STRING;
  copy4LE(&context->storage[context->pos + 1], len);
  if (len) {
    memcpy(&context->storage[context->pos + 5], value, len);
  }
  context->pos += needed;
  return len;
}

int android_log_write_string8(android_log_context ctx, const char* value) {
  return android_log_write_string8_len(ctx, value, MAX_EVENT_PAYLOAD);
}

int android_log_write_float32(android_log_context ctx, float value) {
  size_t needed;
  uint32_t ivalue;
  android_log_context_internal* context;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }
  if (context->overflow) {
    return -EIO;
  }
  needed = sizeof(uint8_t) + sizeof(ivalue);
  if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
    context->overflow = true;
    return -EIO;
  }
  ivalue = *(uint32_t*)&value;
  context->count[context->list_nest_depth]++;
  context->storage[context->pos + 0] = EVENT_TYPE_FLOAT;
  copy4LE(&context->storage[context->pos + 1], ivalue);
  context->pos += needed;
  return 0;
}

int android_log_write_list_end(android_log_context ctx) {
  android_log_context_internal* context;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }
  if (context->list_nest_depth > ANDROID_MAX_LIST_NEST_DEPTH) {
    context->overflow = true;
    context->list_nest_depth--;
    return -EOVERFLOW;
  }
  if (!context->list_nest_depth) {
    context->overflow = true;
    return -EOVERFLOW;
  }
  if (context->list[context->list_nest_depth] <= 0) {
    context->list_nest_depth--;
    context->overflow = true;
    return -EOVERFLOW;
  }
  context->storage[context->list[context->list_nest_depth]] =
      context->count[context->list_nest_depth];
  context->list_nest_depth--;
  return 0;
}

/*
 * Logs the list of elements to the event log.
 */
int android_log_write_list(android_log_context ctx, log_id_t id) {
  android_log_context_internal* context;
  const char* msg;
  ssize_t len;

  if ((id != LOG_ID_EVENTS) && (id != LOG_ID_SECURITY) && (id != LOG_ID_STATS)) {
    return -EINVAL;
  }

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }
  if (context->list_nest_depth) {
    return -EIO;
  }
  /* NB: if there was overflow, then log is truncated. Nothing reported */
  context->storage[1] = context->count[0];
  len = context->len = context->pos;
  msg = (const char*)context->storage;
  /* it's not a list */
  if (context->count[0] <= 1) {
    len -= sizeof(uint8_t) + sizeof(uint8_t);
    if (len < 0) {
      len = 0;
    }
    msg += sizeof(uint8_t) + sizeof(uint8_t);
  }
  return (id == LOG_ID_EVENTS)
             ? __android_log_bwrite(context->tag, msg, len)
             : ((id == LOG_ID_STATS) ? __android_log_stats_bwrite(context->tag, msg, len)
                                     : __android_log_security_bwrite(context->tag, msg, len));
}

int android_log_write_list_buffer(android_log_context ctx, const char** buffer) {
  android_log_context_internal* context;
  const char* msg;
  ssize_t len;

  context = (android_log_context_internal*)ctx;
  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
    return -EBADF;
  }
  if (context->list_nest_depth) {
    return -EIO;
  }
  if (buffer == NULL) {
    return -EFAULT;
  }
  /* NB: if there was overflow, then log is truncated. Nothing reported */
  context->storage[1] = context->count[0];
  len = context->len = context->pos;
  msg = (const char*)context->storage;
  /* it's not a list */
  if (context->count[0] <= 1) {
    len -= sizeof(uint8_t) + sizeof(uint8_t);
    if (len < 0) {
      len = 0;
    }
    msg += sizeof(uint8_t) + sizeof(uint8_t);
  }
  *buffer = msg;
  return len;
}

/*
 * Extract a 4-byte value from a byte stream.
 */
static inline uint32_t get4LE(const uint8_t* src) {
  return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
}

/*
 * Extract an 8-byte value from a byte stream.
 */
static inline uint64_t get8LE(const uint8_t* src) {
  uint32_t low = src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
  uint32_t high = src[4] | (src[5] << 8) | (src[6] << 16) | (src[7] << 24);
  return ((uint64_t)high << 32) | (uint64_t)low;
}

/*
 * Gets the next element. Parsing errors result in an EVENT_TYPE_UNKNOWN type.
 * If there is nothing to process, the complete field is set to non-zero. If
 * an EVENT_TYPE_UNKNOWN type is returned once, and the caller does not check
 * this and continues to call this function, the behavior is undefined
 * (although it won't crash).
 */
static android_log_list_element android_log_read_next_internal(android_log_context ctx, int peek) {
  android_log_list_element elem;
  unsigned pos;
  android_log_context_internal* context;

  context = (android_log_context_internal*)ctx;

  memset(&elem, 0, sizeof(elem));

  /* Nothing to parse from this context, so return complete. */
  if (!context || (kAndroidLoggerRead != context->read_write_flag) ||
      (context->list_nest_depth > ANDROID_MAX_LIST_NEST_DEPTH) ||
      (context->count[context->list_nest_depth] >=
       (MAX_EVENT_PAYLOAD / (sizeof(uint8_t) + sizeof(uint8_t))))) {
    elem.type = EVENT_TYPE_UNKNOWN;
    if (context &&
        (context->list_stop || ((context->list_nest_depth <= ANDROID_MAX_LIST_NEST_DEPTH) &&
                                !context->count[context->list_nest_depth]))) {
      elem.type = EVENT_TYPE_LIST_STOP;
    }
    elem.complete = true;
    return elem;
  }

  /*
   * Use a different variable to update the position in case this
   * operation is a "peek".
   */
  pos = context->pos;
  if (context->list_stop) {
    elem.type = EVENT_TYPE_LIST_STOP;
    elem.complete = !context->count[0] && (!context->list_nest_depth ||
                                           ((context->list_nest_depth == 1) && !context->count[1]));
    if (!peek) {
      /* Suck in superfluous stop */
      if (context->storage[pos] == EVENT_TYPE_LIST_STOP) {
        context->pos = pos + 1;
      }
      if (context->list_nest_depth) {
        --context->list_nest_depth;
        if (context->count[context->list_nest_depth]) {
          context->list_stop = false;
        }
      } else {
        context->list_stop = false;
      }
    }
    return elem;
  }
  if ((pos + 1) > context->len) {
    elem.type = EVENT_TYPE_UNKNOWN;
    elem.complete = true;
    return elem;
  }

  elem.type = static_cast<AndroidEventLogType>(context->storage[pos++]);
  switch ((int)elem.type) {
    case EVENT_TYPE_FLOAT:
    /* Rely on union to translate elem.data.int32 into elem.data.float32 */
    /* FALLTHRU */
    case EVENT_TYPE_INT:
      elem.len = sizeof(int32_t);
      if ((pos + elem.len) > context->len) {
        elem.type = EVENT_TYPE_UNKNOWN;
        return elem;
      }
      elem.data.int32 = get4LE(&context->storage[pos]);
      /* common tangeable object suffix */
      pos += elem.len;
      elem.complete = !context->list_nest_depth && !context->count[0];
      if (!peek) {
        if (!context->count[context->list_nest_depth] ||
            !--(context->count[context->list_nest_depth])) {
          context->list_stop = true;
        }
        context->pos = pos;
      }
      return elem;

    case EVENT_TYPE_LONG:
      elem.len = sizeof(int64_t);
      if ((pos + elem.len) > context->len) {
        elem.type = EVENT_TYPE_UNKNOWN;
        return elem;
      }
      elem.data.int64 = get8LE(&context->storage[pos]);
      /* common tangeable object suffix */
      pos += elem.len;
      elem.complete = !context->list_nest_depth && !context->count[0];
      if (!peek) {
        if (!context->count[context->list_nest_depth] ||
            !--(context->count[context->list_nest_depth])) {
          context->list_stop = true;
        }
        context->pos = pos;
      }
      return elem;

    case EVENT_TYPE_STRING:
      if ((pos + sizeof(int32_t)) > context->len) {
        elem.type = EVENT_TYPE_UNKNOWN;
        elem.complete = true;
        return elem;
      }
      elem.len = get4LE(&context->storage[pos]);
      pos += sizeof(int32_t);
      if ((pos + elem.len) > context->len) {
        elem.len = context->len - pos; /* truncate string */
        elem.complete = true;
        if (!elem.len) {
          elem.type = EVENT_TYPE_UNKNOWN;
          return elem;
        }
      }
      elem.data.string = (char*)&context->storage[pos];
      /* common tangeable object suffix */
      pos += elem.len;
      elem.complete = !context->list_nest_depth && !context->count[0];
      if (!peek) {
        if (!context->count[context->list_nest_depth] ||
            !--(context->count[context->list_nest_depth])) {
          context->list_stop = true;
        }
        context->pos = pos;
      }
      return elem;

    case EVENT_TYPE_LIST:
      if ((pos + sizeof(uint8_t)) > context->len) {
        elem.type = EVENT_TYPE_UNKNOWN;
        elem.complete = true;
        return elem;
      }
      elem.complete = context->list_nest_depth >= ANDROID_MAX_LIST_NEST_DEPTH;
      if (peek) {
        return elem;
      }
      if (context->count[context->list_nest_depth]) {
        context->count[context->list_nest_depth]--;
      }
      context->list_stop = !context->storage[pos];
      context->list_nest_depth++;
      if (context->list_nest_depth <= ANDROID_MAX_LIST_NEST_DEPTH) {
        context->count[context->list_nest_depth] = context->storage[pos];
      }
      context->pos = pos + sizeof(uint8_t);
      return elem;

    case EVENT_TYPE_LIST_STOP: /* Suprise Newline terminates lists. */
      if (!peek) {
        context->pos = pos;
      }
      elem.type = EVENT_TYPE_UNKNOWN;
      elem.complete = !context->list_nest_depth;
      if (context->list_nest_depth > 0) {
        elem.type = EVENT_TYPE_LIST_STOP;
        if (!peek) {
          context->list_nest_depth--;
        }
      }
      return elem;

    default:
      elem.type = EVENT_TYPE_UNKNOWN;
      return elem;
  }
}

android_log_list_element android_log_read_next(android_log_context ctx) {
  return android_log_read_next_internal(ctx, 0);
}

android_log_list_element android_log_peek_next(android_log_context ctx) {
  return android_log_read_next_internal(ctx, 1);
}