sblog.cpp

sloedgy open sip stack source code

   
   // Get a temporary callback vector copy to traverse, allows
   // listeners to unregister from within the listener, also increases
   // parallelism by allowing multiple threads to be calling the
   // callbacks at once
   if (rc == VXIlog_RESULT_SUCCESS)
     rc = VXIlog_RESULT_FAILURE;
   if (! Lock( )) {
     return VXIlog_RESULT_SYSTEM_ERROR;
   } else {
     EVENTCALLBACKS tempEvent = eventCallbacks;
 
     if (! Unlock( ))
       return VXIlog_RESULT_SYSTEM_ERROR;
   
     for (EVENTCALLBACKS::iterator i = tempEvent.begin();
 	 i != tempEvent.end(); ++i)
       {
 	(*i)->callback(_pThis, eventID, timestamp, timestampMsec, keys, values,
 		       (*i)->userdata);
 	if (rc == VXIlog_RESULT_FAILURE)
 	  rc = VXIlog_RESULT_SUCCESS;
       }
   }
   
   VXIVectorDestroy(&keys);
   VXIVectorDestroy(&values);
 
   return rc;
 }
 
 
 VXIlogResult SBlog::EventLog(VXIunsigned      eventID,
 			     const VXIVector* keys,
 			     const VXIVector* values) const
 {
   time_t timestamp;
   VXIunsigned timestampMsec;
   SBlogGetTime (&timestamp, &timestampMsec);
 
   // Get a temporary callback vector copy to traverse, allows
   // listeners to unregister from within the listener, also increases
   // parallelism by allowing multiple threads to be calling the
   // callbacks at once
   VXIlogResult rc = VXIlog_RESULT_FAILURE;
   if (! Lock( )) {
     return VXIlog_RESULT_SYSTEM_ERROR;
   } else {
     EVENTCALLBACKS tempEvent = eventCallbacks;
 
     if (! Unlock( ))
       return VXIlog_RESULT_SYSTEM_ERROR;
   
     for (EVENTCALLBACKS::iterator i = tempEvent.begin();
 	 i != tempEvent.end(); ++i)
       {
 	(*i)->callback(_pThis, eventID, timestamp, timestampMsec, keys, values,
 		       (*i)->userdata);
 	rc = VXIlog_RESULT_SUCCESS;
       }
   }
 
   return rc;
 }
 
 
 VXIlogResult SBlog::ErrorLog(const VXIchar*   moduleName,
                              VXIunsigned      errorID,
                              const VXIchar*   format,
                              va_list          args) const
 {
   time_t  timestamp;
   VXIunsigned timestampMsec;
   SBlogGetTime (&timestamp, &timestampMsec);
 
   // Create key/value pairs
   VXIVector *keys = VXIVectorCreate();
   VXIVector *values = VXIVectorCreate();
   if ((! keys) || (! values)) {
     Error(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
   
   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
   if (format) {
     rc = ParseKeyValue(format, args, keys, values);
     if (rc < VXIlog_RESULT_SUCCESS) {
       VXIVectorDestroy(&keys);
       VXIVectorDestroy(&values);
       return rc;
     }
   }
   
   // Get a temporary callback vector copy to traverse, allows
   // listeners to unregister from within the listener, also increases
   // parallelism by allowing multiple threads to be calling the
   // callbacks at once
   if (rc == VXIlog_RESULT_SUCCESS)
     rc = VXIlog_RESULT_FAILURE;
   if (! Lock( )) {
     return VXIlog_RESULT_SYSTEM_ERROR;
   } else {
     ERRORCALLBACKS tempError = errorCallbacks;
 
     if (! Unlock( ))
       return VXIlog_RESULT_SYSTEM_ERROR; 
 
     for (ERRORCALLBACKS::iterator i = tempError.begin();
 	 i != tempError.end(); ++i)
       {
 	(*i)->callback(_pThis, 
 		       (moduleName && moduleName[0] ? moduleName : L"UNKNOWN"),
 		       errorID, timestamp, timestampMsec, keys, values, 
 		       (*i)->userdata);
 	if (rc == VXIlog_RESULT_FAILURE)
 	  rc = VXIlog_RESULT_SUCCESS;
       }
   }
   
   VXIVectorDestroy(&keys);
   VXIVectorDestroy(&values); 
 
   // Want to warn the caller that NULL moduleName really isn't OK, but
   // logged it anyway
   if ((! moduleName) || (! moduleName[0])) {
     Error(305, L"SBlog: Empty module name passed to VXIlog API call", NULL);
     rc = VXIlog_RESULT_INVALID_ARGUMENT;
   }
   
   return rc;
 }
 
 
 VXIlogResult SBlog::ContentOpen(const VXIchar*      moduleName,
 				const VXIchar*      contentType,
 				VXIString**         logKey,
 				VXIString**         logValue,
 				VXIlogStream**      stream) const
 {
   if ((! contentType) || (! contentType[0]) || (! logKey) || (! logValue) ||
       (! stream)) {
     Error(306, L"SBlog: Invalid argument to VXIlog::ContentOpen()", NULL);
     return VXIlog_RESULT_INVALID_ARGUMENT;
   }
 
   *logKey = *logValue = NULL;
   *stream = NULL;
 
   const VXIchar *finalModuleName = L"UNKNOWN";
   if ((! moduleName) || (! moduleName[0])) {
     Error(305, L"SBlog: Empty module name passed to VXIlog API call", NULL);
   } else {
     finalModuleName = moduleName;
   }
 
   VXIlogResult rc = VXIlog_RESULT_FAILURE;
 
   // Get a temporary callback vector copy to traverse, allows
   // listeners to unregister from within the listener, also increases
   // parallelism by allowing multiple threads to be calling the
   // callbacks at once
   if (! Lock( )) {
     return VXIlog_RESULT_SYSTEM_ERROR;
   } else {
     CONTENTCALLBACKS tempContent = contentCallbacks;
 
     if (! Unlock( ))
       return VXIlog_RESULT_SYSTEM_ERROR; 
 
     VXIlogStream *finalStream = NULL;
 
     for (CONTENTCALLBACKS::iterator i = tempContent.begin();
         i != tempContent.end(); ++i)
     {
       VXIString *logKey_    = NULL;
       VXIString *logValue_  = NULL;
       SBlogStream *stream_  = NULL;
 
       VXIlogResult rc2 = (*i)->callback(_pThis, 
 					finalModuleName,
 					contentType, 
 					(*i)->userdata,
 					&logKey_,
 					&logValue_,
 					&stream_);
       if ((rc2 == VXIlog_RESULT_SUCCESS) && (stream_)) {
 	// Return the key and value of only the first listener
 	if ( rc != VXIlog_RESULT_SUCCESS ) {
 	  finalStream = new VXIlogStream;
 	  if (! finalStream) {
 	    VXIStringDestroy(&logKey_);       
 	    VXIStringDestroy(&logValue_);
 	    stream_->Close(&stream_);
 	    Error(SBLOG_ERR_OUT_OF_MEMORY);
 	    return VXIlog_RESULT_OUT_OF_MEMORY;
 	  }
 
 	  rc = VXIlog_RESULT_SUCCESS;
 	  *logKey = logKey_;
 	  *logValue = logValue_;
 	  *stream = (VXIlogStream *) finalStream;
 	} else {
 	  VXIStringDestroy(&logKey_);       
 	  VXIStringDestroy(&logValue_);
 	}
 
 	// Store the stream
 	finalStream->streams.push_back(stream_);
       } else if ((rc != VXIlog_RESULT_SUCCESS) &&
 		 (((rc < 0) && (rc2 < rc)) ||
 		  ((rc > 0) && (rc2 > rc)))) {
 	// Return success if any listener returns success but keep the
 	// worst error otherwise
 	rc = rc2;
       }
     }
   }
 
   return rc;
 }
 
 
 VXIlogResult SBlog::ContentClose(VXIlogStream**     stream) const
 {
   if ((! stream) || (! *stream)) {
     Error(307, L"SBlog: Invalid argument to VXIlog::ContentClose()", NULL);
     return VXIlog_RESULT_INVALID_ARGUMENT;
   }
   
   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
 
   // Close each of the underlying listener streams
   for (VXIlogStream::STREAMS::iterator vi = (*stream)->streams.begin( );
        vi != (*stream)->streams.end( ); vi++) {
     SBlogStream *s = *vi;
     VXIlogResult rc2 = s->Close (&s);
     if ((rc == VXIlog_RESULT_SUCCESS) || ((rc < 0) && (rc2 < rc)) ||
 	((rc > 0) && (rc2 > rc)))
       rc = rc2;
   }
 
   delete *stream;
   *stream = NULL; 
   return rc;
 }
 
 
 VXIlogResult SBlog::ContentWrite(const VXIbyte*     buffer,
 				 VXIulong           buflen,
 				 VXIulong*          nwritten,
 				 VXIlogStream*      stream) const
 {
   if ((! buffer) || (buflen < 1) || (! nwritten) || (! stream)) {
     Error(308, L"SBlog: Invalid argument to VXIlog::ContentWrite()", NULL);
     return VXIlog_RESULT_INVALID_ARGUMENT;
   }
   
   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
   *nwritten = 0;
 
   // Write to each of the underlying listener streams
   for (VXIlogStream::STREAMS::iterator vi = stream->streams.begin( );
        vi != stream->streams.end( ); vi++) {
     SBlogStream *s = *vi;
     VXIulong nw = 0;
     VXIlogResult rc2 = s->Write (s, buffer, buflen, &nw);
     if (rc == VXIlog_RESULT_SUCCESS) {
       if (nw > *nwritten)
 	*nwritten = nw;
     } else if ((rc == VXIlog_RESULT_SUCCESS) || ((rc < 0) && (rc2 < rc)) ||
 	       ((rc > 0) && (rc2 > rc))) {
       rc = rc2;
     }
   }
 
   return rc;
 }
 
   
 /***********************************************************************/
 
 VXIlogResult SBlogControlDiagnosticTag(SBlogInterface *pThis,
                                        VXIunsigned tagID,
                                        VXIbool     state)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   return (me->ControlDiagnosticTag(tagID, state));
 }
 
 
 VXIlogResult SBlogRegisterErrorListener(SBlogInterface *pThis,
                                         SBlogErrorListener* alistener,
                                         void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogErrorCallbackData *info = new SBlogErrorCallbackData;
   if (info == NULL) {
     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
  
   info->callback = alistener;
   info->userdata = userdata;
   return ( me->RegisterErrorListener(info));
 } 
 
 
 VXIlogResult SBlogUnregisterErrorListener(SBlogInterface *pThis,
                                           SBlogErrorListener* alistener,
                                           void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogErrorCallbackData info = { alistener, userdata };
   SBlogErrorCallbackData *p = me->UnregisterErrorListener(&info);
   if (p) delete p;
   return VXIlog_RESULT_SUCCESS;
 } 
 
 
 VXIlogResult SBlogRegisterDiagnosticListener(SBlogInterface *pThis,
                                              SBlogDiagnosticListener*alistener,
                                              void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogDiagCallbackData *info = new SBlogDiagCallbackData;
   if (info == NULL) {
     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
  
   info->callback = alistener;
   info->userdata = userdata;
   return ( me->RegisterDiagnosticListener(info));
 } 
 
 VXIlogResult SBlogUnregisterDiagnosticListener(
                                      SBlogInterface *pThis,
                                      SBlogDiagnosticListener* alistener,
                                      void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogDiagCallbackData info = { alistener, userdata };
   SBlogDiagCallbackData *p = me->UnregisterDiagnosticListener(&info);
   if (p) delete p;
 
   return VXIlog_RESULT_SUCCESS;
 } 
 
 
 VXIlogResult SBlogRegisterEventListener(SBlogInterface *pThis,
                                         SBlogEventListener* alistener,
                                         void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogEventCallbackData *info = new SBlogEventCallbackData;
   if (info == NULL) {
     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
  
   info->callback = alistener;
   info->userdata = userdata;
   return ( me->RegisterEventListener(info));
 } 
 
 
 VXIlogResult SBlogUnregisterEventListener(SBlogInterface *pThis,
                                           SBlogEventListener* alistener,
                                           void*  userdata)