mirror of
https://github.com/Ylianst/MeshAgent
synced 2025-12-06 00:13:33 +00:00
690 lines
28 KiB
C
690 lines
28 KiB
C
/*
|
|
Copyright 2006 - 2022 Intel Corporation
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
|
|
|
|
#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(_MINCORE)
|
|
#define _CRTDBG_MAP_ALLOC
|
|
#include <crtdbg.h>
|
|
#endif
|
|
|
|
#include "ILibRemoteLogging.h"
|
|
#include "ILibParsers.h"
|
|
#include "ILibWebServer.h"
|
|
#include "ILibCrypto.h"
|
|
#include <stdarg.h>
|
|
|
|
char ILibScratchPad_RemoteLogging[520];
|
|
//! Converts a sockaddr to a friendly string, using static memory, for logging purposes
|
|
/*!
|
|
\param addr sockaddr to convert
|
|
\return friendly string representation (NULL Terminated)
|
|
*/
|
|
char* ILibRemoteLogging_ConvertAddress(struct sockaddr* addr)
|
|
{
|
|
ILibInet_ntop2((struct sockaddr*)addr, ILibScratchPad_RemoteLogging, sizeof(ILibScratchPad_RemoteLogging));
|
|
return(ILibScratchPad_RemoteLogging);
|
|
}
|
|
|
|
#ifdef _REMOTELOGGING
|
|
|
|
typedef struct ILibRemoteLogging_Session
|
|
{
|
|
unsigned int Flags;
|
|
void* UserContext;
|
|
}ILibRemoteLogging_Session;
|
|
|
|
typedef struct ILibRemoteLogging_Module
|
|
{
|
|
sem_t LogSyncLock;
|
|
unsigned int LogFlags;
|
|
|
|
ILibRemoteLogging_OnWrite OutputSink;
|
|
ILibRemoteLogging_OnRawForward RawForwardSink;
|
|
int RawForwardOffset;
|
|
ILibRemoteLogging_OnCommand CommandSink[15];
|
|
ILibRemoteLogging_Session Sessions[5];
|
|
}ILibRemoteLogging_Module;
|
|
|
|
void ILibRemoteLogging_Destroy(ILibRemoteLogging module)
|
|
{
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)module;
|
|
if (obj != NULL)
|
|
{
|
|
sem_destroy(&(obj->LogSyncLock));
|
|
free(module);
|
|
}
|
|
}
|
|
|
|
void ILibRemoteLogging_CompactSessions(ILibRemoteLogging_Session sessions[], int sessionsLength)
|
|
{
|
|
int x=0,y=0;
|
|
for(x=0;x<sessionsLength;++x)
|
|
{
|
|
if(sessions[x].UserContext == NULL)
|
|
{
|
|
for(y=x+1;y<sessionsLength;++y)
|
|
{
|
|
if(sessions[y].UserContext != NULL)
|
|
{
|
|
memcpy_s(&sessions[x], sizeof(ILibRemoteLogging_Session), &sessions[y], sizeof(ILibRemoteLogging_Session));
|
|
memset(&sessions[y], 0, sizeof(ILibRemoteLogging_Session));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void ILibRemoteLogging_RemoveUserContext(ILibRemoteLogging_Session sessions[], int sessionsLength, void *userContext)
|
|
{
|
|
int i;
|
|
for(i=0;i<sessionsLength;++i)
|
|
{
|
|
if(sessions[i].UserContext == NULL){break;}
|
|
if(sessions[i].UserContext == userContext)
|
|
{
|
|
memset(&sessions[i], 0, sizeof(ILibRemoteLogging_Session));
|
|
ILibRemoteLogging_CompactSessions(sessions, sessionsLength);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
ILibRemoteLogging_Session* ILibRemoteLogging_GetSession(ILibRemoteLogging_Session sessions[], int sessionsLength, void *userContext)
|
|
{
|
|
int i;
|
|
ILibRemoteLogging_Session *retVal = NULL;
|
|
for(i=0;i<sessionsLength;++i)
|
|
{
|
|
if(sessions[i].UserContext == NULL)
|
|
{
|
|
sessions[i].Flags = 0x00;
|
|
sessions[i].UserContext = userContext;
|
|
retVal = &sessions[i];
|
|
break;
|
|
}
|
|
else if(sessions[i].UserContext == userContext)
|
|
{
|
|
retVal = &sessions[i];
|
|
break;
|
|
}
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
void ILibRemoteLogging_LoggerCommand_Default(ILibRemoteLogging sender, ILibRemoteLogging_Modules module, unsigned short flags, char* data, int dataLen, void *userContext)
|
|
{
|
|
int len;
|
|
char buf[72];
|
|
|
|
((unsigned short*)buf)[0] = htons((unsigned short)ILibRemoteLogging_Modules_Logger | (unsigned short)0x8000);
|
|
((unsigned short*)buf)[1] = htons(ILibRemoteLogging_Flags_VerbosityLevel_1);
|
|
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "*** ILibRemoteLogging_FileTransport [No Logfile Set] ***");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
void ILibRemoteLogging_SetRawForward(ILibRemoteLogging logger, int bufferOffset, ILibRemoteLogging_OnRawForward onRawForward)
|
|
{
|
|
((ILibRemoteLogging_Module*)logger)->RawForwardSink = onRawForward;
|
|
((ILibRemoteLogging_Module*)logger)->RawForwardOffset = bufferOffset;
|
|
}
|
|
ILibRemoteLogging ILibRemoteLogging_Create(ILibRemoteLogging_OnWrite onOutput)
|
|
{
|
|
ILibRemoteLogging_Module *retVal;
|
|
if((retVal = (ILibRemoteLogging_Module*)malloc(sizeof(ILibRemoteLogging_Module)))==NULL) {ILIBCRITICALEXIT(254);}
|
|
memset(retVal, 0, sizeof(ILibRemoteLogging_Module));
|
|
|
|
sem_init(&(retVal->LogSyncLock), 0, 1);
|
|
retVal->OutputSink = onOutput;
|
|
|
|
ILibRemoteLogging_RegisterCommandSink(retVal, ILibRemoteLogging_Modules_Logger, ILibRemoteLogging_LoggerCommand_Default);
|
|
|
|
return retVal;
|
|
}
|
|
|
|
void ILibRemoteLogging_RegisterCommandSink(ILibRemoteLogging logger, ILibRemoteLogging_Modules module, ILibRemoteLogging_OnCommand sink)
|
|
{
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)logger;
|
|
if (module < 0) { return; }
|
|
|
|
sem_wait(&(obj->LogSyncLock));
|
|
obj->CommandSink[ILibWhichPowerOfTwo((int)module)] = sink;
|
|
sem_post(&(obj->LogSyncLock));
|
|
}
|
|
|
|
|
|
void ILibRemoteLogging_DeleteUserContext(ILibRemoteLogging logger, void *userContext)
|
|
{
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)logger;
|
|
if (obj == NULL) { return; }
|
|
|
|
sem_wait(&(obj->LogSyncLock));
|
|
ILibRemoteLogging_RemoveUserContext(obj->Sessions, sizeof(obj->Sessions) / sizeof(ILibRemoteLogging_Session), userContext);
|
|
sem_post(&(obj->LogSyncLock));
|
|
}
|
|
|
|
//! Converts binary data into a hex string, using static memory, for logging purposes
|
|
/*!
|
|
\param inVal Binary data to convert
|
|
\param inValLength Binary data length
|
|
\return hex string representation of binary data (NULL Terminated)
|
|
*/
|
|
char* ILibRemoteLogging_ConvertToHex(char* inVal, int inValLength)
|
|
{
|
|
util_tohex(inVal, inValLength<255?inValLength:254, ILibScratchPad_RemoteLogging);
|
|
return(ILibScratchPad_RemoteLogging);
|
|
}
|
|
|
|
void ILibRemoteLogging_SendCommand(ILibRemoteLogging loggingModule, ILibRemoteLogging_Modules module, ILibRemoteLogging_Flags flags, char *data, int dataLen, void *userContext)
|
|
{
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)loggingModule;
|
|
char dest[4096];
|
|
|
|
if(obj->OutputSink != NULL && ((dataLen + 4) < 4096))
|
|
{
|
|
((unsigned short*)dest)[0] = htons(module);
|
|
((unsigned short*)dest)[1] = htons(flags);
|
|
if(dataLen > 0) {memcpy_s(dest+4, sizeof(dest) - 4, data, dataLen);}
|
|
obj->OutputSink(loggingModule, dest, 4+dataLen, userContext);
|
|
}
|
|
}
|
|
//! Logging method using printf notation
|
|
/*!
|
|
\b NOTE: NO-OP if there is no connected viewers
|
|
\param loggingModule ILibRemoteLogging Logging Module
|
|
\param module ILibRemoteLogging_Modules Describing the source of the message
|
|
\param flags ILibRemoteLogging_Flags Logging Flags
|
|
\param format printf Format String
|
|
\param ... Optional parameters
|
|
*/
|
|
void ILibRemoteLogging_printf(ILibRemoteLogging loggingModule, ILibRemoteLogging_Modules module, ILibRemoteLogging_Flags flags, char* format, ...)
|
|
{
|
|
int i;
|
|
char dest[4096];
|
|
int len;
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)loggingModule;
|
|
|
|
va_list argptr;
|
|
|
|
if (obj != NULL && obj->RawForwardSink != NULL)
|
|
{
|
|
// When Forwarding, TimeStamp will be added later
|
|
len = obj->RawForwardOffset;
|
|
}
|
|
else
|
|
{
|
|
// Add TimeStamp to Log
|
|
len = ILibGetLocalTime(dest + 4, (int)sizeof(dest) - 4);
|
|
dest[len + 4] = ':';
|
|
dest[len + 5] = ' ';
|
|
len += 2;
|
|
|
|
len += 4; // Space for header (which isn't needed when forwarding)
|
|
}
|
|
|
|
va_start(argptr, format);
|
|
len += vsnprintf(dest+len, 4096 - len, format, argptr);
|
|
va_end(argptr);
|
|
|
|
if (obj != NULL && obj->RawForwardSink != NULL)
|
|
{
|
|
obj->RawForwardSink(obj, module, flags, dest, len);
|
|
}
|
|
else if(obj != NULL && obj->OutputSink != NULL)
|
|
{
|
|
((unsigned short*)dest)[0] = htons((unsigned short)module | (unsigned short)0x8000);
|
|
((unsigned short*)dest)[1] = htons(flags);
|
|
|
|
if ((module & ILibRemoteLogging_Modules_ConsolePrint) == ILibRemoteLogging_Modules_ConsolePrint) { printf("%s\n", dest + 4); }
|
|
|
|
sem_wait(&(obj->LogSyncLock));
|
|
for(i=0;i<(sizeof(obj->Sessions)/sizeof(ILibRemoteLogging_Session)); ++i)
|
|
{
|
|
if(obj->Sessions[i].UserContext == NULL) {break;} // No more Sessions
|
|
if((obj->Sessions[i].Flags & (unsigned int)module) == 0) {continue;} // Logging for this module is not enabled
|
|
if(((obj->Sessions[i].Flags >> 16) & 0x3E) < (unsigned short)flags) {continue;} // Verbosity is not high enough
|
|
sem_post(&(obj->LogSyncLock));
|
|
obj->OutputSink(obj, dest, len, obj->Sessions[i].UserContext);
|
|
sem_wait(&(obj->LogSyncLock));
|
|
}
|
|
sem_post(&(obj->LogSyncLock));
|
|
}
|
|
else if (obj == NULL && (module & ILibRemoteLogging_Modules_ConsolePrint) == ILibRemoteLogging_Modules_ConsolePrint)
|
|
{
|
|
printf("%s\n", dest + 4);
|
|
}
|
|
}
|
|
void ILibRemoteLogging_Dispatch_Update(ILibRemoteLogging_Module *obj, unsigned short module, char* updateString, void *userContext)
|
|
{
|
|
char temp[255];
|
|
int tempLen;
|
|
|
|
tempLen = ILibGetLocalTime((char*)temp, (int)sizeof(temp));
|
|
temp[tempLen] = ':';
|
|
temp[tempLen + 1] = ' ';
|
|
tempLen += 2;
|
|
|
|
if((module & ILibRemoteLogging_Modules_WebRTC_STUN_ICE) == ILibRemoteLogging_Modules_WebRTC_STUN_ICE)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "WebRTC Module: STUN/ICE [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_WebRTC_STUN_ICE | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if((module & ILibRemoteLogging_Modules_WebRTC_DTLS) == ILibRemoteLogging_Modules_WebRTC_DTLS)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "WebRTC Module: DTLS [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_WebRTC_DTLS | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if((module & ILibRemoteLogging_Modules_WebRTC_SCTP) == ILibRemoteLogging_Modules_WebRTC_SCTP)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "WebRTC Module: SCTP [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_WebRTC_SCTP | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if ((module & ILibRemoteLogging_Modules_Agent_GuardPost) == ILibRemoteLogging_Modules_Agent_GuardPost)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "Agent Module: GuardPost [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_Agent_GuardPost | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if ((module & ILibRemoteLogging_Modules_Agent_P2P) == ILibRemoteLogging_Modules_Agent_P2P)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "Agent Module: Peer2Peer [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_Agent_P2P | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if ((module & ILibRemoteLogging_Modules_Microstack_AsyncSocket) == ILibRemoteLogging_Modules_Microstack_AsyncSocket)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "Microstack Module: AsyncSocket [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_Microstack_AsyncSocket | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if ((module & ILibRemoteLogging_Modules_Microstack_Web) == ILibRemoteLogging_Modules_Microstack_Web)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "Microstack Module: WebServer/Client [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_Microstack_Web | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if ((module & ILibRemoteLogging_Modules_Microstack_Generic) == ILibRemoteLogging_Modules_Microstack_Generic)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "Microstack Module: Generic [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_Microstack_Generic | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if ((module & ILibRemoteLogging_Modules_Agent_KVM) == ILibRemoteLogging_Modules_Agent_KVM)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "Agent Module: KVM [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_Agent_KVM | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
if ((module & ILibRemoteLogging_Modules_Microstack_Pipe) == ILibRemoteLogging_Modules_Microstack_Pipe)
|
|
{
|
|
tempLen += sprintf_s(temp + tempLen, sizeof(temp) - tempLen, "Microstack Module: NamedPipe [%s]", updateString);
|
|
ILibRemoteLogging_SendCommand(obj, (ILibRemoteLogging_Modules)(ILibRemoteLogging_Modules_Microstack_Pipe | 0x8000), ILibRemoteLogging_Flags_VerbosityLevel_1, temp, tempLen, userContext);
|
|
}
|
|
}
|
|
int ILibRemoteLogging_IsModuleSet(ILibRemoteLogging loggingModule, ILibRemoteLogging_Modules module)
|
|
{
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)loggingModule;
|
|
int i;
|
|
int retVal = 0;
|
|
sem_wait(&(obj->LogSyncLock));
|
|
for (i = 0; i < sizeof(obj->Sessions) / sizeof(ILibRemoteLogging_Session); ++i)
|
|
{
|
|
if (obj->Sessions[i].UserContext == NULL) { break; }
|
|
if ((obj->Sessions[i].Flags & (unsigned int)module) == (unsigned int)module) { retVal = 1; break; }
|
|
}
|
|
sem_post(&(obj->LogSyncLock));
|
|
return retVal;
|
|
}
|
|
void ILibRemoteLogging_Forward(ILibRemoteLogging loggingModule, char* data, int dataLen)
|
|
{
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)loggingModule;
|
|
int i;
|
|
if (obj->OutputSink == NULL) { return; }
|
|
|
|
sem_wait(&(obj->LogSyncLock));
|
|
for (i = 0; i < sizeof(obj->Sessions) / sizeof(ILibRemoteLogging_Session); ++i)
|
|
{
|
|
if (obj->Sessions[i].UserContext == NULL) { sem_post(&(obj->LogSyncLock)); return; }
|
|
sem_post(&(obj->LogSyncLock));
|
|
obj->OutputSink(obj, data, dataLen, obj->Sessions[i].UserContext);
|
|
sem_wait(&(obj->LogSyncLock));
|
|
}
|
|
sem_post(&(obj->LogSyncLock));
|
|
}
|
|
int ILibRemoteLogging_Dispatch(ILibRemoteLogging loggingModule, char* data, int dataLen, void *userContext)
|
|
{
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)loggingModule;
|
|
unsigned short module;
|
|
unsigned short flags;
|
|
|
|
ILibRemoteLogging_Session *session = NULL;
|
|
|
|
if(dataLen == 0 || userContext == NULL)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
module = ILibRemoteLogging_ReadModuleType(data);
|
|
flags = ILibRemoteLogging_ReadFlags(data);
|
|
|
|
sem_wait(&(obj->LogSyncLock));
|
|
session = ILibRemoteLogging_GetSession(obj->Sessions, sizeof(obj->Sessions) / sizeof(ILibRemoteLogging_Session), userContext);
|
|
if(session == NULL) {sem_post(&(obj->LogSyncLock)); return 1;} // Too many users
|
|
|
|
if((flags & 0x3F) != 0x00)
|
|
{
|
|
// Change Verbosity of Logs
|
|
if((flags & 0x01) == 0x01)
|
|
{
|
|
// Disable Modules
|
|
session->Flags &= (0xFFFFFFFF ^ module);
|
|
sem_post(&(obj->LogSyncLock));
|
|
ILibRemoteLogging_Dispatch_Update(obj, module, "DISABLED", userContext);
|
|
|
|
}
|
|
else
|
|
{
|
|
// Enable Modules and Set Verbosity
|
|
session->Flags &= 0xFFC0FFFF; // Reset Verbosity Flags
|
|
session->Flags |= (flags << 16); // Set Verbosity Flags
|
|
session->Flags |= (unsigned int)module; // Enable Modules
|
|
sem_post(&(obj->LogSyncLock));
|
|
ILibRemoteLogging_Dispatch_Update(obj, module, "ENABLED", userContext);
|
|
}
|
|
}
|
|
else if(module != 0x00)
|
|
{
|
|
// Module Specific Commands
|
|
ILibRemoteLogging_OnCommand command = obj->CommandSink[ILibWhichPowerOfTwo((int)module)];
|
|
sem_post(&(obj->LogSyncLock));
|
|
if(command!=NULL)
|
|
{
|
|
command(loggingModule, (ILibRemoteLogging_Modules)module, flags, data+4, dataLen-4, userContext);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sem_post(&(obj->LogSyncLock));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
typedef struct ILibRemoteLogging_FileTransport
|
|
{
|
|
ILibTransport transport;
|
|
ILibLinkedList_FileBacked_Root *logFile;
|
|
char* localFilePath;
|
|
int enabled;
|
|
ILibRemoteLogging_Module* parent;
|
|
}ILibRemoteLogging_FileTransport;
|
|
|
|
ILibTransport_DoneState ILibFileTransport_SendSink(void *transport, char* buffer, int bufferLength, ILibTransport_MemoryOwnership ownership, ILibTransport_DoneState done)
|
|
{
|
|
ILibRemoteLogging_FileTransport *ft = (ILibRemoteLogging_FileTransport*)transport;
|
|
|
|
if (ft->logFile != NULL && ft->enabled != 0)
|
|
{
|
|
ILibLinkedList_FileBacked_AddTail(ft->logFile, buffer, bufferLength);
|
|
}
|
|
return(ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
unsigned int ILibFileTransport_PendingBytes(void *transport)
|
|
{
|
|
UNREFERENCED_PARAMETER(transport);
|
|
return 0;
|
|
}
|
|
void ILibFileTransport_CloseSink(void* transport)
|
|
{
|
|
ILibRemoteLogging_FileTransport *ft = (ILibRemoteLogging_FileTransport*)transport;
|
|
|
|
ILibRemoteLogging_DeleteUserContext(ft->parent, transport);
|
|
if (ft->logFile != NULL) { ILibLinkedList_FileBacked_Close(ft->logFile); }
|
|
if (ft->localFilePath != NULL) { free(ft->localFilePath); }
|
|
free(transport);
|
|
}
|
|
int ILibRemoteLogging_FileTransport_ReadLogs(ILibRemoteLogging_FileTransport* ft, void *userContext)
|
|
{
|
|
ILibLinkedList_FileBacked_Node *node = NULL;
|
|
|
|
if (ILibLinkedList_FileBacked_IsEmpty(ft->logFile) != 0)
|
|
{
|
|
// No log entries
|
|
return 1;
|
|
}
|
|
|
|
while ((node = ILibLinkedList_FileBacked_ReadNext(ft->logFile, node)) != NULL)
|
|
{
|
|
ILibTransport_Send(userContext, node->data, node->dataLen, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void ILibRemoteLogging_FileTransport_Report(void* userContext, ILibRemoteLogging_FileTransport *ft)
|
|
{
|
|
int len;
|
|
char buf[72];
|
|
|
|
unsigned short newModules = 0;
|
|
unsigned short flags = 0;
|
|
|
|
((unsigned short*)buf)[0] = htons((unsigned short)ILibRemoteLogging_Modules_Logger | (unsigned short)0x8000);
|
|
((unsigned short*)buf)[1] = htons(ILibRemoteLogging_Flags_VerbosityLevel_1);
|
|
|
|
if (ft->logFile == NULL)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "*** ILibRemoteLogging_FileTransport [No Logfile Set] ***");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
return;
|
|
}
|
|
|
|
ILibLinkedList_FileBacked_ReloadRoot(ft->logFile);
|
|
newModules = (unsigned short)(ft->logFile->flags & 0xFFFF);
|
|
flags = (unsigned short)((ft->logFile->flags >> 16) & 0x3F);
|
|
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "*** Verbosity = %d ***", ILibWhichPowerOfTwo((int)flags));
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
|
|
if ((newModules & ILibRemoteLogging_Modules_WebRTC_STUN_ICE) == ILibRemoteLogging_Modules_WebRTC_STUN_ICE)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...WebRTC [STUN/ICE]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_WebRTC_DTLS) == ILibRemoteLogging_Modules_WebRTC_DTLS)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...WebRTC [DTLS]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_WebRTC_SCTP) == ILibRemoteLogging_Modules_WebRTC_SCTP)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...WebRTC [SCTP]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_Agent_GuardPost) == ILibRemoteLogging_Modules_Agent_GuardPost)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...MeshAgent [GUARDPOST]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_Agent_KVM) == ILibRemoteLogging_Modules_Agent_KVM)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...MeshAgent [KVM]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_Agent_P2P) == ILibRemoteLogging_Modules_Agent_P2P)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...MeshAgent [P2P]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_Microstack_AsyncSocket) == ILibRemoteLogging_Modules_Microstack_AsyncSocket)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...Microstack [AsyncSocket]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_Microstack_Web) == ILibRemoteLogging_Modules_Microstack_Web)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...Microstack [WebServer]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_Microstack_Pipe) == ILibRemoteLogging_Modules_Microstack_Pipe)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...Microstack [Pipe]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
if ((newModules & ILibRemoteLogging_Modules_Microstack_Generic) == ILibRemoteLogging_Modules_Microstack_Generic)
|
|
{
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "...Microstack [Generic]");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
}
|
|
|
|
void ILibRemoteLogging_FileTransport_CommandSink(ILibRemoteLogging sender, ILibRemoteLogging_Modules module, unsigned short flags, char* data, int dataLen, void *userContext)
|
|
{
|
|
ILibRemoteLogging_Module *obj = (ILibRemoteLogging_Module*)sender;
|
|
int i, len;
|
|
char buf[72];
|
|
|
|
sem_wait(&(obj->LogSyncLock));
|
|
for (i = 0; i < (sizeof(obj->Sessions) / sizeof(ILibRemoteLogging_Session)); ++i)
|
|
{
|
|
if (obj->Sessions[i].UserContext == NULL) { break; } // End of Sessions
|
|
if (((ILibTransport*)obj->Sessions[i].UserContext)->IdentifierFlags == ILibTransports_RemoteLogging_FileTransport)
|
|
{
|
|
ILibRemoteLogging_FileTransport *ft = (ILibRemoteLogging_FileTransport*)obj->Sessions[i].UserContext;
|
|
// This command applies to this type of ILibTransport
|
|
|
|
|
|
if ((flags & ILibRemoteLogging_Command_Logger_Flags_ENABLE) == ILibRemoteLogging_Command_Logger_Flags_ENABLE)
|
|
{
|
|
switch (data[0])
|
|
{
|
|
case 0:
|
|
case 1:
|
|
// Enable/Disable
|
|
ILibLinkedList_FileBacked_ReloadRoot(ft->logFile);
|
|
ft->logFile->flags &= (unsigned int)0x7FFFFFFF;
|
|
ft->enabled = data[0];
|
|
if (ft->enabled != 0)
|
|
{
|
|
ft->logFile->flags |= (unsigned int)0x80000000;
|
|
}
|
|
ILibLinkedList_FileBacked_SaveRoot(ft->logFile);
|
|
|
|
((unsigned short*)buf)[0] = htons((unsigned short)ILibRemoteLogging_Modules_Logger | (unsigned short)0x8000);
|
|
((unsigned short*)buf)[1] = htons(ILibRemoteLogging_Flags_VerbosityLevel_1);
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "ILibRemoteLogging_FileTransport [%s]", ft->enabled == 0 ? "DISABLED" : "ENABLED");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
if (ft->enabled != 0)
|
|
{
|
|
ILibRemoteLogging_FileTransport_Report(userContext, ft);
|
|
}
|
|
break;
|
|
case 3:
|
|
// Return the current state
|
|
((unsigned short*)buf)[0] = htons(ILibRemoteLogging_Modules_Logger);
|
|
((unsigned short*)buf)[1] = htons(ILibRemoteLogging_Command_Logger_Flags_ENABLE);
|
|
buf[4] = ft->enabled == 0 ? 0 : 1;
|
|
ILibTransport_Send(userContext, buf, 5, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
if (ft->enabled != 0)
|
|
{
|
|
ILibRemoteLogging_FileTransport_Report(userContext, ft);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((flags & ILibRemoteLogging_Command_Logger_Flags_READ_FILE) == ILibRemoteLogging_Command_Logger_Flags_READ_FILE)
|
|
{
|
|
if (ILibRemoteLogging_FileTransport_ReadLogs(ft, userContext) != 0)
|
|
{
|
|
((unsigned short*)buf)[0] = htons((unsigned short)ILibRemoteLogging_Modules_Logger | (unsigned short)0x8000);
|
|
((unsigned short*)buf)[1] = htons(ILibRemoteLogging_Flags_VerbosityLevel_1);
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "ILibRemoteLogging_FileTransport: (No Log Entries)");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
}
|
|
if ((flags & ILibRemoteLogging_Command_Logger_Flags_RESET_FILE) == ILibRemoteLogging_Command_Logger_Flags_RESET_FILE)
|
|
{
|
|
// Clear the Log File
|
|
if (ft->logFile != NULL)
|
|
{
|
|
ILibLinkedList_FileBacked_Reset(ft->logFile);
|
|
|
|
((unsigned short*)buf)[0] = htons((unsigned short)ILibRemoteLogging_Modules_Logger | (unsigned short)0x8000);
|
|
((unsigned short*)buf)[1] = htons(ILibRemoteLogging_Flags_VerbosityLevel_1);
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "ILibRemoteLogging_FileTransport: (Logfile was reset)");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
else
|
|
{
|
|
((unsigned short*)buf)[0] = htons((unsigned short)ILibRemoteLogging_Modules_Logger | (unsigned short)0x8000);
|
|
((unsigned short*)buf)[1] = htons(ILibRemoteLogging_Flags_VerbosityLevel_1);
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "ILibRemoteLogging_FileTransport: (No Log File)");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
}
|
|
}
|
|
if ((flags & ILibRemoteLogging_Command_Logger_Flags_RESET_FLAGS) == ILibRemoteLogging_Command_Logger_Flags_RESET_FLAGS)
|
|
{
|
|
if (dataLen == 4 && ft->logFile != NULL)
|
|
{
|
|
unsigned short newModules = ntohs(((unsigned short*)data)[0]);
|
|
unsigned short newFlags = ntohs(((unsigned short*)data)[1]);
|
|
obj->Sessions[i].Flags = (newFlags & 0x3F) << 16;
|
|
obj->Sessions[i].Flags |= (unsigned int)newModules;
|
|
|
|
ILibLinkedList_FileBacked_ReloadRoot(ft->logFile);
|
|
ft->logFile->flags = (unsigned int)ft->enabled << 31;
|
|
ft->logFile->flags |= (obj->Sessions[i].Flags & 0x7FFFFFFF);
|
|
ILibLinkedList_FileBacked_SaveRoot(ft->logFile);
|
|
|
|
((unsigned short*)buf)[0] = htons((unsigned short)ILibRemoteLogging_Modules_Logger | (unsigned short)0x8000);
|
|
((unsigned short*)buf)[1] = htons(ILibRemoteLogging_Flags_VerbosityLevel_1);
|
|
len = sprintf_s(buf + 4, sizeof(buf) - 4, "ILibRemoteLogging_FileTransport: (LogFile Flags RESET)");
|
|
ILibTransport_Send(userContext, buf, len + 4, ILibTransport_MemoryOwnership_USER, ILibTransport_DoneState_COMPLETE);
|
|
|
|
ILibRemoteLogging_FileTransport_Report(userContext, ft);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
sem_post(&(obj->LogSyncLock));
|
|
}
|
|
ILibTransport* ILibRemoteLogging_CreateFileTransport(ILibRemoteLogging loggingModule, ILibRemoteLogging_Modules modules, ILibRemoteLogging_Flags flags, char* path, int pathLen)
|
|
{
|
|
ILibRemoteLogging_FileTransport *retVal = ILibMemory_Allocate(sizeof(ILibRemoteLogging_FileTransport), 0, NULL, NULL);
|
|
char data[4];
|
|
|
|
if (pathLen < 0) { pathLen = (int)strnlen_s(path, _MAX_PATH); }
|
|
retVal->transport.IdentifierFlags = (int)ILibTransports_RemoteLogging_FileTransport;
|
|
retVal->transport.SendPtr = ILibFileTransport_SendSink;
|
|
retVal->transport.PendingBytesPtr = ILibFileTransport_PendingBytes;
|
|
retVal->transport.ClosePtr = ILibFileTransport_CloseSink;
|
|
retVal->parent = (ILibRemoteLogging_Module*)loggingModule;
|
|
retVal->localFilePath = ILibString_Copy(path, pathLen);
|
|
|
|
retVal->logFile = ILibLinkedList_FileBacked_Create(retVal->localFilePath, 2048000, 4096);
|
|
if (retVal->logFile != NULL && retVal->logFile->flags != 0)
|
|
{
|
|
modules = (unsigned short)(retVal->logFile->flags & 0xFFFF);
|
|
flags = (unsigned short)(retVal->logFile->flags >> 16);
|
|
retVal->enabled = ((flags & 0x8000) == 0x8000) ? 1 : 0;
|
|
}
|
|
|
|
((unsigned short*)data)[0] = htons((unsigned short)modules);
|
|
((unsigned short*)data)[1] = htons((unsigned short)flags & (unsigned short)0x3F);
|
|
|
|
ILibRemoteLogging_Dispatch(loggingModule, data, (int)sizeof(data), retVal);
|
|
ILibRemoteLogging_RegisterCommandSink(loggingModule, ILibRemoteLogging_Modules_Logger, ILibRemoteLogging_FileTransport_CommandSink);
|
|
return((ILibTransport*)retVal);
|
|
}
|
|
|
|
#endif
|