rvremotelog.c

h.248协议源码

/************************************************************************
 File Name     : rvRemoteLog.c
 Description   :
*************************************************************************
 Copyright (c)  2001 , RADVision, Inc. All rights reserved.
*************************************************************************
 NOTICE:
 This document contains information that is proprietary to RADVision Inc. 
 No part of this publication may be reproduced in any form whatsoever
 without written prior approval by RADVision Inc. 
 
 RADVision Inc. reserves the right to revise this publication and make
 changes without obligation to notify any person of such revisions or
 changes.
*************************************************************************
 $Revision: $
 $Date:   03/01/2001 $
 $Author: Scott K. Eaton $
************************************************************************/


#include "rvremotelog.h"
#include "rvdefalloc.h"
#include "rvdatabuffer.h"
#include "rvsocket_.h"
#include <stdio.h>

#if (RV_LOGMASK != RV_LOGMASK_NONE)

#define RV_REMOTELOG_MAX_BUFFER_SIZE 1024

/***********************************************************************
* Utility methods
************************************************************************/
void rvLogRecordSerialize(const RvLogRecord *thisPtr, RvDataBuffer *bufferPtr)
{
    RvUint32 length;

    /* Copy record into the buffer */
    length = strlen(thisPtr->text);
    rvDataBufferWriteUint8Array(bufferPtr, thisPtr->text, length);
    rvDataBufferWriteUint32(bufferPtr, length);

    rvDataBufferWriteUint32(bufferPtr, thisPtr->level);

    length = strlen(thisPtr->threadName);
    rvDataBufferWriteUint8Array(bufferPtr, thisPtr->threadName, length);
    rvDataBufferWriteUint32(bufferPtr, length);

    rvDataBufferWriteUint32(bufferPtr, rvTimespecSecs(&thisPtr->timestamp));
    rvDataBufferWriteUint32(bufferPtr, rvTimespecNsecs(&thisPtr->timestamp));
}

void rvLogRecordUnserialize(RvLogRecord *thisPtr, RvDataBuffer *bufferPtr)
{
    RvUint32 length;
    RvUint32 seconds;
    RvUint32 nanoseconds;

    /* Copy the record out of the buffer */
    rvDataBufferReadUint32(bufferPtr, &nanoseconds);
    rvDataBufferReadUint32(bufferPtr, &seconds);
    rvTimespecCreate(&thisPtr->timestamp, seconds, nanoseconds);

    rvDataBufferReadUint32(bufferPtr, &length);
    rvDataBufferReadUint8Array(bufferPtr, thisPtr->threadName, length);

    rvDataBufferReadUint32(bufferPtr, &thisPtr->level);

    rvDataBufferReadUint32(bufferPtr, &length);
    rvDataBufferReadUint8Array(bufferPtr, thisPtr->text, length);
}


RvUint32 rvLogRecordGetSerializedSize(const RvLogRecord *thisPtr)
{
    RvUint32 length = 0;

    /* Compute the size */
    length += strlen(thisPtr->text);
    length += sizeof(RvUint32);
    length += strlen(thisPtr->threadName);
    length += sizeof(RvUint32)*2;

    return length;
}


RvBool rvSocketSendDataBufferTo(RvSocket *thisPtr, RvDataBuffer *bufferPtr, const RvSocketAddr* toAddrPtr)
{
	return (rvSocketSendTo_(*thisPtr, (char*)rvDataBufferGetData(bufferPtr), 
                            rvDataBufferGetLength(bufferPtr), 0, toAddrPtr) < 0);
}

int rvSocketRecvDataBufferFrom(RvSocket* thisPtr, RvDataBuffer *bufferPtr, RvSocketAddr* fromAddrPtr)
{
    int packetLength;

    packetLength = rvSocketRecvFrom(thisPtr,
                              rvDataBufferGetBuffer(bufferPtr),
                              rvDataBufferGetCapacity(bufferPtr),
                              fromAddrPtr);
    if(packetLength < 0)
        rvDataBufferSetDataPosition(bufferPtr,0,0);
    else
        rvDataBufferSetDataPosition(bufferPtr,0,packetLength);


    return packetLength;
}


