1 /*
   2  * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include "util.h"
  27 
  28 #include <time.h>
  29 #include <errno.h>
  30 #include <sys/types.h>
  31 
  32 #include "proc_md.h"
  33 
  34 #include "log_messages.h"
  35 
  36 #ifdef JDWP_LOGGING
  37 
  38 #define MAXLEN_INTEGER          20
  39 #define MAXLEN_FILENAME         256
  40 #define MAXLEN_TIMESTAMP        80
  41 #define MAXLEN_LOCATION         (MAXLEN_FILENAME+MAXLEN_INTEGER+16)
  42 #define MAXLEN_MESSAGE          256
  43 #define MAXLEN_EXEC             (MAXLEN_FILENAME*2+MAXLEN_INTEGER+16)
  44 
  45 static MUTEX_T my_mutex = MUTEX_INIT;
  46 
  47 /* Static variables (should be protected with mutex) */
  48 static int logging;
  49 static FILE * log_file;
  50 static char logging_filename[MAXLEN_FILENAME+1+6];
  51 static char location_stamp[MAXLEN_LOCATION+1];
  52 static PID_T processPid;
  53 static int open_count;
  54 
  55 /* Ascii id of current native thread. */
  56 static void
  57 get_time_stamp(char *tbuf, size_t ltbuf)
  58 {
  59     char format[MAXLEN_TIMESTAMP+1];
  60     unsigned millisecs = 0;
  61     time_t t = 0;
  62 
  63     GETMILLSECS(millisecs);
  64     if ( time(&t) == (time_t)(-1) )
  65         t = 0;
  66     (void)strftime(format, sizeof(format),
  67                 /* Break this string up for SCCS's sake */
  68                 "%" "d.%" "m.%" "Y %" "T.%%.3d %" "Z", localtime(&t));
  69     (void)snprintf(tbuf, ltbuf, format, (int)(millisecs));
  70 }
  71 
  72 /* Get basename of filename */
  73 static const char *
  74 file_basename(const char *file)
  75 {
  76     char *p1;
  77     char *p2;
  78 
  79     if ( file==NULL )
  80         return "unknown";
  81     p1 = strrchr(file, '\\');
  82     p2 = strrchr(file, '/');
  83     p1 = ((p1 > p2) ? p1 : p2);
  84     if (p1 != NULL) {
  85         file = p1 + 1;
  86     }
  87     return file;
  88 }
  89 
  90 /* Fill in the exact source location of the LOG entry. */
  91 static void
  92 fill_location_stamp(const char *flavor, const char *file, int line)
  93 {
  94     (void)snprintf(location_stamp, sizeof(location_stamp),
  95                     "%s:\"%s\":%d;",
  96                     flavor, file_basename(file), line);
  97     location_stamp[sizeof(location_stamp)-1] = 0;
  98 }
  99 
 100 /* Begin a log entry. */
 101 void
 102 log_message_begin(const char *flavor, const char *file, int line)
 103 {
 104     MUTEX_LOCK(my_mutex); /* Unlocked in log_message_end() */
 105     if ( logging ) {
 106         location_stamp[0] = 0;
 107         fill_location_stamp(flavor, file, line);
 108     }
 109 }
 110 
 111 /* Standard Logging Format Entry */
 112 static void
 113 standard_logging_format(FILE *fp,
 114         const char *datetime,
 115         const char *level,
 116         const char *product,
 117         const char *module,
 118         const char *optional,
 119         const char *messageID,
 120         const char *message)
 121 {
 122     const char *format;
 123 
 124     /* "[#|Date&Time&Zone|LogLevel|ProductName|ModuleID|
 125      *     OptionalKey1=Value1;OptionalKeyN=ValueN|MessageID:MessageText|#]\n"
 126      */
 127 
 128     format="[#|%s|%s|%s|%s|%s|%s:%s|#]\n";
 129 
 130     print_message(fp, "", "", format,
 131             datetime,
 132             level,
 133             product,
 134             module,
 135             optional,
 136             messageID,
 137             message);
 138 }
 139 
 140 /* End a log entry */
 141 void
 142 log_message_end(const char *format, ...)
 143 {
 144     if ( logging ) {
 145         va_list ap;
 146         THREAD_T tid;
 147         char datetime[MAXLEN_TIMESTAMP+1];
 148         const char *level;
 149         const char *product;
 150         const char *module;
 151         char optional[MAXLEN_INTEGER+6+MAXLEN_INTEGER+6+MAXLEN_LOCATION+1];
 152         const char *messageID;
 153         char message[MAXLEN_MESSAGE+1];
 154 
 155         /* Grab the location, start file if needed, and clear the lock */
 156         if ( log_file == NULL && open_count == 0 && logging_filename[0] != 0 ) {
 157             open_count++;
 158             log_file = fopen(logging_filename, "w");
 159             if ( log_file!=NULL ) {
 160                 (void)setvbuf(log_file, NULL, _IOLBF, BUFSIZ);
 161             } else {
 162                 logging = 0;
 163             }
 164         }
 165 
 166         if ( log_file != NULL ) {
 167 
 168             /* Get the rest of the needed information */
 169             tid = GET_THREAD_ID();
 170             level = "FINEST"; /* FIXUP? */
 171             product = "J2SE1.5"; /* FIXUP? */
 172             module = "jdwp"; /* FIXUP? */
 173             messageID = ""; /* FIXUP: Unique message string ID? */
 174             (void)snprintf(optional, sizeof(optional),
 175                         "LOC=%s;PID=%d;THR=t@%d",
 176                         location_stamp,
 177                         (int)processPid,
 178                         (int)tid);
 179 
 180             /* Construct message string. */
 181             va_start(ap, format);
 182             (void)vsnprintf(message, sizeof(message), format, ap);
 183             va_end(ap);
 184 
 185             get_time_stamp(datetime, sizeof(datetime));
 186 
 187             /* Send out standard logging format message */
 188             standard_logging_format(log_file,
 189                 datetime,
 190                 level,
 191                 product,
 192                 module,
 193                 optional,
 194                 messageID,
 195                 message);
 196         }
 197         location_stamp[0] = 0;
 198     }
 199     MUTEX_UNLOCK(my_mutex); /* Locked in log_message_begin() */
 200 }
 201 
 202 #endif
 203 
 204 /* Set up the logging with the name of a logging file. */
 205 void
 206 setup_logging(const char *filename, unsigned flags)
 207 {
 208 #ifdef JDWP_LOGGING
 209     FILE *fp = NULL;
 210 
 211     /* Turn off logging */
 212     logging = 0;
 213     gdata->log_flags = 0;
 214 
 215     /* Just return if not doing logging */
 216     if ( filename==NULL || flags==0 )
 217         return;
 218 
 219     /* Create potential filename for logging */
 220     processPid = GETPID();
 221     (void)snprintf(logging_filename, sizeof(logging_filename),
 222                     "%s.%d", filename, (int)processPid);
 223 
 224     /* Turn on logging (do this last) */
 225     logging = 1;
 226     gdata->log_flags = flags;
 227 
 228 #endif
 229 }
 230 
 231 /* Finish up logging, flush output to the logfile. */
 232 void
 233 finish_logging()
 234 {
 235 #ifdef JDWP_LOGGING
 236     MUTEX_LOCK(my_mutex);
 237     if ( logging ) {
 238         logging = 0;
 239         if ( log_file != NULL ) {
 240             (void)fflush(log_file);
 241             (void)fclose(log_file);
 242             log_file = NULL;
 243         }
 244     }
 245     MUTEX_UNLOCK(my_mutex);
 246 #endif
 247 }