/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */



#include "Trace.h"
#include <cstdarg>
#include <string>
#include <cstdio>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>

using namespace std;

/**
 * Tracking for the stacks
 */
vector<vector<Trace *> > Trace::stacks;

/**
 * The indentation string for output
 */
vector<string> Trace::indent;

#define MAX_MSG_PREFIX_LEN 128
#define CTIME_LEN       26
#define DEBUG_FILE      "/var/adm/sun_fc.debug"
#define LOG_FILE        "/var/adm/sun_fc"

/**
 * @memo            Log a message
 * @param           priority The priority of the message (see syslog man page)
 * @param           msg The message string
 * 
 * @doc             If the debug file is present, we will log everything to
 *                  that file.  Otherwise, if the normal log file is present,
 *                  we'll log all non-debug messages to that file.  Lastly,
 *                  if neither file is present, the message will be
 *                  silently discarded.
 */
void Trace::message(int priority, const char *msg) {
        char prefix[MAX_MSG_PREFIX_LEN];
        char message[MAX_MSG_PREFIX_LEN + MAX_MSG_LEN + 2];
        int fd;
        // char time[CTIME_LEN+1];
        std::string priString;


        /* If we can open the log file, write there, else use the cim log */
        fd = open(DEBUG_FILE, O_WRONLY|O_APPEND); /* will only open if exists */
        if (fd == -1) {
            /* No debug file, how about the log file? */
            if (priority == LOG_DEBUG) {
                return; /* Ignore debug */
            }
            fd = open(LOG_FILE, O_WRONLY|O_APPEND);
            /* We catch open failures later */
        }

        // now(time);
        /* First interpret the priority value */
        switch (priority) {
        case INTERNAL_ERROR:
            priString = "INTERNAL";
            break;
        case STACK_TRACE:
            priString = "STACK";
            break;
        case IO_ERROR:
            priString = "IO";
            break;
        case USER_ERROR:
            priString = "USER";
            break;
        case LOG_DEBUG:
            priString = "DEBUG";
            break;
        default:
            priString = "UNKNOWN";
            break;
        }

        if (fd != -1) {
            /* Format the prefix string for the log file */
            snprintf(prefix, MAX_MSG_PREFIX_LEN, "%d:%d:%s%s:%s",
                time(NULL),
                tid,
                indent[tid].c_str(),
                routine.c_str(),
                priString.c_str());

            /* Format the message string for the log file */
            snprintf(message, strlen(prefix) + MAX_MSG_LEN + 2, "%s:%s\n",
                prefix,
                msg);
            write(fd, message, strlen(message));
            close(fd);
        } /* Else discard the log message */
}

/**
 * @memo            Create a new Trace instance and update stack.
 * @param           myRoutine The name of the routine 
 * 
 * @doc             This class was developed to provide a Java
 *                  like stack trace capability, as C++ does not provide
 *                  a run-time stack lookup feature.  Instances of the
 *                  Trace class should be created on the stack so they
 *                  will be automatically freed when the stack is popped
 *                  when the function returns.
 */
Trace::Trace(std::string myRoutine) : routine(myRoutine) {
        tid = pthread_self();
        if (stacks.size() < tid+1) {
            stacks.resize(tid+1);
            indent.resize(tid+1);
            indent[tid] = "";
        }
        message(LOG_DEBUG, "entered");
        stacks[tid].push_back(this);
        indent[tid] += " ";
}

/**
 * @memo            Delete a trace instances and update the stack
 */
Trace::~Trace() {
        string::size_type len = indent[tid].size();
        if (len > 0) {
            indent[tid].resize(len - 1);
        }
        message(LOG_DEBUG, "exited");
        stacks[tid].pop_back();
}

/**
 * @memo            Print out the current stack trace information
 */
void Trace::stackTrace() {
        message(STACK_TRACE, "Stack trace follows");
        for (vector<Trace *>::size_type i = stacks[tid].size() - 1; ; i--) {
            string msg = "          ";
            msg += (stacks[tid])[i]->label();
            message(STACK_TRACE, msg.c_str());
            if (i == 0) {
                break;
            }
        }
}