/***********************************************************************
* RvRemoteLogServer
************************************************************************/
static void NewRecordEvent(const RvLogRecord *recordPtr, void *dataPtr)
{
    RvRemoteLogServer *thisPtr = (RvRemoteLogServer *)dataPtr;

    if(thisPtr->mode == RVREMOTELOG_MODE_BINARY)
    {
        /* Reset the buffer */
        rvDataBufferSetDataPosition(&thisPtr->buffer,RV_REMOTELOG_MAX_BUFFER_SIZE,0);

        /* Copy record into buffer */
        rvLogRecordSerialize(recordPtr,&thisPtr->buffer);

        /* Send the buffer */
        rvSocketSendDataBufferTo(&thisPtr->socket, &thisPtr->buffer, &thisPtr->address);

    }
    else
    {
        int  length;
        char buffer[1024];
        char timeString[32];

	    length = sprintf(buffer, "%s|%s|%s|%s", 
	                rvLogRecordGetTimeAsString(recordPtr,timeString),
	                rvLogRecordGetThreadName(recordPtr),
	                rvLogRecordGetLevelString(recordPtr),
	                rvLogRecordGetText(recordPtr));

        /* under-score method is used to aviod logging in normal rvSocketSendTo */
        rvSocketSendTo_(thisPtr->socket, buffer, length, 0, &thisPtr->address);
    }
}

/*$
{function:
	{name:    rvRemoteLogServerConstruct }
	{class:   RvRemoteLogServer}
	{include: rvremotelog.h}
	{description:
		{p: This method constructs a RvRemoteLogServer. After construction the remote log
            server will begin forwarding log records to the supplied address.}
	}
	{proto: RvRemoteLogServer* rvRemoteLogServerConstruct(RvRemoteLogServer* thisPtr, RvLog* logPtr, RvLogMask mask, const char *address, int port, RvRemoteLogMode mode);}
	{params:
		{param: {n:thisPtr} {d:The RvRemoteLogServer object.}}
		{param: {n:logPtr}  {d:The log to listen to and forward data from.}}
		{param: {n:mask}    {d:The log level mask to filter log records with.}}
		{param: {n:address} {d:The inet address to send to.}}
		{param: {n:port}    {d:The inet port to send to.}}
		{param: {n:mode}    {d:The mode to run in. Only RVREMOTELOG_MODE_ASCII is supported currently.}}
	}
	{returns: A pointer to the RvRemoteLogServer object if the object 
              constructs sucessfully, NULL otherwise. }
}
$*/
RvRemoteLogServer* rvRemoteLogServerConstruct(RvRemoteLogServer* thisPtr, RvLog* logPtr, RvLogMask mask, const char *address, int port, RvRemoteLogMode mode)
{
    rvSocketAddrConstructInetByName(&thisPtr->address, address, (RvInetPort)port);
    rvLogListenerConstruct(&thisPtr->listener, mask, NewRecordEvent, thisPtr); 
    rvSocketConstructUdp(&thisPtr->socket, 0);
    thisPtr->logPtr = logPtr;
    thisPtr->mode   = mode;

    rvDataBufferConstruct(&thisPtr->buffer,RV_REMOTELOG_MAX_BUFFER_SIZE,0,&rvDefaultAlloc);


    rvLogRegisterListener(thisPtr->logPtr, &thisPtr->listener);

    return thisPtr;
}

