1/*
2 * Conditions Of Use
3 *
4 * This software was developed by employees of the National Institute of
5 * Standards and Technology (NIST), an agency of the Federal Government.
6 * Pursuant to title 15 Untied States Code Section 105, works of NIST
7 * employees are not subject to copyright protection in the United States
8 * and are considered to be in the public domain.  As a result, a formal
9 * license is not needed to use the software.
10 *
11 * This software is provided by NIST as a service and is expressly
12 * provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
13 * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
14 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
15 * AND DATA ACCURACY.  NIST does not warrant or make any representations
16 * regarding the use of the software or the results thereof, including but
17 * not limited to the correctness, accuracy, reliability or usefulness of
18 * the software.
19 *
20 * Permission to use this software is contingent upon your acceptance
21 * of the terms of this agreement.
22 *
23 */
24/***************************************************************************
25 * Product of NIST/ITL Advanced Networking Technologies Division (ANTD).    *
26 ***************************************************************************/
27package gov.nist.core;
28
29import java.io.*;
30import java.util.Properties;
31
32// BEGIN ANDROID-added
33// TODO: this class should be replaced by android logging mechanism.
34public class LogWriter implements StackLogger {
35    private static final String TAG = "SIP_STACK";
36
37    private boolean mEnabled = true;
38
39    public void logStackTrace() {
40        // TODO
41    }
42
43    public void logStackTrace(int traceLevel) {
44        // TODO
45    }
46
47    public int getLineCount() {
48        return 0;
49    }
50
51    public void logException(Throwable ex) {
52        //Log.e(TAG, "", ex);
53    }
54    public void logDebug(String message) {
55        //Log.d(TAG, message);
56    }
57    public void logTrace(String message) {
58        //Log.d(TAG, message);
59    }
60    public void logFatalError(String message) {
61        //Log.e(TAG, message);
62    }
63    public void logError(String message) {
64        //Log.e(TAG, message);
65    }
66    public boolean isLoggingEnabled() {
67        return mEnabled;
68    }
69    public boolean isLoggingEnabled(int logLevel) {
70        // TODO
71        return mEnabled;
72    }
73    public void logError(String message, Exception ex) {
74        //Log.e(TAG, message, ex);
75    }
76    public void logWarning(String string) {
77        //Log.w(TAG, string);
78    }
79    public void logInfo(String string) {
80        //Log.i(TAG, string);
81    }
82
83    public void disableLogging() {
84        mEnabled = false;
85    }
86
87    public void enableLogging() {
88        mEnabled = true;
89    }
90
91    public void setBuildTimeStamp(String buildTimeStamp) {
92    }
93
94    public void setStackProperties(Properties stackProperties) {
95    }
96
97    public String getLoggerName() {
98        return "Android SIP Logger";
99    }
100}
101// END android-added
102
103// BEGIN android-deleted
104
105//import org.apache.log4j.Appender;
106//import org.apache.log4j.FileAppender;
107//import org.apache.log4j.Level;
108//import org.apache.log4j.Logger;
109//import org.apache.log4j.Priority;
110//import org.apache.log4j.SimpleLayout;
111//
112///**
113// * A wrapper around log4j that is used for logging debug and errors. You can
114// * replace this file if you want to change the way in which messages are logged.
115// *
116// * @version 1.2
117// *
118// * @author M. Ranganathan <br/>
119// * @author M.Andrews
120// * @author Jeroen van Bemmel
121// * @author Jean Deruelle
122// *
123// */
124//
125//public class LogWriter implements StackLogger {
126//
127//    /**
128//     * The logger to which we will write our logging output.
129//     */
130//    private Logger logger;
131//
132//    /**
133//     * The stack name.
134//     */
135//    private String stackName;
136//
137//    /**
138//     * Name of the log file in which the trace is written out (default is
139//     * /tmp/sipserverlog.txt)
140//     */
141//    private String logFileName = null;
142//
143//    /**
144//     * Flag to indicate that logging is enabled.
145//     */
146//    private volatile boolean needsLogging = false;
147//
148//    private int lineCount;
149//
150//    /**
151//     * trace level
152//     */
153//
154//    protected int traceLevel = TRACE_NONE;
155//
156//    private String buildTimeStamp;
157//
158//    private Properties configurationProperties;
159//
160//    /**
161//     * log a stack trace. This helps to look at the stack frame.
162//     */
163//    public void logStackTrace() {
164//        this.logStackTrace(TRACE_DEBUG);
165//
166//    }
167//
168//    public void logStackTrace(int traceLevel) {
169//        if (needsLogging) {
170//            StringWriter sw = new StringWriter();
171//            PrintWriter pw = new PrintWriter(sw);
172//            StackTraceElement[] ste = new Exception().getStackTrace();
173//            // Skip the log writer frame and log all the other stack frames.
174//            for (int i = 1; i < ste.length; i++) {
175//                String callFrame = "[" + ste[i].getFileName() + ":"
176//                        + ste[i].getLineNumber() + "]";
177//                pw.print(callFrame);
178//            }
179//            pw.close();
180//            String stackTrace = sw.getBuffer().toString();
181//            Level level = this.getLevel(traceLevel);
182//            Priority priority = this.getLogPriority();
183//            if ( level.isGreaterOrEqual(priority)) {
184//                logger.log(level,stackTrace);
185//            }
186//
187//        }
188//    }
189//
190//    /**
191//     * Get the line count in the log stream.
192//     *
193//     * @return
194//     */
195//    public int getLineCount() {
196//        return lineCount;
197//    }
198//
199//    /**
200//     * Get the logger.
201//     *
202//     * @return
203//     */
204//    public Logger getLogger() {
205//        return logger;
206//    }
207//
208//
209//    /**
210//     * This method allows you to add an external appender.
211//     * This is useful for the case when you want to log to
212//     * a different log stream than a file.
213//     *
214//     * @param appender
215//     */
216//    public void addAppender(Appender appender) {
217//
218//        this.logger.addAppender(appender);
219//
220//    }
221//
222//    /**
223//     * Log an exception.
224//     *
225//     * @param ex
226//     */
227//    public void logException(Throwable ex) {
228//
229//        if (needsLogging) {
230//
231//            this.getLogger().error(ex.getMessage(), ex);
232//        }
233//    }
234//
235//
236//
237//
238//    /**
239//     * Counts the line number so that the debug log can be correlated to the
240//     * message trace.
241//     *
242//     * @param message --
243//     *            message to count the lines for.
244//     */
245//    private void countLines(String message) {
246//        char[] chars = message.toCharArray();
247//        for (int i = 0; i < chars.length; i++) {
248//            if (chars[i] == '\n')
249//                lineCount++;
250//        }
251//
252//    }
253//
254//    /**
255//     * Prepend the line and file where this message originated from
256//     *
257//     * @param message
258//     * @return re-written message.
259//     */
260//    private String enhanceMessage(String message) {
261//
262//        StackTraceElement[] stackTrace = new Exception().getStackTrace();
263//        StackTraceElement elem = stackTrace[2];
264//        String className = elem.getClassName();
265//        String methodName = elem.getMethodName();
266//        String fileName = elem.getFileName();
267//        int lineNumber = elem.getLineNumber();
268//        String newMessage = className + "." + methodName + "(" + fileName + ":"
269//                + lineNumber + ") [" + message + "]";
270//        return newMessage;
271//
272//    }
273//
274//    /**
275//     * Log a message into the log file.
276//     *
277//     * @param message
278//     *            message to log into the log file.
279//     */
280//    public void logDebug(String message) {
281//        if (needsLogging) {
282//            String newMessage = this.enhanceMessage(message);
283//            if ( this.lineCount == 0) {
284//                getLogger().debug("BUILD TIMESTAMP = " + this.buildTimeStamp);
285//                getLogger().debug("Config Propeties = " + this.configurationProperties);
286//            }
287//            countLines(newMessage);
288//            getLogger().debug(newMessage);
289//        }
290//
291//    }
292//
293//    /**
294//     * Log a message into the log file.
295//     *
296//     * @param message
297//     *            message to log into the log file.
298//     */
299//    public void logTrace(String message) {
300//        if (needsLogging) {
301//            String newMessage = this.enhanceMessage(message);
302//            if ( this.lineCount == 0) {
303//                getLogger().debug("BUILD TIMESTAMP = " + this.buildTimeStamp);
304//                getLogger().debug("Config Propeties = " + this.configurationProperties);
305//            }
306//            countLines(newMessage);
307//            getLogger().trace(newMessage);
308//        }
309//
310//    }
311//
312//    /**
313//     * Set the trace level for the stack.
314//     */
315//    private void setTraceLevel(int level) {
316//        traceLevel = level;
317//    }
318//
319//    /**
320//     * Get the trace level for the stack.
321//     */
322//    public int getTraceLevel() {
323//        return traceLevel;
324//    }
325//
326//    /**
327//     * Log an error message.
328//     *
329//     * @param message --
330//     *            error message to log.
331//     */
332//    public void logFatalError(String message) {
333//        Logger logger = this.getLogger();
334//        String newMsg = this.enhanceMessage(message);
335//        countLines(newMsg);
336//        logger.fatal(newMsg);
337//
338//    }
339//
340//    /**
341//     * Log an error message.
342//     *
343//     * @param message --
344//     *            error message to log.
345//     *
346//     */
347//    public void logError(String message) {
348//        Logger logger = this.getLogger();
349//        String newMsg = this.enhanceMessage(message);
350//        countLines(newMsg);
351//        logger.error(newMsg);
352//
353//    }
354//
355//    public LogWriter() {
356//    }
357//
358//	public void setStackProperties(Properties configurationProperties) {
359//
360//        this.configurationProperties = configurationProperties;
361//
362//        String logLevel = configurationProperties
363//                .getProperty("gov.nist.javax.sip.TRACE_LEVEL");
364//
365//        this.logFileName = configurationProperties
366//                .getProperty("gov.nist.javax.sip.DEBUG_LOG");
367//
368//        this.stackName = configurationProperties
369//                .getProperty("javax.sip.STACK_NAME");
370//
371//        //check whether a Log4j logger name has been
372//        //specified. if not, use the stack name as the default
373//        //logger name.
374//        String category = configurationProperties
375//                                .getProperty("gov.nist.javax.sip.LOG4J_LOGGER_NAME", this.stackName);
376//
377//
378//        logger = Logger.getLogger(category);
379//        if (logLevel != null) {
380//            if (logLevel.equals("LOG4J")) {
381//                //if TRACE_LEVEL property is specified as
382//                //"LOG4J" then, set the traceLevel based on
383//                //the log4j effective log level.
384//                Level level = logger.getEffectiveLevel();
385//                this.needsLogging = true;
386//                if (level == Level.OFF)
387//                    this.needsLogging = false;
388//                this.traceLevel = TRACE_NONE;
389//                if (level.isGreaterOrEqual(Level.DEBUG)) {
390//                    this.traceLevel = TRACE_DEBUG;
391//                } else if (level.isGreaterOrEqual(Level.INFO)) {
392//                    this.traceLevel = TRACE_INFO;
393//                } else if (level.isGreaterOrEqual(Level.WARN)) {
394//                    this.traceLevel = TRACE_ERROR;
395//                }
396//            }
397//            else {
398//                try {
399//                    int ll = 0;
400//                    if (logLevel.equals("TRACE")) {
401//                        ll = TRACE_DEBUG;
402//                        Debug.debug = true;
403//                        Debug.setStackLogger(this);
404//                    } else if (logLevel.equals("DEBUG")) {
405//                        ll = TRACE_DEBUG;
406//                    } else if ( logLevel.equals("INFO")) {
407//                        ll = TRACE_INFO;
408//                    } else if (logLevel.equals("ERROR")) {
409//                        ll = TRACE_ERROR;
410//                    } else if (logLevel.equals("NONE") || logLevel.equals("OFF")) {
411//                        ll = TRACE_NONE;
412//                    } else {
413//                        ll = Integer.parseInt(logLevel);
414//                        if ( ll > 32 ) {
415//                            Debug.debug = true;
416//                            Debug.setStackLogger(this);
417//                        }
418//                    }
419//
420//                    this.setTraceLevel(ll);
421//                    this.needsLogging = true;
422//                    if (traceLevel == TRACE_DEBUG) {
423//                        logger.setLevel(Level.DEBUG);
424//                    } else if (traceLevel == TRACE_INFO) {
425//                        logger.setLevel(Level.INFO);
426//                    } else if (traceLevel == TRACE_ERROR) {
427//                        logger.setLevel(Level.ERROR);
428//                    } else if (traceLevel == TRACE_NONE) {
429//                        logger.setLevel(Level.OFF);
430//                        this.needsLogging = false;
431//                    }
432//
433//                    /*
434//                     * If user specifies a logging file as part of the startup
435//                     * properties then we try to create the appender.
436//                     */
437//                    if (this.needsLogging && this.logFileName != null) {
438//
439//                        boolean overwrite = Boolean.valueOf(
440//                                configurationProperties.getProperty(
441//                                "gov.nist.javax.sip.DEBUG_LOG_OVERWRITE"));
442//
443//                        FileAppender fa = null;
444//                        try {
445//                            fa = new FileAppender(new SimpleLayout(),
446//                                    this.logFileName, !overwrite);
447//                        } catch (FileNotFoundException fnf) {
448//
449//                            // Likely due to some directoy not existing. Create
450//                            // them
451//                            File logfile = new File(this.logFileName);
452//                            logfile.getParentFile().mkdirs();
453//                            logfile.delete();
454//
455//                            try {
456//                                fa = new FileAppender(new SimpleLayout(),
457//                                        this.logFileName);
458//                            } catch (IOException ioe) {
459//                                ioe.printStackTrace(); // give up
460//                            }
461//                        } catch (IOException ex) {
462//                            ex.printStackTrace();
463//                        }
464//
465//                        if (fa != null)
466//                            logger.addAppender(fa);
467//                    }
468//
469//                } catch (NumberFormatException ex) {
470//                    ex.printStackTrace();
471//                    System.err.println("LogWriter: Bad integer " + logLevel);
472//                    System.err.println("logging dislabled ");
473//                    needsLogging = false;
474//                }
475//            }
476//        } else {
477//            this.needsLogging = false;
478//
479//        }
480//
481//
482//    }
483//
484//    /**
485//     * @return flag to indicate if logging is enabled.
486//     */
487//    public boolean isLoggingEnabled() {
488//
489//        return this.needsLogging;
490//    }
491//
492//    /**
493//     * Return true/false if loging is enabled at a given level.
494//     *
495//     * @param logLevel
496//     */
497//    public boolean isLoggingEnabled(int logLevel) {
498//        return this.needsLogging && logLevel <= traceLevel;
499//    }
500//
501//
502//    /**
503//     * Log an error message.
504//     *
505//     * @param message
506//     * @param ex
507//     */
508//    public void logError(String message, Exception ex) {
509//        Logger logger = this.getLogger();
510//        logger.error(message, ex);
511//
512//    }
513//
514//    /**
515//     * Log a warning mesasge.
516//     *
517//     * @param string
518//     */
519//    public void logWarning(String string) {
520//        getLogger().warn(string);
521//
522//    }
523//
524//    /**
525//     * Log an info message.
526//     *
527//     * @param string
528//     */
529//    public void logInfo(String string) {
530//        getLogger().info(string);
531//    }
532//
533//    /**
534//     * Disable logging altogether.
535//     *
536//     */
537//    public void disableLogging() {
538//        this.needsLogging = false;
539//    }
540//
541//    /**
542//     * Enable logging (globally).
543//     */
544//    public void enableLogging() {
545//        this.needsLogging = true;
546//
547//    }
548//
549//    public void setBuildTimeStamp(String buildTimeStamp) {
550//        this.buildTimeStamp = buildTimeStamp;
551//
552//    }
553//
554//    public Priority getLogPriority() {
555//         if ( this.traceLevel == TRACE_INFO ) {
556//            return Priority.INFO;
557//        } else if ( this.traceLevel == TRACE_ERROR ) {
558//            return Priority.ERROR;
559//        } else if ( this.traceLevel == TRACE_DEBUG) {
560//            return Priority.DEBUG;
561//        } else if ( this.traceLevel == TRACE_TRACE) {
562//            return Priority.DEBUG;
563//        } else {
564//            return Priority.FATAL;
565//        }
566//    }
567//
568//    public Level getLevel(int traceLevel) {
569//        if ( traceLevel == TRACE_INFO ) {
570//           return Level.INFO;
571//       } else if ( traceLevel == TRACE_ERROR ) {
572//           return Level.ERROR;
573//       } else if ( traceLevel == TRACE_DEBUG) {
574//           return Level.DEBUG;
575//       } else if (traceLevel == TRACE_TRACE) {
576//           return Level.ALL;
577//       } else {
578//           return Level.OFF;
579//       }
580//   }
581//
582//	public String getLoggerName() {
583//	    if ( this.logger != null ) {
584//	        return logger.getName();
585//	    } else {
586//	        return null;
587//	    }
588//	}
589//
590//
591//}
592
593// END android-deleted
594