开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
SBlogListeners.cpp
资源名称：openvxi-3.4.zip　[点击查看]
上传用户：xqtpzdz
上传日期：2022-05-21
资源大小：1764k
文件大小：45k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

SBlogListeners.cpp：源码内容
  2. /****************License************************************************
  3.  * Vocalocity OpenVXI
  4.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *  
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  19.  * registered trademarks of Vocalocity, Inc. 
  20.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  21.  * by Vocalocity.
  22.  ***********************************************************************/
  24. // -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8
  26. #define SBLOGLISTENERS_EXPORTS
  27. #include "SBlogListeners.h"
  29. #include <wchar.h>
  30. #include <stdio.h>
  31. #include <stdlib.h>
  32. #include <string>                // for STL string and wstring
  33. #include <sstream>               // for STL basic_ostringstream( )
  34. #include <limits.h>
  35. #include <cerrno>                // For errno to report fopen( ) errors
  37. #include <SBlog.h>
  38. #include <VXItrd.h>
  39. #include <VXItypes.h>
  40. #include <SBlogMapper.h>
  42. #include "SBlogOSUtils.h"
  44. #ifdef WIN32
  45. namespace std { };
  46. using namespace std;
  47. #define localtime_r(clock, result) 
  48.         ((result)->tm_sec = 0, localtime(clock))
  49. #endif
  51. static const VXIunsigned MAX_LOG_BUFFER  = 4096;
  52. #ifndef MAX_PATH
  53. #define MAX_PATH        1024
  54. #endif
  56. #define SBLOG_ERR_OUT_OF_MEMORY 100, L"SBlogListeners: Out of memory", NULL
  57. #define SBLOG_ERR_MUTEX_CREATE 101, L"SBlogListeners: Mutex create failed", NULL
  58. #define SBLOG_ERR_MUTEX_LOCK 102, L"SBlogListeners: Mutex lock failed", NULL
  59. #define SBLOG_ERR_MUTEX_UNLOCK 103, L"SBlogListeners: Mutex unlock failed", NULL
  60. #define SBLOG_ERR_ALREADY_INITIALIZED 104, L"SBlogListeners: Not initialized", NULL
  61. #define SBLOG_ERR_NOT_INITIALIZED 105, L"SBlogListeners: Not initialized", NULL
  63. #ifndef MODULE_PREFIX
  64. #define MODULE_PREFIX  COMPANY_DOMAIN L"."
  65. #endif
  66. #define MODULE_NAME MODULE_PREFIX     L"SBlog"
  69. static VXIbool gblLogPerformanceCounter = TRUE;
  71. /**********************************************************************/
  72. // Internal class definitions
  73. /**********************************************************************/
  74. static const VXIchar KEY_SEP     = L'=';
  75. static const char    N_KEY_SEP   =  '=';
  76. static const VXIchar ENTRY_SEP   = L'|';
  77. static const char    N_ENTRY_SEP =  '|';
  78. static const VXIchar ESCAPE      = L'\';
  79. static const char    N_ESCAPE    =  '\';
  81. class SBlogLogEntry{
  82. public:
  83.   enum LogEscapes {
  84.     ESCAPES_NONE,
  85.     ESCAPES_STANDARD,
  86.     ESCAPES_OSR_EVNT_LOG,
  87.   };
  89. public:
  90.   SBlogLogEntry(LogEscapes escapes = ESCAPES_STANDARD);
  91.   SBlogLogEntry(time_t, VXIunsigned);
  92.   ~SBlogLogEntry() {}
  94.   void SetEscapes(LogEscapes escapes) { escapes_ = escapes; }
  96.   VXIlogResult Append(const VXIchar*, VXIunsigned n);
  97.   VXIlogResult Append(const VXIVector *keys,
  98.           const VXIVector *values);
  100.   void operator+= (const VXIchar *val) { Append(val, 0); }
  101.   void operator+= (const VXIchar val) {
  102.     if (cur_size_ < MAX_LOG_BUFFER) {
  103.       entry_[cur_size_++] =  val;
  104.     }
  105.     entry_[cur_size_]=L'';
  106.     return ;
  107.   }
  108.   void operator+= (const char*);
  109.   void operator+= (long int);
  110.   void operator+= (VXIint32);
  111.   void operator+= (VXIunsigned);
  112.   void operator+= (VXIflt32);
  113.   void operator+= (VXIptr);
  114.   void operator+= (const VXIValue *);
  115.   void operator+= (VXIulong);
  116.   void operator+= (VXIflt64);
  118.   void AddKeySep() {
  119.     (*this) += KEY_SEP;
  120.   }
  121.   void AddEntrySep() {
  122.     (*this) += ENTRY_SEP;
  123.   }
  125.   void Terminate(bool addCpuTimes = true, bool addNewline = true);
  127.   const wchar_t *Entry()const {return entry_;}
  128.   
  129.   VXIunsigned size() const {
  130.     return cur_size_;
  131.   }
  133. protected:
  134.   LogEscapes escapes_;
  135.   unsigned int cur_size_;
  136.   wchar_t entry_[MAX_LOG_BUFFER+1];
  137. };
  140. class SBlogLogStream {
  141. private:
  142.   enum LogFormat {
  143.     FORMAT_TEXT_LATIN1 = 0,
  144.     FORMAT_TEXT_UTF8
  145.   };
  147. public:
  148.   SBlogLogStream();
  149.   virtual ~SBlogLogStream() {}
  150.   VXIlogResult Init(const VXIchar   *filename,
  151.         const VXIchar   *fileMimeType,
  152.         VXIint32         maxLogSizeBytes,
  153.         const VXIchar   *logContentDir,
  154.         VXIint32         maxContentDirSize,
  155.         VXIbool          logToStdout,
  156.         VXIbool          keepLogFileOpen,
  157.         VXIbool          reportErrorText,
  158.         const VXIVector *errorMapFiles);
  159.   VXIlogResult ShutDown();
  160.   VXIlogResult WriteEntry(const SBlogLogEntry& entry, 
  161.         VXIbool logToStdout = TRUE);
  162.   VXIlogResult CheckOpen();
  163.   VXIlogResult Open(VXIunsigned nextblock_size);
  164.   VXIlogResult Close();
  165.   VXIbool Enabled() {
  166.     if ((logfilename_ == NULL) && (! logToStdout_))
  167.       return FALSE;
  168.     return TRUE;
  169.   }
  170.   VXIbool ReportErrorText( ) { return reportErrorText_; }
  171.   const VXIchar *GetErrorText(VXIunsigned errorID, const VXIchar *moduleName,
  172.             const VXIchar **severity);
  173.   const VXIchar *GetContentDir(void) const { return logContentDir_; }
  174.   const char *GetNContentDir(void) const { return narrowLogContentDir_; }
  175.   const VXIint32 GetContentDirMaxSize(void) const { return maxContentDirSize_;}
  177.   // ----- Internal error logging functions
  178.   static VXIlogResult GlobalError(VXIunsigned errorID, 
  179.           const VXIchar *errorIDText,
  180.           const VXIchar *format, ...);
  182. protected:
  183.   VXItrdResult Lock() { 
  184.     VXItrdResult rc = VXItrdMutexLock(loglock_);
  185.     if (rc != VXItrd_RESULT_SUCCESS) GlobalError(SBLOG_ERR_MUTEX_LOCK);
  186.     return rc;
  187.   }
  188.   VXItrdResult Unlock() { 
  189.     VXItrdResult rc = VXItrdMutexUnlock(loglock_); 
  190.     if (rc != VXItrd_RESULT_SUCCESS) GlobalError(SBLOG_ERR_MUTEX_UNLOCK);
  191.     return rc;
  192.   }
  194. private:
  195.   SBlogErrorMapper *errorMapper_;
  196.   VXIchar *logfilename_;
  197.   VXIchar *logContentDir_;
  198.   char narrowlogfilename_[MAX_PATH];
  199.   char narrowLogContentDir_[MAX_PATH];
  200.   FILE *logFp_;
  201.   VXIint32 currentSize_;
  202.   VXIint32 maxLogSizeBytes_;
  203.   VXIint32 maxContentDirSize_;
  204.   LogFormat logFormat_;
  205.   VXIbool logToStdout_;
  206.   VXIbool keepLogFileOpen_;
  207.   VXIbool reportErrorText_;
  208.   VXItrdMutex *loglock_;
  209.   VXItrdMutex *internalErrorLoggingLock_;
  210.   VXIthreadID internalErrorLoggingThread_;
  211. };
  213. // ContentStream class
  214. class SBlogContentStream : public SBlogStream {
  215. public:
  216.   static const char PATH_SEPARATOR;
  218. public:
  219.   SBlogContentStream();
  220.   virtual ~SBlogContentStream();
  222.   VXIlogResult Open(const VXIchar *moduleName, 
  223.         const VXIchar *contentType,
  224.         const char *baseDir,
  225.         VXIint channel);
  227.   const VXIchar *GetPath(void) const { return wpath_.c_str(); }
  228.     
  229. private:
  230.   static VXIlogResult CallClose(struct SBlogStream  **stream);
  231.   static VXIlogResult CallWrite(struct SBlogStream *stream, 
  232.         const VXIbyte *buffer,
  233.         VXIulong buflen,
  234.         VXIulong *nwritten);
  235.   
  236.   VXIlogResult Close(void);
  237.   VXIlogResult Write(const VXIbyte *buffer, VXIulong buflen,
  238.          VXIulong *nwritten);
  240.   VXIlogResult CreatePath(const VXIchar *moduleName, 
  241.         const VXIchar *contentType,
  242.         const char *baseDir,
  243.         VXIint channel);
  244.   VXIlogResult CreateDirectories(void);
  246. private:
  247.   FILE *fp_;
  248.   std::string::size_type baseDirLen_;
  249.   std::string npath_;
  250.   std::basic_string<wchar_t> wpath_;
  251. };
  253. // define class static member
  254. #ifdef WIN32
  255. const char SBlogContentStream::PATH_SEPARATOR = '\';
  256. #else
  257. const char SBlogContentStream::PATH_SEPARATOR = '/';
  258. #endif
  260. // return file extension based on the given mine type
  261. // if the mine type is not recognized, no extension is generated.
  262. static const char* GetExtension(const VXIchar *mimetype)
  263. {
  264.   static const char EXT_ALAW[] = ".alaw";
  265.   static const char EXT_TXT[]  = ".txt";
  266.   static const char EXT_ULAW[] = ".ulaw";
  267.   static const char EXT_VOX[]  = ".vox";
  268.   static const char EXT_WAV[]  = ".wav";
  269.   static const char EXT_XML[]  = ".xml";
  270.   static const char EXT_VXML[] = ".vxml";
  271.   static const char EXT_L8[]   = ".L8";
  272.   static const char EXT_L16[]  = ".L16";
  273.   static const char EXT_UNKNOWN[] = "";
  275.   if (wcscmp(VXI_MIME_TEXT, mimetype) == 0 ||
  276.       wcscmp(VXI_MIME_UNICODE_TEXT, mimetype) == 0 ||
  277.       wcscmp(VXI_MIME_UTF16_TEXT, mimetype) == 0)
  278.   {
  279.     return EXT_TXT;
  280.   }
  281.   else if (wcscmp(VXI_MIME_XML, mimetype) == 0 ||
  282.      wcscmp(VXI_MIME_SSML, mimetype) == 0 ||
  283.      wcscmp(VXI_MIME_SRGS, mimetype) == 0)
  284.   {
  285.     return EXT_XML;
  286.   }
  287.   else if (wcscmp(VXI_MIME_VXML, mimetype) == 0)
  288.   {
  289.     return EXT_VXML;
  290.   }
  291.   else if (wcscmp(VXI_MIME_ALAW, mimetype) == 0)
  292.   {
  293.     return EXT_ALAW;
  294.   }
  295.   else if (wcscmp(VXI_MIME_WAV, mimetype) == 0) 
  296.   {
  297.     return EXT_WAV;
  298.   }
  299.   else if (wcscmp(VXI_MIME_LINEAR, mimetype) == 0)
  300.   {
  301.     return EXT_L8;
  302.   }
  303.   else if (wcscmp(VXI_MIME_LINEAR_16, mimetype) == 0 ||
  304.      wcscmp(VXI_MIME_LINEAR_16_16KHZ, mimetype) == 0)
  305.   {
  306.     return EXT_L16;
  307.   }
  308.   else if (wcscmp(VXI_MIME_ULAW, mimetype) == 0)
  309.   {
  310.     return EXT_ULAW;
  311.   }
  312.   else if (wcscmp(VXI_MIME_VOX, mimetype) == 0)
  313.   {
  314.     return EXT_VOX;
  315.   }
  316.   else
  317.   {
  318.     return EXT_UNKNOWN;  
  319.   }
  320. }
  322. /**********************************************************************/
  323. // SBlogContentStream class implementation
  324. /**********************************************************************/
  325. // c'tor
  326. SBlogContentStream::SBlogContentStream() : 
  327.   SBlogStream(), fp_(NULL), baseDirLen_(0), npath_(), wpath_()
  328. {
  329.   SBlogStream::Close = CallClose;
  330.   SBlogStream::Write = CallWrite;
  331. }
  333. // d'tor
  334. SBlogContentStream::~SBlogContentStream()
  335. {
  336.   if (fp_)
  337.     fclose(fp_);
  338. }
  340. // create path
  341. VXIlogResult SBlogContentStream::CreatePath(const VXIchar *moduleName, 
  342.               const VXIchar *contentType,
  343.               const char *baseDir,
  344.               VXIint channel)
  345. {
  346.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  348.   // Create the content path, with the file name based on a timestamp
  349.   // to millisecond granularity
  350.   std::basic_ostringstream<char> pathStream;
  351.   if (( baseDir ) && ( *baseDir )) {
  352.     baseDirLen_ = strlen (baseDir);
  353.     pathStream << baseDir << PATH_SEPARATOR;
  354.   }
  356.   if (( moduleName ) && ( *moduleName )) {
  357.     for (const VXIchar *ptr = moduleName; *ptr; ptr++) {
  358.       if ((( *ptr >= L'0' ) && ( *ptr <= L'9' )) ||
  359.           (( *ptr >= L'A' ) && ( *ptr <= L'Z' )) ||
  360.           (( *ptr >= L'a' ) && ( *ptr <= L'z' )) ||
  361.           ( *ptr == L'.'  ) || ( *ptr == PATH_SEPARATOR)
  362.           )
  363.         pathStream << static_cast<char>(*ptr);
  364.       else
  365.         pathStream << '_';
  366.     }
  367.   } else {
  368.     pathStream << "unknown_module";
  369.   }
  370.   pathStream << PATH_SEPARATOR;
  371.   
  372.   // Construct the file name
  373.   char logNFileName[32];
  374.   time_t tnow;
  375.   VXIunsigned mSec;
  376.   SBlogGetTime(&tnow, &mSec);
  377.   struct tm *ts, ts_r = { 0 };
  378.   ts = localtime_r(&tnow, &ts_r);
  379.   ts->tm_year = (ts->tm_year < 1900 ? ts->tm_year + 1900 : ts->tm_year); // y2k
  380.   ts->tm_mon++;  // tm_mon is 0 base
  381.   sprintf(logNFileName, "%03d-%d%02d%02d%02d%02d%02d%03d", 
  382.           channel, ts->tm_year, ts->tm_mon, ts->tm_mday,
  383.           ts->tm_hour, ts->tm_min, ts->tm_sec, mSec);
  385.   // Construct the final path
  386.   pathStream << logNFileName << GetExtension(contentType);
  387.   npath_ = pathStream.str();
  389.   // Convert back to wide characters
  390.   for (std::string::size_type i = 0; i < npath_.size( ); i++)
  391.     wpath_ += static_cast<wchar_t>(npath_[i]);
  393.   return rc;
  394. }
  396. // Create the directory tree for the path
  397. VXIlogResult SBlogContentStream::CreateDirectories( ) 
  398. {
  399.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  401.   // Go through the directories for the relative portion and create them
  402.   std::string::size_type componentLen = baseDirLen_;
  403.   while (componentLen != std::string::npos) {
  404.     std::string tempPath (npath_, 0, componentLen);
  405.     SBlogMkDir (tempPath.c_str());
  406.     componentLen = npath_.find_first_of ("/\", componentLen + 1);
  407.   }
  409.   return rc;
  410. }
  412. // open content stream
  413. VXIlogResult SBlogContentStream::Open(const VXIchar *moduleName, 
  414.               const VXIchar *contentType,
  415.               const char *baseDir,
  416.               VXIint channel)
  417. {
  418.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  420.   rc = CreatePath(moduleName, contentType, baseDir, channel);
  421.   if ( rc == VXIlog_RESULT_SUCCESS )
  422.     rc = CreateDirectories();
  423.   if ( rc == VXIlog_RESULT_SUCCESS ) {
  424.     fp_ = fopen(npath_.c_str(), "wb");
  425.     if ( fp_ == NULL ) {
  426.       SBlogLogStream::GlobalError(252, 
  427.                   L"SBlogListeners: Content log file open failed", 
  428.       L"%s%S%s%S%s%d", L"file", npath_.c_str(),
  429.       L"errnoStr", strerror(errno), L"errno", errno);
  430.       return VXIlog_RESULT_IO_ERROR;
  431.     }
  432.   }
  433.   return rc;
  434. }
  436. // close content stream
  437. VXIlogResult SBlogContentStream::Close()
  438. {
  439.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  440.   if ( fp_ ) {
  441.     fclose(fp_);
  442.     fp_ = NULL;
  443.   }
  444.   return rc;
  445. }
  447. VXIlogResult SBlogContentStream::CallClose(struct SBlogStream **stream)
  448. {
  449.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  450.   if ( stream == NULL || *stream == NULL ) 
  451.     return VXIlog_RESULT_INVALID_ARGUMENT;
  453.   SBlogContentStream *myStream = static_cast<SBlogContentStream *>(*stream);
  454.   rc = myStream->Close();
  455.   delete myStream;
  456.   *stream = NULL;
  457.   return rc;
  458. }
  460. // write content stream
  461. VXIlogResult SBlogContentStream::Write( const VXIbyte *buffer, 
  462.           VXIulong buflen, VXIulong *nwritten)
  463. {
  464.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  465.   if ( fp_ == NULL ) return VXIlog_RESULT_FAILURE;
  466.   *nwritten =  fwrite (buffer, 1, buflen, fp_);
  467.   if ( *nwritten == 0 ) {
  468.     if ( ferror (fp_) ) {
  469.       SBlogLogStream::GlobalError(253, 
  470.                   L"SBlogListeners: Content logging file write failed", 
  471.       L"%s%S%s%S%s%d", L"file", npath_.c_str(),
  472.       L"errnoStr", strerror(errno), L"errno", errno);
  473.       rc = VXIlog_RESULT_IO_ERROR;
  474.     } else {
  475.       rc = VXIlog_RESULT_NON_FATAL_ERROR;
  476.     } 
  477.   }
  478.   return rc;
  479. }
  481. VXIlogResult SBlogContentStream::CallWrite(struct SBlogStream *stream, 
  482.              const VXIbyte *buffer,
  483.              VXIulong buflen,
  484.              VXIulong *nwritten)
  485. {
  486.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  487.   if ( stream == NULL ) return VXIlog_RESULT_INVALID_ARGUMENT;
  488.   SBlogContentStream *myStream = static_cast<SBlogContentStream *>(stream);
  489.   rc = myStream->Write(buffer, buflen, nwritten);
  490.   return rc;
  491. }
  493. /**********************************************************************/
  494. // globals to the file
  495. /**********************************************************************/
  496. static SBlogLogStream *g_LogStream=NULL;
  498. /**********************************************************************/
  499. // Logging class implementation
  500. /**********************************************************************/
  501. SBlogLogEntry::SBlogLogEntry(LogEscapes escapes)
  502. {
  503.   escapes_ = escapes;
  504.   cur_size_ = 0;
  505. }
  507. SBlogLogEntry::SBlogLogEntry(time_t timestamp, VXIunsigned timestampMsec)
  508. {
  509.   escapes_ = ESCAPES_STANDARD;
  510.   cur_size_ = 0;
  511.   char timestampStr[128];
  512.   SBlogGetTimeStampStr(timestamp,timestampMsec,timestampStr);
  513.   (*this) += timestampStr;
  514. }
  516. VXIlogResult
  517. SBlogLogEntry::Append (const VXIchar* val, VXIunsigned n)
  518. {
  519.   unsigned int i = 0;
  520.   if (n <= 0)
  521.     n = wcslen(val);
  523.   // strip leading and trailing whitespace
  524.   while ((n > 0) && (SBlogIsSpace(val[n-1]))) n--;
  525.   while ((i < n) && (SBlogIsSpace(val[i]))) i++;
  527.   while((cur_size_ < MAX_LOG_BUFFER) && (i < n)) {
  528.     if (SBlogIsSpace(val[i])) {
  529.       entry_[cur_size_++] = L' ';
  530.     } else {
  531.       bool suppress = false;
  533.       switch(escapes_) {
  534.         case ESCAPES_STANDARD:
  535.           // CC: Remove \ 
  536.           //if ((val[i] == KEY_SEP) || (val[i] == ENTRY_SEP) || (val[i] == ESCAPE))
  537.           //  entry_[cur_size_++] = ESCAPE;
  538.           break;
  539.         case ESCAPES_OSR_EVNT_LOG:
  540.           if (val[i] == ENTRY_SEP) {
  541.             // In OSR event log, escape for | is putting 2 in a row
  542.             entry_[cur_size_++] = ENTRY_SEP;
  543.           } else if (val[i] == KEY_SEP) {
  544.             // In OSR event log, no escape defined for =
  545.             suppress = true;
  546.             entry_[cur_size_++] = L'-';
  547.             entry_[cur_size_++] = L'>';
  548.           }
  549.           break;
  550.         default:
  551.           break;
  552.       }
  554.       if (! suppress)
  555.         entry_[cur_size_++] = val[i];
  556.     }
  557.     i++;
  558.   }
  559.   entry_[cur_size_]=L'';
  561.   return VXIlog_RESULT_SUCCESS;
  562. }
  564. VXIlogResult 
  565. SBlogLogEntry::Append(const VXIVector *keys,
  566.           const VXIVector *values)
  567. {
  568.   if ((! keys) || (! values))
  569.     return VXIlog_RESULT_INVALID_ARGUMENT;
  571.   VXIunsigned index = VXIVectorLength(keys);
  572.   for(VXIunsigned i = 0; i < index; i++) {
  573.     const VXIValue *key = VXIVectorGetElement(keys, i);
  574.     const VXIValue *value = VXIVectorGetElement(values, i);
  575.     if (!key || !value)
  576.       break;
  578.     *this += key;
  579.     AddKeySep();
  580.     *this += value;
  581.     if (i < index - 1) AddEntrySep();
  582.   }
  583.   return VXIlog_RESULT_SUCCESS;
  584. }
  586. void 
  587. SBlogLogEntry::operator+= (const char* val)
  588. {
  589.   unsigned int i = 0;
  590.   unsigned int n = strlen(val);
  592.   // strip leading and trailing whitespace
  593.   while ((n > 0) && (SBlogIsSpace(val[n-1]))) n--;
  594.   while ((i < n) && (SBlogIsSpace(val[i]))) i++;
  596.   while((cur_size_ < MAX_LOG_BUFFER) && (i < n)) {
  597.     if (SBlogIsSpace(val[i])) {
  598.       entry_[cur_size_++] = L' ';
  599.     } else {
  600.       bool suppress = false;
  602.       switch(escapes_) {
  603.         case ESCAPES_STANDARD:
  604.           // CC: Remove \
  605.           //if ((val[i] == KEY_SEP) || (val[i] == ENTRY_SEP) || (val[i] == ESCAPE))
  606.           //entry_[cur_size_++] = ESCAPE;
  607.           break;
  608.         case ESCAPES_OSR_EVNT_LOG:
  609.           if (val[i] == ENTRY_SEP) {
  610.             // In OSR event log, escape for | is putting 2 in a row
  611.             entry_[cur_size_++] = ENTRY_SEP;
  612.           } else if (val[i] == KEY_SEP) {
  613.             // In OSR event log, no escape defined for =
  614.             suppress = true;
  615.             entry_[cur_size_++] = L'-';
  616.             entry_[cur_size_++] = L'>';
  617.           }
  618.           break;
  619.         default:
  620.           break;
  621.       }
  623.       if (! suppress)
  624.         entry_[cur_size_++] = (VXIchar) val[i];
  625.     }
  626.     i++;
  627.   }
  628.   entry_[cur_size_]=L'';
  629. }
  632. void
  633. SBlogLogEntry::operator+= (VXIint32 val)
  634. {
  635.   char temp[128];
  636.   sprintf(temp,"%d",val);
  637.   (*this) += temp;
  638.   return ;
  639. }
  641. void
  642. SBlogLogEntry::operator+= (long int val)
  643. {
  644.   char temp[128];
  645.   sprintf(temp,"%ld",val);
  646.   (*this) += temp;
  647.   return ;
  648. }
  650. void
  651. SBlogLogEntry::operator+= (VXIunsigned val)
  652. {
  653.   char temp[128];
  654.   sprintf(temp,"%d",val);
  655.   (*this) += temp;
  656.   return ;
  657. }
  659. void
  660. SBlogLogEntry::operator+= (VXIflt32 val)
  661. {
  662.   char temp[128];
  663.   sprintf(temp,"%f",val);
  664.   (*this) += temp;
  665.   return ;
  666. }
  668. void
  669. SBlogLogEntry::operator+= (VXIulong val)
  670. {
  671.   char temp[128];
  672.   sprintf(temp,"%u",val);
  673.   (*this) += temp;
  674.   return ;
  675. }
  677. void
  678. SBlogLogEntry::operator+= (VXIflt64 val)
  679. {
  680.   char temp[128];
  681.   sprintf(temp,"%f",val);
  682.   (*this) += temp;
  683.   return ;
  684. }
  686. void
  687. SBlogLogEntry::operator+= (VXIptr val)
  688. {
  689.   char temp[128];
  690.   sprintf(temp,"0x%p",val);
  691.   (*this) += temp;
  692.   return ;
  693. }
  695. void
  696. SBlogLogEntry::operator+=(const VXIValue *value)
  697. {
  698.   switch (VXIValueGetType(value)) {
  699.   case VALUE_STRING:
  700.     (*this) += VXIStringCStr((const VXIString *) value);
  701.     break;
  703.   case VALUE_INTEGER:
  704.     (*this) += VXIIntegerValue((const VXIInteger *) value);
  705.     break;
  707.   case VALUE_FLOAT:
  708.     (*this) += VXIFloatValue((const VXIFloat *) value);
  709.     break;
  711.   case VALUE_DOUBLE:
  712.     (*this) += VXIDoubleValue((const VXIDouble *) value);
  713.     break;
  715.   case VALUE_ULONG:
  716.     (*this) += VXIULongValue((const VXIULong *) value);
  717.     break;
  719.   case VALUE_PTR:
  720.     (*this) += VXIPtrValue((const VXIPtr *) value);
  721.     break;
  723.   default:
  724.     (*this) += L"unsupported type ";
  725.     (*this) += VXIValueGetType(value);
  726.   }
  727. }
  729. void SBlogLogEntry::Terminate(bool addCpuTimes, bool addNewline)
  730. {
  731.   // overwrite addCpuTime param
  732.   addCpuTimes = (gblLogPerformanceCounter == TRUE ? true : false);
  733.   if (addCpuTimes) {
  734.     long userTime;
  735.     long kernelTime;
  736.     SBlogGetCPUTimes(&userTime,&kernelTime);
  737.     this->AddEntrySep();
  738.     (*this) += "UCPU";
  739.     this->AddKeySep();
  740.     (*this) += userTime;
  741.     
  742.     this->AddEntrySep();
  743.     (*this) += "SCPU";
  744.     this->AddKeySep();
  745.     (*this) += kernelTime;
  746.   }
  747.   
  748.   if (addNewline) {
  749.     if (cur_size_ == MAX_LOG_BUFFER)
  750.       cur_size_--;
  751.     entry_[cur_size_++] ='n';
  752.   }
  753.   entry_[cur_size_] = '';
  754. }
  756. SBlogLogStream::SBlogLogStream() :
  757.   errorMapper_(NULL),
  758.   logfilename_(NULL),
  759.   logContentDir_(NULL),
  760.   logFp_(NULL),
  761.   currentSize_(0),
  762.   maxLogSizeBytes_(0),
  763.   maxContentDirSize_(0),
  764.   logFormat_(FORMAT_TEXT_LATIN1),
  765.   logToStdout_(TRUE),
  766.   keepLogFileOpen_(TRUE),
  767.   reportErrorText_(FALSE),
  768.   loglock_(NULL),
  769.   internalErrorLoggingLock_(NULL),
  770.   internalErrorLoggingThread_((VXIthreadID) -1)
  771. {
  772.   narrowlogfilename_[0] = '';
  773.   narrowLogContentDir_[0] = '';
  774. }
  776. VXIlogResult
  777. SBlogLogStream::Init(const VXIchar   *filename,
  778.          const VXIchar   *fileMimeType,
  779.          VXIint32         maxLogSizeBytes,
  780.          const VXIchar   *logContentDir,
  781.          VXIint32         maxContentDirSize,
  782.          VXIbool          logToStdout,
  783.          VXIbool          keepLogFileOpen,
  784.          VXIbool          reportErrorText,
  785.          const VXIVector *errorMapFiles)
  786. {
  787.   int n;
  788.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  790.   // check the inputs
  791.   if (maxLogSizeBytes < 0) {
  792.     GlobalError(152, L"SBlogListeners: Invalid system log file size "
  793.                 L"limit configured", L"%s%ld", L"configured",
  794.                 (long) maxLogSizeBytes);
  795.     return VXIlog_RESULT_INVALID_ARGUMENT;
  796.   } else if (maxContentDirSize < 0) {
  797.     GlobalError(153, L"SBlogListeners: Invalid content logging file "
  798.                 L"size limit configured", L"%s%ld", L"configured",
  799.                 (long) maxContentDirSize);
  800.     return VXIlog_RESULT_INVALID_ARGUMENT;
  801.   }
  803.   if ((! fileMimeType) || (! fileMimeType[0]) ||
  804.       (wcscmp(fileMimeType, SBLOG_MIME_TEXT_LATIN1) == 0))
  805.     logFormat_ = FORMAT_TEXT_LATIN1;
  806.   else if (wcscmp(fileMimeType, SBLOG_MIME_TEXT_UTF8) == 0)
  807.     logFormat_ = FORMAT_TEXT_UTF8;
  808.   else {
  809.     GlobalError(150, L"SBlogListeners: Invalid system log file format "
  810.                 L"configured", L"%s%s", L"format", fileMimeType);
  811.     return VXIlog_RESULT_INVALID_ARGUMENT;
  812.   }
  814.   maxLogSizeBytes_ = maxLogSizeBytes;
  815.   maxContentDirSize_ = maxContentDirSize;
  816.   logToStdout_ = logToStdout;
  817.   keepLogFileOpen_ = keepLogFileOpen;
  818.   reportErrorText_ = reportErrorText;
  820.   if (logfilename_) {
  821.     delete [] logfilename_;
  822.     logfilename_ = NULL;
  823.   }
  824.   if (logContentDir_) {
  825.     delete [] logContentDir_;
  826.     logContentDir_ = NULL;
  827.   }
  829.   if (filename != NULL) { // write to a file otherwise only stdout
  830.     // copy the filename
  831.     n = wcslen(filename);
  832.     logfilename_ = new VXIchar[n+1];
  833.     if (!logfilename_) {
  834.       GlobalError(SBLOG_ERR_OUT_OF_MEMORY);
  835.       return VXIlog_RESULT_OUT_OF_MEMORY;
  836.     }
  838.     wcscpy(logfilename_, filename);
  839.     
  840.     // convert the file name path
  841.     SBlogWchar2Latin1(logfilename_, narrowlogfilename_, MAX_PATH);
  843.     rc = CheckOpen();
  844.   }
  846.   if (logContentDir != NULL) {
  847.     // copy the filename
  848.     n = wcslen(logContentDir);
  849.     logContentDir_ = new VXIchar[n+1];
  850.     if (!logContentDir_) {
  851.       GlobalError(SBLOG_ERR_OUT_OF_MEMORY);
  852.       return VXIlog_RESULT_OUT_OF_MEMORY;
  853.     }
  855.     wcscpy(logContentDir_, logContentDir);
  856.     
  857.     // convert the file name path
  858.     SBlogWchar2Latin1(logContentDir_, narrowLogContentDir_, MAX_PATH);
  860.     // reate the content directory
  861.     SBlogMkDir (narrowLogContentDir_);
  862.   }
  864.   // Create the mutexes
  865.   if ((VXItrdMutexCreate(&loglock_) != VXItrd_RESULT_SUCCESS) ||
  866.       (VXItrdMutexCreate(&internalErrorLoggingLock_) !=
  867.        VXItrd_RESULT_SUCCESS)) {
  868.     GlobalError(SBLOG_ERR_MUTEX_CREATE);
  869.     rc = VXIlog_RESULT_SYSTEM_ERROR;
  870.   }
  872.   // load the XML error files into a VXIMap member here
  873.   if (errorMapFiles)
  874.   {
  875.     VXIlogResult rc2 = SBlogErrorMapperCreate(errorMapFiles, &errorMapper_);
  877.     // write to log file if unable to display error text
  878.     if (rc2 != VXIlog_RESULT_SUCCESS && Enabled())
  879.     {
  880.       if( rc2 == VXIlog_RESULT_UNSUPPORTED )
  881.         GlobalError(350, L"XML error text lookup feature disabled because the "
  882.                     L"listener is compiled without defining HAVE_XERCES", NULL);
  883.       else
  884.         GlobalError(351, L"XML error text lookup feature disabled due to an "
  885.                     L"error in parsing the configured XML error files", NULL);
  886.     }
  887.   }
  889.   return rc;
  890. }
  892. VXIlogResult
  893. SBlogLogStream::ShutDown()
  894. {
  895.   if (errorMapper_) {
  896.     SBlogErrorMapperDestroy(&errorMapper_);
  897.     errorMapper_ = NULL;
  898.   }
  900.   if (logfilename_) {
  901.     delete [] logfilename_;
  902.     logfilename_ = NULL;
  903.   }
  905.   if (logContentDir_) {
  906.     delete [] logContentDir_;
  907.     logContentDir_ = NULL;
  908.   }
  910.   if (logFp_) {
  911.     fclose(logFp_);
  912.     logFp_ = NULL;
  913.   }
  915.   if ((loglock_) && (VXItrdMutexDestroy(&loglock_) != VXItrd_RESULT_SUCCESS))
  916.     return VXIlog_RESULT_SYSTEM_ERROR;
  918.   if ((internalErrorLoggingLock_) && 
  919.       (VXItrdMutexDestroy(&internalErrorLoggingLock_) != 
  920.        VXItrd_RESULT_SUCCESS))
  921.     return VXIlog_RESULT_SYSTEM_ERROR;
  923.   return VXIlog_RESULT_SUCCESS;
  924. }
  926. /*
  927.   Make sure the current file can be opened - safety during the intialize
  928.   */
  929. VXIlogResult
  930. SBlogLogStream::CheckOpen()
  931. {
  932.   if (narrowlogfilename_[0] == '') {
  933.     GlobalError(154, L"SBlogListeners: Invalid system log file name "
  934.                 L"configured", NULL);
  935.     return VXIlog_RESULT_PLATFORM_ERROR;
  936.   }
  938.   // See if the file exists and open it, getting the size
  939.   SBlogFileStats info;
  940.   if (SBlogGetFileStats(narrowlogfilename_, &info) == 0) {
  941.     currentSize_ = info.st_size;
  942.     logFp_ = fopen(narrowlogfilename_, "a");
  943.   } else {
  944.     currentSize_ = 0;
  945.     logFp_ = fopen(narrowlogfilename_, "w");
  946.   }
  947.   if (! logFp_) {
  948.     GlobalError(151, L"SBlogListeners: System log file open failed", 
  949.                 L"%s%S%s%S%s%d", L"file", narrowlogfilename_,
  950.                 L"errnoStr", strerror(errno), L"errno", errno);
  951.     return VXIlog_RESULT_IO_ERROR;
  952.   }
  953.   if (! keepLogFileOpen_) {
  954.     fclose(logFp_);
  955.     logFp_ = NULL;
  956.   }
  957.   return VXIlog_RESULT_SUCCESS;
  958. }
  960. VXIlogResult
  961. SBlogLogStream::Open(VXIunsigned nextblock_size)
  962. {
  963.   if (narrowlogfilename_[0] == '') {
  964.     GlobalError(154, L"SBlogListeners: Invalid system log file name "
  965.                 L"configured", NULL);
  966.     return VXIlog_RESULT_PLATFORM_ERROR;
  967.   }
  969.   if (! logFp_) {
  970.     // See if the file exists and open it, getting the size
  971.     SBlogFileStats info;
  972.     if (SBlogGetFileStats(narrowlogfilename_, &info) == 0) {
  973.       currentSize_ = info.st_size;
  974.     } else {
  975.       currentSize_ = 0;
  976.     }
  977.   }
  979.   if ((currentSize_ + nextblock_size) > (VXIunsigned) maxLogSizeBytes_) {
  980.     if (logFp_) {
  981.       fclose(logFp_);
  982.       logFp_ = NULL;
  983.     }
  985.     currentSize_ = 0;
  986.     char overflowName[MAX_PATH+64];
  987.     strcpy(overflowName,narrowlogfilename_);
  988.     strcat(overflowName,".old");
  989.     remove(overflowName);
  990.     if (rename(narrowlogfilename_,overflowName)) {
  991.       GlobalError(251, L"SBlogListeners: System log file rollover failed",
  992.                   L"%s%S%s%S%s%S%s%d", L"logFile", narrowlogfilename_, 
  993.                   L"rolloverFile", overflowName, L"errnoStr", strerror(errno),
  994.                   L"errno", errno);
  995.       return VXIlog_RESULT_IO_ERROR;
  996.     }
  997.     logFp_ = fopen(narrowlogfilename_, "w");
  998.   } else if (! logFp_) {
  999.     logFp_ = fopen(narrowlogfilename_, "a");
  1000.   }
  1001.   if (! logFp_) {
  1002.     GlobalError(151, L"SBlogListeners: System log file open failed", 
  1003.                 L"%s%S%s%S%s%d", L"file", narrowlogfilename_,
  1004.                 L"errnoStr", strerror(errno), L"errno", errno);
  1005.     return VXIlog_RESULT_IO_ERROR;
  1006.   }
  1007.   return VXIlog_RESULT_SUCCESS;
  1008. }
  1010. VXIlogResult
  1011. SBlogLogStream::Close()
  1012. {
  1013.   if (!logFp_)
  1014.     return VXIlog_RESULT_IO_ERROR;
  1015.   if (! keepLogFileOpen_) {
  1016.     fclose(logFp_);
  1017.     logFp_ = NULL;
  1018.   } else {
  1019.     fflush(logFp_);
  1020.   }
  1021.   return VXIlog_RESULT_SUCCESS;
  1022. }
  1024. VXIlogResult
  1025. SBlogLogStream::WriteEntry(const SBlogLogEntry &entry, VXIbool logToStdout)
  1026. {
  1027.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  1028.   unsigned int nFileBytes = 0;
  1029.   char latin1OutBuf[MAX_LOG_BUFFER + 1]; // make sure enough room
  1030.   char utf8OutBuf[MAX_LOG_BUFFER * 4 + 1];
  1031.   const char *fileBuf = NULL;
  1032.   latin1OutBuf[0] = 0;
  1033.   utf8OutBuf[0] = 0;
  1035.   // Exit if there is nothing to write, should never happen
  1036.   if (entry.size() == 0)
  1037.     return VXIlog_RESULT_FATAL_ERROR;
  1039.   if ((logfilename_ != NULL) || (logToStdout && logToStdout_)) {
  1040.     // Generate Latin-1 and/or UTF-8 output as required. Note that
  1041.     // Latin-1 is used for console output even when the log file
  1042.     // format is not Latin-1 because under many operating
  1043.     // system/compiler/console combinations wide character output
  1044.     // doesn't work right.
  1045.     switch (logFormat_) {
  1046.     case FORMAT_TEXT_UTF8:
  1047.       SBlogWchar2UTF8(entry.Entry(), utf8OutBuf, MAX_LOG_BUFFER * 4,
  1048.           &nFileBytes);
  1049.       fileBuf = utf8OutBuf;
  1050.       break;
  1051.     case FORMAT_TEXT_LATIN1:
  1052.       SBlogWchar2Latin1(entry.Entry(), latin1OutBuf, MAX_LOG_BUFFER);
  1053.       fileBuf = latin1OutBuf;
  1054.       nFileBytes = entry.size();
  1055.       break;
  1056.     default:
  1057.       GlobalError(150, L"SBlogListeners: Invalid system log file format "
  1058.                   L"configured", NULL);
  1059.       return VXIlog_RESULT_FATAL_ERROR;
  1060.     }
  1062. #ifndef WCHART_CONSOLE_OUTPUT
  1063.     if ((logToStdout) && (logToStdout_) && (! latin1OutBuf[0]))
  1064.       SBlogWchar2Latin1(entry.Entry(), latin1OutBuf, MAX_LOG_BUFFER);
  1065. #endif
  1066.   }
  1067.   
  1068.   if (nFileBytes == 0)
  1069.     return VXIlog_RESULT_SUCCESS;
  1071.   if (Lock() != VXItrd_RESULT_SUCCESS)
  1072.     return VXIlog_RESULT_SYSTEM_ERROR;
  1074.   if (logfilename_ != NULL) {
  1075.     // proceed to log to stdout if enabled, but return the error code
  1076.     rc = Open(entry.size());
  1077.     if (rc == VXIlog_RESULT_SUCCESS) {
  1078.       int nwrite = fwrite(fileBuf, 1, nFileBytes, logFp_);
  1079.       if (nwrite == 0) {
  1080.         // should disable logging.
  1081.         GlobalError(250, L"SBlogListeners: System log file write failed", 
  1082.                     L"%s%S%s%S%s%d", L"file", narrowlogfilename_,
  1083.                     L"errnoStr", strerror(errno), L"errno", errno);
  1084.         rc = VXIlog_RESULT_IO_ERROR;
  1085.       } else {
  1086.         currentSize_ += nwrite;
  1087.         // to ensure we don't lose log lines on a crash/abort
  1088.         fflush(logFp_);
  1089.       }
  1090.     }
  1092.     VXIlogResult rc2 = Close();
  1093.     if (rc2 != VXIlog_RESULT_SUCCESS)
  1094.       rc = rc2;
  1095.   }
  1097.   if ((logToStdout) && (logToStdout_)) {
  1098.     VXIlogResult rc2 = VXIlog_RESULT_SUCCESS;
  1099. #ifdef WCHART_CONSOLE_OUTPUT
  1100.     if (fputws(entry.Entry(), stdout) <= 0)
  1101.       rc2 = VXIlog_RESULT_IO_ERROR;
  1102. #else
  1103.     if (fwrite(latin1OutBuf, 1, entry.size(), stdout) <= 0)
  1104.       rc2 = VXIlog_RESULT_IO_ERROR;
  1105. #endif
  1107.     if (fflush(stdout) != 0)
  1108.       rc = VXIlog_RESULT_IO_ERROR;
  1110.     if (rc2 != VXIlog_RESULT_SUCCESS)
  1111.       rc = rc2;
  1112.   }
  1114.   if (Unlock() != VXItrd_RESULT_SUCCESS)
  1115.     rc = VXIlog_RESULT_SYSTEM_ERROR;
  1117.   return rc;
  1118. }
  1121. const VXIchar *
  1122. SBlogLogStream::GetErrorText(VXIunsigned errorID, const VXIchar *moduleName,
  1123.            const VXIchar **severity)
  1124. {
  1125.   static const VXIchar *severityStr[4] = {
  1126.     L"", L"CRITICAL", L"SEVERE", L"WARNING" };
  1128.   VXIint severityNum = -1;
  1129.   const VXIchar *errText;
  1130.   
  1131.   // mapping here
  1132.   if (errorMapper_)
  1133.     SBlogErrorMapperGetErrorInfo(errorMapper_, errorID, moduleName,
  1134.          &errText, &severityNum);
  1135.   else
  1136.     errText = severityStr[0];
  1138.   if ((severityNum >= 1) && (severityNum <= 3))
  1139.     *severity = severityStr[severityNum];
  1140.   else
  1141.     *severity = severityStr[0];
  1142.   
  1143.   // If the mapping failed, this returned an empty string
  1144.   return errText;
  1145. }
  1147. VXIlogResult SBlogLogStream::GlobalError(VXIunsigned errorID, 
  1148.            const VXIchar *errorIDText,
  1149.            const VXIchar *format, ...)
  1150. {
  1151.   va_list args;
  1152.   va_start(args, format);
  1153.   VXIlogResult rc = SBlogVLogErrorToConsole(MODULE_NAME, errorID, errorIDText,
  1154.                                             format, args);
  1155.   va_end(args);
  1156.   return rc;
  1157. }
  1160. SBLOGLISTENERS_API void DiagnosticListener
  1161. (
  1162.   SBlogInterface *pThis,
  1163.   VXIunsigned tagID,
  1164.   const VXIchar* subtag,
  1165.   time_t timestamp,
  1166.   VXIunsigned timestampMsec,
  1167.   const VXIchar* printmsg,
  1168.   void *userdata
  1169. )
  1170. {
  1171.   // casting userdata
  1172.   SBlogListenerChannelData *data = (SBlogListenerChannelData *)userdata;
  1173.   if ( data == NULL ) return;
  1174.   // Exit immediately if no logging enabled
  1175.   if (!g_LogStream || !g_LogStream->Enabled())
  1176.     return;
  1178.   SBlogLogEntry entry(timestamp, timestampMsec);
  1179.   entry.AddEntrySep();
  1180.   entry += (long) VXItrdThreadGetID();
  1181.   // entry.AddEntrySep();
  1182.   entry.AddEntrySep();
  1183.   entry += data->channel;
  1184.   entry.AddEntrySep();
  1185.   entry += tagID;
  1186.   entry.AddEntrySep();
  1187.   entry += subtag;
  1188.   entry.AddEntrySep();
  1189.   entry += printmsg;
  1190.   entry.Terminate();
  1191.   g_LogStream->WriteEntry(entry);
  1192.   return;
  1193. }
  1196. SBLOGLISTENERS_API void ErrorListener
  1197. (
  1198.   SBlogInterface *pThis,
  1199.   const VXIchar *moduleName,
  1200.   VXIunsigned errorID,
  1201.   time_t timestamp,
  1202.   VXIunsigned timestampMsec,
  1203.   const VXIVector *keys,
  1204.   const VXIVector *values,
  1205.   void *userdata
  1206. )
  1207. {
  1208.   // casting userdata, even if we get NULL for pThis and userdata
  1209.   // proceed since we rely on that in SBlogStream::Error() above
  1210.   SBlogListenerChannelData *data = (SBlogListenerChannelData *)userdata;
  1212.   // Exit immediately if no logging enabled
  1213.   if (!g_LogStream || !g_LogStream->Enabled())
  1214.     return;
  1216.   // Lookup error text
  1217.   const VXIchar *errorText = L"", *severity = L"";
  1218.   if ( g_LogStream->ReportErrorText( ) )
  1219.     errorText = g_LogStream->GetErrorText (errorID, moduleName, &severity);
  1221.   SBlogLogEntry entry(timestamp, timestampMsec);
  1222.   entry.AddEntrySep();
  1223.   entry += (long) VXItrdThreadGetID();
  1224.   // entry.AddEntrySep();
  1225.   entry.AddEntrySep();
  1226.   if (data)
  1227.     entry += data->channel;
  1228.   else
  1229.     entry += -1;
  1230.   entry.AddEntrySep();
  1231.   entry += severity;
  1232.   entry.AddEntrySep();
  1233.   entry += moduleName;
  1234.   entry.AddEntrySep();
  1235.   entry += errorID;
  1236.   entry.AddEntrySep();
  1237.   entry += errorText;
  1238.   entry.AddEntrySep();
  1239.   entry.Append(keys, values);
  1240.   entry.Terminate();
  1241.   g_LogStream->WriteEntry(entry);
  1242. }
  1245. SBLOGLISTENERS_API void EventListener
  1246. (
  1247.   SBlogInterface *pThis,
  1248.   VXIunsigned eventID,
  1249.   time_t timestamp,
  1250.   VXIunsigned timestampMsec,
  1251.   const VXIVector *keys,
  1252.   const VXIVector *values,
  1253.   void *userdata
  1254. )
  1255. {
  1256.   // casting userdata
  1257.   SBlogListenerChannelData *data = (SBlogListenerChannelData *)userdata;
  1258.   if ( data == NULL ) return;
  1259.   // Exit immediately if no logging enabled
  1260.   if (!g_LogStream || !g_LogStream->Enabled())
  1261.     return;
  1262.   SBlogLogEntry entry(timestamp, timestampMsec);
  1263.   entry.AddEntrySep();
  1264.   entry += (long) VXItrdThreadGetID();
  1265.   entry.AddEntrySep();
  1266.   // entry.AddEntrySep();
  1267.   entry += data->channel;
  1268.   entry.AddEntrySep();
  1269.   entry += L"EVENT";
  1270.   entry.AddEntrySep();
  1271.   entry += eventID;
  1272.   entry.AddEntrySep();
  1273.   entry.Append(keys, values);
  1274.   entry.Terminate();
  1275.   g_LogStream->WriteEntry(entry, FALSE);
  1276. }
  1279. SBLOGLISTENERS_API VXIlogResult ContentListener
  1280. (
  1281.   SBlogInterface *pThis,
  1282.   const VXIchar  *moduleName,
  1283.   const VXIchar  *contentType,
  1284.   void           *userdata,
  1285.   VXIString     **logKey,
  1286.   VXIString     **logValue,
  1287.   SBlogStream   **stream
  1288. )
  1289. {
  1290.   // casting userdata
  1291.   SBlogListenerChannelData *data = (SBlogListenerChannelData *)userdata;
  1292.   if ( data == NULL ) return VXIlog_RESULT_INVALID_ARGUMENT;
  1293.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  1295.   *logKey = NULL;
  1296.   *logValue = NULL;
  1297.   *stream = NULL;
  1299.   // Exit immediately if no logging enabled
  1300.   if (!g_LogStream || !g_LogStream->Enabled())
  1301.     return VXIlog_RESULT_FAILURE;
  1303.   const char *baseDir = g_LogStream->GetNContentDir();
  1304.   VXIulong maxSize = g_LogStream->GetContentDirMaxSize();
  1306.   // only do open if content dir. and size is valid
  1307.   if (baseDir && *baseDir != 0 && maxSize > 0 )
  1308.   {
  1309.     SBlogContentStream *openedStream = new SBlogContentStream;
  1310.     rc = openedStream->Open(moduleName, contentType, baseDir, data->channel);
  1311.     if ( rc != VXIlog_RESULT_SUCCESS ) {
  1312.       delete openedStream;
  1313.     } else {  
  1314.       // create key & value for cross-reference
  1315.       VXIString *logKey_ = VXIStringCreate(L"contentURL");
  1316.       VXIString *logValue_ = VXIStringCreate(openedStream->GetPath());
  1317.       *logKey = logKey_;
  1318.       *logValue = logValue_;
  1319.       *stream = static_cast<SBlogStream *>(openedStream);
  1320.     }
  1321.   } else {
  1322.     rc = VXIlog_RESULT_FAILURE;
  1323.   }
  1325.   return rc;
  1326. }
  1329. /**********************************************************************/
  1330. // Public Interface
  1331. /**********************************************************************/
  1333. SBLOGLISTENERS_API VXIlogResult SBlogListenerInit
  1334. (
  1335.  const VXIchar   *filename,
  1336.  VXIint32         maxLogSizeBytes,
  1337.  VXIbool          logToStdout,
  1338.  VXIbool          keepLogFileOpen
  1339. )
  1340. {
  1341.   return SBlogListenerInitEx2(filename, NULL, maxLogSizeBytes, NULL, 0, 
  1342.                               logToStdout, keepLogFileOpen, FALSE, NULL);
  1343. }
  1345. SBLOGLISTENERS_API VXIlogResult SBlogListenerInitEx
  1346. (
  1347.  const VXIchar   *filename,
  1348.  VXIint32         maxLogSizeBytes,
  1349.  const VXIchar   *logContentDir,
  1350.  VXIint32         maxContentDirSize,
  1351.  VXIbool          logToStdout,
  1352.  VXIbool          keepLogFileOpen,
  1353.  VXIbool          reportErrorText,
  1354.  const VXIVector *errorMapFiles
  1355. )
  1356. {
  1357.   return SBlogListenerInitEx2(filename, NULL, maxLogSizeBytes, logContentDir,
  1358.                               maxContentDirSize, logToStdout, keepLogFileOpen,
  1359.                               reportErrorText, errorMapFiles);
  1360. }
  1362. SBLOGLISTENERS_API VXIlogResult SBlogListenerInitEx2
  1363. (
  1364.  const VXIchar   *filename,
  1365.  const VXIchar   *fileMimeType,
  1366.  VXIint32         maxLogSizeBytes,
  1367.  const VXIchar   *logContentDir,
  1368.  VXIint32         maxContentDirSize,
  1369.  VXIbool          logToStdout,
  1370.  VXIbool          keepLogFileOpen,
  1371.  VXIbool          reportErrorText,
  1372.  const VXIVector *errorMapFiles
  1373. )
  1374. {
  1375.   return SBlogListenerInitEx3(filename, fileMimeType, maxLogSizeBytes, 
  1376.                               logContentDir, maxContentDirSize, logToStdout, keepLogFileOpen,
  1377.                               TRUE, reportErrorText, errorMapFiles);
  1378. }
  1380. SBLOGLISTENERS_API VXIlogResult SBlogListenerInitEx3
  1381. (
  1382.  const VXIchar   *filename,
  1383.  const VXIchar   *fileMimeType,
  1384.  VXIint32         maxLogSizeBytes,
  1385.  const VXIchar   *logContentDir,
  1386.  VXIint32         maxContentDirSize,
  1387.  VXIbool          logToStdout,
  1388.  VXIbool          keepLogFileOpen,
  1389.  VXIbool          logPerformanceCounter,
  1390.  VXIbool          reportErrorText,
  1391.  const VXIVector *errorMapFiles
  1392. )
  1393. {
  1394.   if (g_LogStream != NULL) {
  1395.     SBlogLogStream::GlobalError(SBLOG_ERR_NOT_INITIALIZED);
  1396.     return VXIlog_RESULT_NON_FATAL_ERROR;
  1397.   }
  1398.   g_LogStream = new SBlogLogStream();
  1399.   if (!g_LogStream) {
  1400.     SBlogLogStream::GlobalError(SBLOG_ERR_OUT_OF_MEMORY);
  1401.     return VXIlog_RESULT_OUT_OF_MEMORY;
  1402.   }
  1403.   gblLogPerformanceCounter = logPerformanceCounter;
  1404.   return g_LogStream->Init(filename, fileMimeType, maxLogSizeBytes, 
  1405.                            logContentDir, maxContentDirSize, logToStdout,
  1406.                            keepLogFileOpen, reportErrorText, errorMapFiles);
  1407. }
  1409. SBLOGLISTENERS_API VXIlogResult SBlogListenerShutDown()
  1410. {
  1411.   if (g_LogStream == NULL) {
  1412.     SBlogLogStream::GlobalError(SBLOG_ERR_NOT_INITIALIZED);
  1413.     return VXIlog_RESULT_NON_FATAL_ERROR;
  1414.   }
  1415.   VXIlogResult ret = g_LogStream->ShutDown();
  1416.   if (ret) {
  1417.     return ret;
  1418.   }
  1419.   delete g_LogStream;
  1420.   g_LogStream = NULL;
  1421.   return ret;
  1422. }
  1425. SBLOGLISTENERS_API VXIlogResult ControlDiagnosticTag
  1426. (
  1427.  VXIlogInterface *pThis,
  1428.  VXIunsigned tagID,
  1429.  VXIbool     state
  1430. )
  1431. {
  1432.   if ( pThis == NULL ) {
  1433.     SBlogLogStream::GlobalError(254, 
  1434.                            L"SBlogListeners: Invalid argument to API function",
  1435.                            L"%s%s", L"function", L"ControlDiagnosticTag");
  1436.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1437.   }
  1438.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1439.   return( logIntf->ControlDiagnosticTag(logIntf, tagID, state) );
  1440. }
  1442. SBLOGLISTENERS_API VXIlogResult RegisterErrorListener
  1443. (
  1444.   VXIlogInterface           *pThis,
  1445.   SBlogErrorListener        *alistener,
  1446.   SBlogListenerChannelData  *channelData
  1447. )
  1448. {
  1449.   if ((pThis == NULL) || (channelData == NULL)) {
  1450.     SBlogLogStream::GlobalError(254, 
  1451.                            L"SBlogListeners: Invalid argument to API function",
  1452.                            L"%s%s", L"function", L"RegisterErrorListener");
  1453.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1454.   }
  1455.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1456.   return ( logIntf->RegisterErrorListener(logIntf,alistener,channelData) );
  1457. }
  1459. SBLOGLISTENERS_API VXIlogResult UnregisterErrorListener
  1460. (
  1461.   VXIlogInterface           *pThis,
  1462.   SBlogErrorListener        *alistener,
  1463.   SBlogListenerChannelData  *channelData
  1464. )
  1465. {
  1466.   if ((pThis == NULL) || (channelData == NULL)) {
  1467.     SBlogLogStream::GlobalError(254, 
  1468.           L"SBlogListeners: Invalid argument to API function",
  1469.           L"%s%s", L"function", L"UnregisterErrorListener");
  1470.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1471.   }
  1472.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1473.   return ( logIntf->UnregisterErrorListener(logIntf,alistener,channelData) );
  1475. }
  1477. SBLOGLISTENERS_API VXIlogResult RegisterDiagnosticListener
  1478. (
  1479.   VXIlogInterface           *pThis,
  1480.   SBlogDiagnosticListener   *alistener,
  1481.   SBlogListenerChannelData  *channelData
  1482. )
  1483. {
  1484.   if ((pThis == NULL) || (channelData == NULL)) {
  1485.     SBlogLogStream::GlobalError(254, 
  1486.                 L"SBlogListeners: Invalid argument to API function",
  1487.                 L"%s%s", L"function", L"RegisterDiagnosticListener");
  1488.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1489.   }
  1490.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1491.   return (logIntf->RegisterDiagnosticListener(logIntf,alistener,channelData));
  1492. }
  1494. SBLOGLISTENERS_API VXIlogResult UnregisterDiagnosticListener
  1495. (
  1496.   VXIlogInterface           *pThis,
  1497.   SBlogDiagnosticListener   *alistener,
  1498.   SBlogListenerChannelData  *channelData
  1499. )
  1500. {
  1501.   if ((pThis == NULL) || (channelData == NULL)) {
  1502.     SBlogLogStream::GlobalError(254,
  1503.           L"SBlogListeners: Invalid argument to API function",
  1504.           L"%s%s", L"function", L"UnregisterDiagnosticListener");
  1505.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1506.   }
  1507.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1508.   return (logIntf->UnregisterDiagnosticListener(logIntf,alistener,channelData));
  1509. }
  1511. SBLOGLISTENERS_API VXIlogResult RegisterEventListener
  1512. (
  1513.   VXIlogInterface           *pThis,
  1514.   SBlogEventListener        *alistener,
  1515.   SBlogListenerChannelData  *channelData
  1516. )
  1517. {
  1518.   if ((pThis == NULL) || (channelData == NULL)) {
  1519.     SBlogLogStream::GlobalError(254,
  1520.           L"SBlogListeners: Invalid argument to API function",
  1521.           L"%s%s", L"function", L"RegisterEventListener");
  1522.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1523.   }
  1524.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1525.   return(logIntf->RegisterEventListener(logIntf,alistener,channelData));
  1526. } 
  1527.  
  1528. SBLOGLISTENERS_API VXIlogResult UnregisterEventListener
  1529. (
  1530.   VXIlogInterface           *pThis,
  1531.   SBlogEventListener        *alistener,
  1532.   SBlogListenerChannelData  *channelData
  1533. )
  1534. {
  1535.   if ((pThis == NULL) || (channelData == NULL)) {
  1536.     SBlogLogStream::GlobalError(254,
  1537.           L"SBlogListeners: Invalid argument to API function",
  1538.           L"%s%s", L"function", L"UnregisterEventListener");
  1539.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1540.   }
  1541.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1542.   return(logIntf->UnregisterEventListener(logIntf,alistener,channelData));  
  1543. }
  1545. SBLOGLISTENERS_API VXIlogResult RegisterContentListener
  1546. (
  1547.   VXIlogInterface           *pThis,
  1548.   SBlogContentListener      *alistener,
  1549.   SBlogListenerChannelData  *channelData
  1550. )
  1551. {
  1552.   if ((pThis == NULL) || (channelData == NULL)) {
  1553.     SBlogLogStream::GlobalError(254,
  1554.           L"SBlogListeners: Invalid argument to API function",
  1555.           L"%s%s", L"function", L"RegisterContentListener");
  1556.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1557.   }
  1558.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1559.   return(logIntf->RegisterContentListener(logIntf,alistener,channelData));
  1560. } 
  1561.  
  1562. SBLOGLISTENERS_API VXIlogResult UnregisterContentListener
  1563. (
  1564.   VXIlogInterface           *pThis,
  1565.   SBlogContentListener      *alistener,
  1566.   SBlogListenerChannelData  *channelData
  1567. )
  1568. {
  1569.   if ((pThis == NULL) || (channelData == NULL)) {
  1570.     SBlogLogStream::GlobalError(254,
  1571.           L"SBlogListeners: Invalid argument to API function",
  1572.           L"%s%s", L"function", L"UnregisterContentListener");
  1573.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1574.   }
  1575.   SBlogInterface *logIntf = (SBlogInterface *)pThis;
  1576.   return(logIntf->UnregisterContentListener(logIntf,alistener,channelData));  
  1577. }