| /* |
| * Conditions Of Use |
| * |
| * This software was developed by employees of the National Institute of |
| * Standards and Technology (NIST), an agency of the Federal Government. |
| * Pursuant to title 15 Untied States Code Section 105, works of NIST |
| * employees are not subject to copyright protection in the United States |
| * and are considered to be in the public domain. As a result, a formal |
| * license is not needed to use the software. |
| * |
| * This software is provided by NIST as a service and is expressly |
| * provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED |
| * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT |
| * AND DATA ACCURACY. NIST does not warrant or make any representations |
| * regarding the use of the software or the results thereof, including but |
| * not limited to the correctness, accuracy, reliability or usefulness of |
| * the software. |
| * |
| * Permission to use this software is contingent upon your acceptance |
| * of the terms of this agreement. |
| * |
| */ |
| /*************************************************************************** |
| * Product of NIST/ITL Advanced Networking Technologies Division (ANTD). * |
| ***************************************************************************/ |
| package gov.nist.core; |
| |
| import java.io.*; |
| import java.util.Properties; |
| |
| // BEGIN ANDROID-added |
| // TODO: this class should be replaced by android logging mechanism. |
| public class LogWriter implements StackLogger { |
| private static final String TAG = "SIP_STACK"; |
| |
| private boolean mEnabled = true; |
| |
| public void logStackTrace() { |
| // TODO |
| } |
| |
| public void logStackTrace(int traceLevel) { |
| // TODO |
| } |
| |
| public int getLineCount() { |
| return 0; |
| } |
| |
| public void logException(Throwable ex) { |
| //Log.e(TAG, "", ex); |
| } |
| public void logDebug(String message) { |
| //Log.d(TAG, message); |
| } |
| public void logTrace(String message) { |
| //Log.d(TAG, message); |
| } |
| public void logFatalError(String message) { |
| //Log.e(TAG, message); |
| } |
| public void logError(String message) { |
| //Log.e(TAG, message); |
| } |
| public boolean isLoggingEnabled() { |
| return mEnabled; |
| } |
| public boolean isLoggingEnabled(int logLevel) { |
| // TODO |
| return mEnabled; |
| } |
| public void logError(String message, Exception ex) { |
| //Log.e(TAG, message, ex); |
| } |
| public void logWarning(String string) { |
| //Log.w(TAG, string); |
| } |
| public void logInfo(String string) { |
| //Log.i(TAG, string); |
| } |
| |
| public void disableLogging() { |
| mEnabled = false; |
| } |
| |
| public void enableLogging() { |
| mEnabled = true; |
| } |
| |
| public void setBuildTimeStamp(String buildTimeStamp) { |
| } |
| |
| public void setStackProperties(Properties stackProperties) { |
| } |
| |
| public String getLoggerName() { |
| return "Android SIP Logger"; |
| } |
| } |
| // END android-added |
| |
| // BEGIN android-deleted |
| |
| //import org.apache.log4j.Appender; |
| //import org.apache.log4j.FileAppender; |
| //import org.apache.log4j.Level; |
| //import org.apache.log4j.Logger; |
| //import org.apache.log4j.Priority; |
| //import org.apache.log4j.SimpleLayout; |
| // |
| ///** |
| // * A wrapper around log4j that is used for logging debug and errors. You can |
| // * replace this file if you want to change the way in which messages are logged. |
| // * |
| // * @version 1.2 |
| // * |
| // * @author M. Ranganathan <br/> |
| // * @author M.Andrews |
| // * @author Jeroen van Bemmel |
| // * @author Jean Deruelle |
| // * |
| // */ |
| // |
| //public class LogWriter implements StackLogger { |
| // |
| // /** |
| // * The logger to which we will write our logging output. |
| // */ |
| // private Logger logger; |
| // |
| // /** |
| // * The stack name. |
| // */ |
| // private String stackName; |
| // |
| // /** |
| // * Name of the log file in which the trace is written out (default is |
| // * /tmp/sipserverlog.txt) |
| // */ |
| // private String logFileName = null; |
| // |
| // /** |
| // * Flag to indicate that logging is enabled. |
| // */ |
| // private volatile boolean needsLogging = false; |
| // |
| // private int lineCount; |
| // |
| // /** |
| // * trace level |
| // */ |
| // |
| // protected int traceLevel = TRACE_NONE; |
| // |
| // private String buildTimeStamp; |
| // |
| // private Properties configurationProperties; |
| // |
| // /** |
| // * log a stack trace. This helps to look at the stack frame. |
| // */ |
| // public void logStackTrace() { |
| // this.logStackTrace(TRACE_DEBUG); |
| // |
| // } |
| // |
| // public void logStackTrace(int traceLevel) { |
| // if (needsLogging) { |
| // StringWriter sw = new StringWriter(); |
| // PrintWriter pw = new PrintWriter(sw); |
| // StackTraceElement[] ste = new Exception().getStackTrace(); |
| // // Skip the log writer frame and log all the other stack frames. |
| // for (int i = 1; i < ste.length; i++) { |
| // String callFrame = "[" + ste[i].getFileName() + ":" |
| // + ste[i].getLineNumber() + "]"; |
| // pw.print(callFrame); |
| // } |
| // pw.close(); |
| // String stackTrace = sw.getBuffer().toString(); |
| // Level level = this.getLevel(traceLevel); |
| // Priority priority = this.getLogPriority(); |
| // if ( level.isGreaterOrEqual(priority)) { |
| // logger.log(level,stackTrace); |
| // } |
| // |
| // } |
| // } |
| // |
| // /** |
| // * Get the line count in the log stream. |
| // * |
| // * @return |
| // */ |
| // public int getLineCount() { |
| // return lineCount; |
| // } |
| // |
| // /** |
| // * Get the logger. |
| // * |
| // * @return |
| // */ |
| // public Logger getLogger() { |
| // return logger; |
| // } |
| // |
| // |
| // /** |
| // * This method allows you to add an external appender. |
| // * This is useful for the case when you want to log to |
| // * a different log stream than a file. |
| // * |
| // * @param appender |
| // */ |
| // public void addAppender(Appender appender) { |
| // |
| // this.logger.addAppender(appender); |
| // |
| // } |
| // |
| // /** |
| // * Log an exception. |
| // * |
| // * @param ex |
| // */ |
| // public void logException(Throwable ex) { |
| // |
| // if (needsLogging) { |
| // |
| // this.getLogger().error(ex.getMessage(), ex); |
| // } |
| // } |
| // |
| // |
| // |
| // |
| // /** |
| // * Counts the line number so that the debug log can be correlated to the |
| // * message trace. |
| // * |
| // * @param message -- |
| // * message to count the lines for. |
| // */ |
| // private void countLines(String message) { |
| // char[] chars = message.toCharArray(); |
| // for (int i = 0; i < chars.length; i++) { |
| // if (chars[i] == '\n') |
| // lineCount++; |
| // } |
| // |
| // } |
| // |
| // /** |
| // * Prepend the line and file where this message originated from |
| // * |
| // * @param message |
| // * @return re-written message. |
| // */ |
| // private String enhanceMessage(String message) { |
| // |
| // StackTraceElement[] stackTrace = new Exception().getStackTrace(); |
| // StackTraceElement elem = stackTrace[2]; |
| // String className = elem.getClassName(); |
| // String methodName = elem.getMethodName(); |
| // String fileName = elem.getFileName(); |
| // int lineNumber = elem.getLineNumber(); |
| // String newMessage = className + "." + methodName + "(" + fileName + ":" |
| // + lineNumber + ") [" + message + "]"; |
| // return newMessage; |
| // |
| // } |
| // |
| // /** |
| // * Log a message into the log file. |
| // * |
| // * @param message |
| // * message to log into the log file. |
| // */ |
| // public void logDebug(String message) { |
| // if (needsLogging) { |
| // String newMessage = this.enhanceMessage(message); |
| // if ( this.lineCount == 0) { |
| // getLogger().debug("BUILD TIMESTAMP = " + this.buildTimeStamp); |
| // getLogger().debug("Config Propeties = " + this.configurationProperties); |
| // } |
| // countLines(newMessage); |
| // getLogger().debug(newMessage); |
| // } |
| // |
| // } |
| // |
| // /** |
| // * Log a message into the log file. |
| // * |
| // * @param message |
| // * message to log into the log file. |
| // */ |
| // public void logTrace(String message) { |
| // if (needsLogging) { |
| // String newMessage = this.enhanceMessage(message); |
| // if ( this.lineCount == 0) { |
| // getLogger().debug("BUILD TIMESTAMP = " + this.buildTimeStamp); |
| // getLogger().debug("Config Propeties = " + this.configurationProperties); |
| // } |
| // countLines(newMessage); |
| // getLogger().trace(newMessage); |
| // } |
| // |
| // } |
| // |
| // /** |
| // * Set the trace level for the stack. |
| // */ |
| // private void setTraceLevel(int level) { |
| // traceLevel = level; |
| // } |
| // |
| // /** |
| // * Get the trace level for the stack. |
| // */ |
| // public int getTraceLevel() { |
| // return traceLevel; |
| // } |
| // |
| // /** |
| // * Log an error message. |
| // * |
| // * @param message -- |
| // * error message to log. |
| // */ |
| // public void logFatalError(String message) { |
| // Logger logger = this.getLogger(); |
| // String newMsg = this.enhanceMessage(message); |
| // countLines(newMsg); |
| // logger.fatal(newMsg); |
| // |
| // } |
| // |
| // /** |
| // * Log an error message. |
| // * |
| // * @param message -- |
| // * error message to log. |
| // * |
| // */ |
| // public void logError(String message) { |
| // Logger logger = this.getLogger(); |
| // String newMsg = this.enhanceMessage(message); |
| // countLines(newMsg); |
| // logger.error(newMsg); |
| // |
| // } |
| // |
| // public LogWriter() { |
| // } |
| // |
| // public void setStackProperties(Properties configurationProperties) { |
| // |
| // this.configurationProperties = configurationProperties; |
| // |
| // String logLevel = configurationProperties |
| // .getProperty("gov.nist.javax.sip.TRACE_LEVEL"); |
| // |
| // this.logFileName = configurationProperties |
| // .getProperty("gov.nist.javax.sip.DEBUG_LOG"); |
| // |
| // this.stackName = configurationProperties |
| // .getProperty("javax.sip.STACK_NAME"); |
| // |
| // //check whether a Log4j logger name has been |
| // //specified. if not, use the stack name as the default |
| // //logger name. |
| // String category = configurationProperties |
| // .getProperty("gov.nist.javax.sip.LOG4J_LOGGER_NAME", this.stackName); |
| // |
| // |
| // logger = Logger.getLogger(category); |
| // if (logLevel != null) { |
| // if (logLevel.equals("LOG4J")) { |
| // //if TRACE_LEVEL property is specified as |
| // //"LOG4J" then, set the traceLevel based on |
| // //the log4j effective log level. |
| // Level level = logger.getEffectiveLevel(); |
| // this.needsLogging = true; |
| // if (level == Level.OFF) |
| // this.needsLogging = false; |
| // this.traceLevel = TRACE_NONE; |
| // if (level.isGreaterOrEqual(Level.DEBUG)) { |
| // this.traceLevel = TRACE_DEBUG; |
| // } else if (level.isGreaterOrEqual(Level.INFO)) { |
| // this.traceLevel = TRACE_INFO; |
| // } else if (level.isGreaterOrEqual(Level.WARN)) { |
| // this.traceLevel = TRACE_ERROR; |
| // } |
| // } |
| // else { |
| // try { |
| // int ll = 0; |
| // if (logLevel.equals("TRACE")) { |
| // ll = TRACE_DEBUG; |
| // Debug.debug = true; |
| // Debug.setStackLogger(this); |
| // } else if (logLevel.equals("DEBUG")) { |
| // ll = TRACE_DEBUG; |
| // } else if ( logLevel.equals("INFO")) { |
| // ll = TRACE_INFO; |
| // } else if (logLevel.equals("ERROR")) { |
| // ll = TRACE_ERROR; |
| // } else if (logLevel.equals("NONE") || logLevel.equals("OFF")) { |
| // ll = TRACE_NONE; |
| // } else { |
| // ll = Integer.parseInt(logLevel); |
| // if ( ll > 32 ) { |
| // Debug.debug = true; |
| // Debug.setStackLogger(this); |
| // } |
| // } |
| // |
| // this.setTraceLevel(ll); |
| // this.needsLogging = true; |
| // if (traceLevel == TRACE_DEBUG) { |
| // logger.setLevel(Level.DEBUG); |
| // } else if (traceLevel == TRACE_INFO) { |
| // logger.setLevel(Level.INFO); |
| // } else if (traceLevel == TRACE_ERROR) { |
| // logger.setLevel(Level.ERROR); |
| // } else if (traceLevel == TRACE_NONE) { |
| // logger.setLevel(Level.OFF); |
| // this.needsLogging = false; |
| // } |
| // |
| // /* |
| // * If user specifies a logging file as part of the startup |
| // * properties then we try to create the appender. |
| // */ |
| // if (this.needsLogging && this.logFileName != null) { |
| // |
| // boolean overwrite = Boolean.valueOf( |
| // configurationProperties.getProperty( |
| // "gov.nist.javax.sip.DEBUG_LOG_OVERWRITE")); |
| // |
| // FileAppender fa = null; |
| // try { |
| // fa = new FileAppender(new SimpleLayout(), |
| // this.logFileName, !overwrite); |
| // } catch (FileNotFoundException fnf) { |
| // |
| // // Likely due to some directoy not existing. Create |
| // // them |
| // File logfile = new File(this.logFileName); |
| // logfile.getParentFile().mkdirs(); |
| // logfile.delete(); |
| // |
| // try { |
| // fa = new FileAppender(new SimpleLayout(), |
| // this.logFileName); |
| // } catch (IOException ioe) { |
| // ioe.printStackTrace(); // give up |
| // } |
| // } catch (IOException ex) { |
| // ex.printStackTrace(); |
| // } |
| // |
| // if (fa != null) |
| // logger.addAppender(fa); |
| // } |
| // |
| // } catch (NumberFormatException ex) { |
| // ex.printStackTrace(); |
| // System.err.println("LogWriter: Bad integer " + logLevel); |
| // System.err.println("logging dislabled "); |
| // needsLogging = false; |
| // } |
| // } |
| // } else { |
| // this.needsLogging = false; |
| // |
| // } |
| // |
| // |
| // } |
| // |
| // /** |
| // * @return flag to indicate if logging is enabled. |
| // */ |
| // public boolean isLoggingEnabled() { |
| // |
| // return this.needsLogging; |
| // } |
| // |
| // /** |
| // * Return true/false if loging is enabled at a given level. |
| // * |
| // * @param logLevel |
| // */ |
| // public boolean isLoggingEnabled(int logLevel) { |
| // return this.needsLogging && logLevel <= traceLevel; |
| // } |
| // |
| // |
| // /** |
| // * Log an error message. |
| // * |
| // * @param message |
| // * @param ex |
| // */ |
| // public void logError(String message, Exception ex) { |
| // Logger logger = this.getLogger(); |
| // logger.error(message, ex); |
| // |
| // } |
| // |
| // /** |
| // * Log a warning mesasge. |
| // * |
| // * @param string |
| // */ |
| // public void logWarning(String string) { |
| // getLogger().warn(string); |
| // |
| // } |
| // |
| // /** |
| // * Log an info message. |
| // * |
| // * @param string |
| // */ |
| // public void logInfo(String string) { |
| // getLogger().info(string); |
| // } |
| // |
| // /** |
| // * Disable logging altogether. |
| // * |
| // */ |
| // public void disableLogging() { |
| // this.needsLogging = false; |
| // } |
| // |
| // /** |
| // * Enable logging (globally). |
| // */ |
| // public void enableLogging() { |
| // this.needsLogging = true; |
| // |
| // } |
| // |
| // public void setBuildTimeStamp(String buildTimeStamp) { |
| // this.buildTimeStamp = buildTimeStamp; |
| // |
| // } |
| // |
| // public Priority getLogPriority() { |
| // if ( this.traceLevel == TRACE_INFO ) { |
| // return Priority.INFO; |
| // } else if ( this.traceLevel == TRACE_ERROR ) { |
| // return Priority.ERROR; |
| // } else if ( this.traceLevel == TRACE_DEBUG) { |
| // return Priority.DEBUG; |
| // } else if ( this.traceLevel == TRACE_TRACE) { |
| // return Priority.DEBUG; |
| // } else { |
| // return Priority.FATAL; |
| // } |
| // } |
| // |
| // public Level getLevel(int traceLevel) { |
| // if ( traceLevel == TRACE_INFO ) { |
| // return Level.INFO; |
| // } else if ( traceLevel == TRACE_ERROR ) { |
| // return Level.ERROR; |
| // } else if ( traceLevel == TRACE_DEBUG) { |
| // return Level.DEBUG; |
| // } else if (traceLevel == TRACE_TRACE) { |
| // return Level.ALL; |
| // } else { |
| // return Level.OFF; |
| // } |
| // } |
| // |
| // public String getLoggerName() { |
| // if ( this.logger != null ) { |
| // return logger.getName(); |
| // } else { |
| // return null; |
| // } |
| // } |
| // |
| // |
| //} |
| |
| // END android-deleted |
