liblog/stderr_write.c

/*
 * 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.
 */

/*
 * stderr write handler.  Output is logcat-like, and responds to
 * logcat's environment variables ANDROID_PRINTF_LOG and
 * ANDROID_LOG_TAGS to filter output.
 *
 * This transport only provides a writer, that means that it does not
 * provide an End-To-End capability as the logs are effectively _lost_
 * to the stderr file stream.  The purpose of this transport is to
 * supply a means for command line tools to report their logging
 * to the stderr stream, in line with all other activities.
 */

#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#include <log/event_tag_map.h>
#include <log/log.h>
#include <log/logprint.h>
#include <log/uio.h>

#include "log_portability.h"
#include "logger.h"

static int stderrOpen();
static void stderrClose();
static int stderrAvailable(log_id_t logId);
static int stderrWrite(log_id_t logId, struct timespec* ts,
                       struct iovec* vec, size_t nr);

struct stderrContext {
    AndroidLogFormat* logformat;
#if defined(__ANDROID__)
    EventTagMap* eventTagMap;
#endif
};

LIBLOG_HIDDEN struct android_log_transport_write stderrLoggerWrite = {
    .node = { &stderrLoggerWrite.node, &stderrLoggerWrite.node },
    .context.private = NULL,
    .name = "stderr",
    .available = stderrAvailable,
    .open = stderrOpen,
    .close = stderrClose,
    .write = stderrWrite,
};

static int stderrOpen()
{
    struct stderrContext* ctx;
    const char* envStr;
    bool setFormat;

    if (!stderr || (fileno(stderr) < 0)) {
        return -EBADF;
    }

    if (stderrLoggerWrite.context.private) {
        return fileno(stderr);
    }

    ctx = calloc(1, sizeof(struct stderrContext));
    if (!ctx) {
        return -ENOMEM;
    }

    ctx->logformat = android_log_format_new();
    if (!ctx->logformat) {
        free(ctx);
        return -ENOMEM;
    }

    envStr = getenv("ANDROID_PRINTF_LOG");
    setFormat = false;

    if (envStr) {
        char* formats = strdup(envStr);
        char* sv = NULL;
        char* arg = formats;
        while (!!(arg = strtok_r(arg, ",:; \t\n\r\f", &sv))) {
            AndroidLogPrintFormat format = android_log_formatFromString(arg);
            arg = NULL;
            if (format == FORMAT_OFF) {
                continue;
            }
            if (android_log_setPrintFormat(ctx->logformat, format) <= 0) {
                continue;
            }
            setFormat = true;
        }
        free(formats);
    }
    if (!setFormat) {
        AndroidLogPrintFormat format = android_log_formatFromString(
                "threadtime");
        android_log_setPrintFormat(ctx->logformat, format);
    }
    envStr = getenv("ANDROID_LOG_TAGS");
    if (envStr) {
        android_log_addFilterString(ctx->logformat, envStr);
    }
    stderrLoggerWrite.context.private = ctx;

    return fileno(stderr);
}

static void stderrClose()
{
    struct stderrContext* ctx = stderrLoggerWrite.context.private;

    if (ctx) {
        stderrLoggerWrite.context.private = NULL;
        if (ctx->logformat) {
            android_log_format_free(ctx->logformat);
            ctx->logformat = NULL;
        }
#if defined(__ANDROID__)
        if (ctx->eventTagMap) {
            android_closeEventTagMap(ctx->eventTagMap);
            ctx->eventTagMap = NULL;
        }
#endif
    }
}

static int stderrAvailable(log_id_t logId)
{
    if ((logId >= LOG_ID_MAX) || (logId == LOG_ID_KERNEL)) {
        return -EINVAL;
    }
    return 1;
}

static int stderrWrite(log_id_t logId, struct timespec* ts,
                       struct iovec* vec, size_t nr)
{
    struct log_msg log_msg;
    AndroidLogEntry entry;
    char binaryMsgBuf[1024];
    int err;
    size_t i;
    struct stderrContext* ctx = stderrLoggerWrite.context.private;

    if (!ctx) return -EBADF;
    if (!vec || !nr) return -EINVAL;

    log_msg.entry.len = 0;
    log_msg.entry.hdr_size = sizeof(log_msg.entry);
    log_msg.entry.pid = getpid();
#ifdef __BIONIC__
    log_msg.entry.tid = gettid();
#else
    log_msg.entry.tid = getpid();
#endif
    log_msg.entry.sec = ts->tv_sec;
    log_msg.entry.nsec = ts->tv_nsec;
    log_msg.entry.lid = logId;
    log_msg.entry.uid = __android_log_uid();

    for (i = 0; i < nr; ++i) {
        size_t len = vec[i].iov_len;
        if ((log_msg.entry.len + len) > LOGGER_ENTRY_MAX_PAYLOAD) {
            len = LOGGER_ENTRY_MAX_PAYLOAD - log_msg.entry.len;
        }
        if (!len) continue;
        memcpy(log_msg.entry.msg + log_msg.entry.len, vec[i].iov_base, len);
        log_msg.entry.len += len;
    }

    if ((logId == LOG_ID_EVENTS) || (logId == LOG_ID_SECURITY)) {
#if defined(__ANDROID__)
        if (!ctx->eventTagMap) {
            ctx->eventTagMap = android_openEventTagMap(NULL);
        }
#endif
        err = android_log_processBinaryLogBuffer(&log_msg.entry_v1,
                                                 &entry,
#if defined(__ANDROID__)
                                                 ctx->eventTagMap,
#else
                                                 NULL,
#endif
                                                 binaryMsgBuf,
                                                 sizeof(binaryMsgBuf));
    } else {
        err = android_log_processLogBuffer(&log_msg.entry_v1, &entry);
    }

    /* print known truncated data, in essence logcat --debug */
    if ((err < 0) && !entry.message) return -EINVAL;

    if (!android_log_shouldPrintLine(ctx->logformat, entry.tag, entry.priority)) {
        return log_msg.entry.len;
    }

    err = android_log_printLogLine(ctx->logformat, fileno(stderr), &entry);
    if (err < 0) return errno ? -errno : -EINVAL;
    return log_msg.entry.len;
}