/*$
{function:
	{name:    rvRemoteLogServerDestruct }
	{class:   RvRemoteLogServer}
	{include: rvremotelog.h}
	{description:
        {p: This method destroys a RvRemoteLogServer, freeing any recources
            it held.}
	}
	{proto: void rvRemoteLogServerDestruct(RvRemoteLogServer* thisPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvRemoteLogServer object to destroy.}}
	}
}
$*/
void rvRemoteLogServerDestruct(RvRemoteLogServer* thisPtr)
{
    rvLogUnregisterListener(thisPtr->logPtr, &thisPtr->listener);

    rvDataBufferDestruct(&thisPtr->buffer);

    rvLogListenerDestruct(&thisPtr->listener);
    rvSocketDestruct(&thisPtr->socket);
    thisPtr->logPtr = NULL;
}


/***********************************************************************
* RvRemoteLogClient
*
* This class is a work in progress, it is not completed currently.
************************************************************************/
#define MAX_MESSAGE_SIZE 1024


static void NewDataBufferEvent(RvSocketSelect *selectPtr, RvSocketListener *listenerPtr, void *dataPtr)
{
	RvLogRecord        record;
	RvPtrListIter      i;
    RvSocketAddr       fromAddress;
    RvDataBuffer       buffer;
    RvRemoteLogClient *thisPtr = (RvRemoteLogClient *)dataPtr;

    /* Construct the buffer */
    rvDataBufferConstruct(&buffer,MAX_MESSAGE_SIZE, 0, &rvDefaultAlloc);

    /* Read data from the socket */
    rvSocketRecvDataBufferFrom(&thisPtr->socket, &buffer, &fromAddress);

    /* Get Record out of buffer */
    rvLogRecordUnserialize(&record, &buffer);

	/* If log mask matches and there are listeners */
	if (rvPtrListSize(&thisPtr->listeners)) 
    {

		rvMutexLock(&thisPtr->mutex);

		/* Send log message to each listener */
		for (i = rvPtrListBegin(&thisPtr->listeners); 
		  i != rvPtrListEnd(&thisPtr->listeners); 
		  i = rvPtrListIterNext(i)) 
        {
			RvLogListener* listener;
			
			listener = (RvLogListener*)rvPtrListIterData(i);

			/* If listeners mask matches level, send to listener */
			if (listener->mask & rvLogRecordGetLevel(&record)) 
				listener->output(&record, listener->data);
		}

		rvMutexUnlock(&thisPtr->mutex);
	}
}

RvRemoteLogClient *rvRemoteLogClientConstruct(RvRemoteLogClient *thisPtr, RvSocketEngine *socketEnginePtr, RvSocketAddr *addressPtr)
{
	/* Construct a list for holding listeners */
    rvPtrListConstruct(&thisPtr->listeners, &rvDefaultAlloc);
    
    thisPtr->socketEnginePtr = socketEnginePtr;
    rvSocketConstructUdpEx(&thisPtr->socket, addressPtr);
    rvSocketListenerConstruct(&thisPtr->socketListener,&thisPtr->socket,NewDataBufferEvent,thisPtr);

    rvSocketEngineRegisterListener(thisPtr->socketEnginePtr, &thisPtr->socketListener);    return thisPtr;
}

void rvRemoteLogClientDestruct(RvRemoteLogClient *thisPtr)
{
    rvSocketEngineUnregisterListener(thisPtr->socketEnginePtr, &thisPtr->socketListener);
	rvPtrListDestruct(&thisPtr->listeners);
}

void rvRemoteLogClientRegisterListener(RvRemoteLogClient* thisPtr, RvLogListener *listenerPtr)
{
	rvMutexLock(&thisPtr->mutex);
	rvPtrListPushBack(&thisPtr->listeners, listenerPtr);
	rvMutexUnlock(&thisPtr->mutex);
}

void rvRemoteLogClientUnregisterListener(RvRemoteLogClient* thisPtr, RvLogListener *listenerPtr)
{
	rvMutexLock(&thisPtr->mutex);
	rvPtrListRemove(&thisPtr->listeners, listenerPtr);
	rvMutexUnlock(&thisPtr->mutex);
}

#endif