msg.c

基于h323协议的软phone

            }
        }

        if(!strcmp(param, "msgdeb"))
        {
            if((!strcmp(lowerString(value), "on")) || (atoi(value) > 0))
            {
                /* create debugger listerner */
                useDeb = RV_TRUE;
                continue;
            }
        }

        if(!strcmp(param, "flushfile"))
        {
            /* set buffer size */
            if(flushFile == -1)
                flushFile = atoi(value);
            continue;
        }

        if(!strcmp(param, "filesize"))
        {
            /* set buffer size */
            if(fileSize == -1)
                fileSize = atoi(value);
            continue;
        }

        if(!strcmp(param, "numoffiles"))
        {
            /* set number of files */
            if(numOfFiles == -1)
                numOfFiles = atoi(value);
            continue;
        }

        if(!strcmp(param, "filename"))
        {
            /* set file name */
            if(msLogFileName[0] == '\0')
                strcpy(msLogFileName, value);
            continue;
        }
    }

    /* set defaults if they were not set */
    if(msLogFileName[0] == '\0')
        strcpy(msLogFileName, LOG_FILE);
    if(numOfFiles == -1)
        numOfFiles = 1;
    if(fileSize == -1)
        fileSize = 0;
    if(flushFile == -1)
        flushFile = 0;
    if(msgDebugLevel == -1)
        msgDebugLevel = 0;

    if(useFile && !logfiled)
        if(RvLogListenerConstructLogfile(&fileListener, RvLogGet(), msLogFileName, numOfFiles, fileSize, flushFile != 0) == RV_OK)
            logfiled = RV_TRUE;

    if(useTerm && !logtermed)
        if(RvLogListenerConstructTerminal(&termListener, RvLogGet(), 0) == RV_OK)
            logtermed = RV_TRUE;

    if(useDeb && !logdebed)
        if(RvLogListenerConstructDebug(&debListener, RvLogGet()) == RV_OK)
            logdebed = RV_TRUE;

    msSetDebugLevel(msgDebugLevel);

    return newHeader;
}


RvBool rvteleInsertIntoLog(FILE** fdp, char line[])
{
    char *logName;
    RvLogMessageType logMask;

    while(fgets(line, 200, *fdp))
    {
        if(strlen(line) < 2) continue; /* ignore empty lines */

        if(line[0] == '#') continue; /* ignore remarks */

        if(line[0] == '[')
        {
            line[strlen(line)-1] = 0; /* remove \n */
            return RV_TRUE; /* exit on new header */
        }

        if(parseInsertLine(line, &logName, &logMask) != RV_OK)
            continue;

        if(logName[0] == '*')
            RvLogSetGlobalMask(RvLogGet(), logMask);
        else
        {
            RvLogSource logSource;
            RvLogSourceConstruct(RvLogGet(), &logSource, RV_LOG_LIBCODE_ANY, logName, "");
            RvLogSourceSetMask(&logSource, logMask);
        }
    }

    return RV_FALSE;
}



/****************************** internal listener *****************************/


/********************************************************************************************
 * rvMsgPrintListener
 *
 * purpose : Callback that is executed whenever a message has to be logged somewhere.
 *           This is used to get log information to the application's callbacks.
 * input   : logRecord  - Information related with the logged message
 *           userData   - User related data, given when the printing function was set
 * output  : None
 * return  : None
 * remarks : The log record holds a pointer to the message to log. This message has
 *           a set amount of bytes before it allocated but unused to allow better
 *           formatting of messages. That amount is RV_LOG_RESERVED_BYTES.
 ********************************************************************************************/
static void RVCALLCONV rvMsgPrintListener(
    IN RvLogRecord* logRecord,
    IN void*        userData)
{
    RvChar* buf;
    RvChar* threadName = NULL;
    RvThread* threadInfo;
    RvTime t;
    RvTm tm;
    const RvChar* mtypeStr;
    RvUint32 len;
    void (*notify)(IN char *line,...) = stackNotify;

    RV_UNUSED_ARG(userData);

    if (notify == NULL)
        return;

    /* Find the message type string */
    switch (RvLogRecordGetMessageType(logRecord))
    {
        case RV_LOGLEVEL_EXCEP:   mtypeStr = "EXCEP"; break;
        case RV_LOGLEVEL_ERROR:   mtypeStr = "ERROR"; break;
        case RV_LOGLEVEL_WARNING: mtypeStr = "WARN "; break;
        case RV_LOGLEVEL_INFO :   mtypeStr = "INFO "; break;
        case RV_LOGLEVEL_DEBUG:   mtypeStr = "DEBUG"; break;
        case RV_LOGLEVEL_ENTER:   mtypeStr = "ENTER"; break;
        case RV_LOGLEVEL_LEAVE:   mtypeStr = "LEAVE"; break;
        default:
            return;
    }

    /* Move back in the text - there's free space there for our formatting */
    buf = (RvChar *)RvLogRecordGetText(logRecord) - 38;

    /* Find out the thread's name */
    threadInfo = RvLogRecordGetThread(logRecord);
    if (threadInfo != NULL)
        threadName = RvThreadGetName(threadInfo);
    if (threadName == NULL)
        threadName = (RvChar *)"Unknown";

    /* Get the time of the log */
    RvClockGet(&t);
    RvTmConstructUtc(&tm, &t);

    /* Format the additional information into the reserved space in the beginning of the buffer */
    /* 8+1+2+1+2+1+2+1+10+2+5+3 = */
    RvSprintf(buf, "%8.8s %2.2u:%2.2u:%2.2u %-10.10s: %s -",
        threadName,
        RvTmGetHour(&tm), RvTmGetMin(&tm), RvTmGetSec(&tm),
        RvLogSourceGetName(RvLogRecordGetSource(logRecord)),
        mtypeStr);

    /* We're done with time information */
    RvTimeDestruct(&t);
    RvTmDestruct(&tm);

    /* This one is for the addition of the actual string after the fomatted header */
    buf[37] = ' ';

    /* Add a newline in the end and calculate the size of message */
    len = strlen(buf);
    buf[len] = '\0';

    /* Now that we finally have a formatted buffer we can work with - notify the application */
    notify("%s", buf);
}


/****************************** ms functions *****************************/

/* Add module to debug printing list */
RVAPI int RVCALLCONV msAdd(IN char * moduleName)
{
    char *logName;
    RvLogMessageType logMask;
    RvLogSource tmpSource;
    RvStatus status;

    status = parseInsertLine(moduleName, &logName, &logMask);
    if (status == RV_OK)
    {
        if(logName[0] == '*')
            status = RvLogSetGlobalMask(RvLogGet(), logMask);
        else
        {
            status = RvLogSourceConstruct(RvLogGet(), &tmpSource, RV_LOG_LIBCODE_ANY, moduleName, "");
            if (status == RV_OK)
                RvLogSourceSetMask(&tmpSource, logMask);
        }

    }

    return status;
}

/* Delete module from debug printing list */
RVAPI int RVCALLCONV msDelete(IN char* moduleName)
{
    RvLogSource tmpSource;

    RvLogGetSourceByName(RvLogGet(), RV_LOG_LIBCODE_H323, moduleName, &tmpSource);
    return RvLogSourceDestruct(RvLogGet(), &tmpSource);
}

/* Delete all modules from debug printing list */
RVAPI int RVCALLCONV msDeleteAll(void)
{
    return RvLogSetGlobalMask(RvLogGet(), 0);
}

/* Set the configuration file name. */
RVAPI void RVCALLCONV msFile(IN char *name)
{
    strncpy(msConfFileName, name, sizeof(msConfFileName));
    msConfFileName[sizeof(msConfFileName)-1] = '\0';
}

/* Get the debug level */
RVAPI int RVCALLCONV msGetDebugLevel(void)
{
    return msgDebugLevel;
}

/* Set the log output file name.  */
RVAPI void RVCALLCONV msLogFile(IN char *name)
{
    strncpy(msLogFileName, name, sizeof(msLogFileName));
    msLogFileName[sizeof(msLogFileName)-1] = '\0';
}

/* Get the current log output file name.  */
RVAPI RvStatus RVCALLCONV msGetLogFilename(IN RvUint32 nameLength, OUT char* name)
{
    if (logfiled == RV_FALSE)
        return RV_ERROR_NOTSUPPORTED; /* No file... */

    return RvLogListenerLogfileGetCurrentFilename(&fileListener, nameLength, name);
}

/* Set the debug level */
RVAPI int RVCALLCONV msSetDebugLevel(IN int newDebugLevel)
{
    /* Make sure we silence the log for debug level 0 only */
    if (newDebugLevel == 0)
        RvLogSetLevel(RvLogGet(), 0);
    else if (newDebugLevel >= 3)
        RvLogSetLevel(RvLogGet(), 2);
    else
        RvLogSetLevel(RvLogGet(), 1);

    return(msgDebugLevel = newDebugLevel);
}

/* Set function to be called when logging messages are being written */
RVAPI void RVCALLCONV msSetStackNotify(void (*sN)(IN char *line,...))
{
    if ((applicationListenerOn == RV_FALSE) && (sN != NULL))
    {
        /* We have to set a dedicated listener for the application on the log */
        RvLogRegisterListener(RvLogGet(), rvMsgPrintListener, NULL);
    }
    else if (applicationListenerOn == RV_TRUE)
    {
        /* We have to remove a dedicated listener */
        if (stackNotify != NULL)
            RvLogUnregisterListener(RvLogGet(), rvMsgPrintListener);
    }

    /* Set the listener function */
    applicationListenerOn = (sN != NULL);
    stackNotify = sN;
}

/* Add sink */
RVAPI int RVCALLCONV msSinkAdd(IN char* sinkName)
{
    char firstName[64], secondName[64];
    int numOfNames; /* number of separated strings in sinkName */

    numOfNames=sscanf(sinkName, "%s %s", firstName, secondName);

    if(!strcmp(firstName, "file"))
    {
        /* see if we got two names */
        if (numOfNames>1)
            msLogFile(secondName); /* register new logfile name */

        /* if we already have a log file, close before opening a new one */
        if (logfiled)
        {
            RvLogListenerDestructLogfile(&fileListener); /* close current logfile */
            logfiled = RV_FALSE;
        }

        /* Open the new file */
        if(RvLogListenerConstructLogfile(&fileListener, RvLogGet(), msLogFileName, numOfFiles, fileSize, flushFile != 0) == RV_OK)
            logfiled = RV_TRUE;
    }

    /* if we don't have a terminal output, open one */
    if(!strcmp(firstName, "terminal") && !logtermed)
    {
        if(RvLogListenerConstructTerminal(&termListener, RvLogGet(), 0) == RV_OK)
            logtermed = RV_TRUE;
    }

    /* if we don't have a debugger output, open one */
    if(!strcmp(firstName, "logger") && !logdebed)
    {
        if(RvLogListenerConstructDebug(&debListener, RvLogGet()) == RV_OK)
            logdebed = RV_TRUE;
    }

    return RV_TRUE;
}

/* Delete sink */
RVAPI int RVCALLCONV msSinkDelete(IN char* sinkName)
{
    if(!strcmp(sinkName, "file") && logfiled)
    {
        RvLogListenerDestructLogfile(&fileListener);
        logfiled = RV_FALSE;
    }
    if(!strcmp(sinkName, "terminal") && logtermed)
    {
        RvLogListenerDestructTerminal(&termListener);
        logtermed = RV_FALSE;
    }
    if(!strcmp(sinkName, "logger") && logdebed)
    {
        RvLogListenerDestructDebug(&debListener);
        logdebed = RV_FALSE;
    }
    return RV_OK;
}



#else  /* (RV_LOGMASK_COMPILEMASK) */

int RV_dummyMsg = 0;

#endif  /* (RV_LOGMASK_COMPILEMASK) */

#ifdef __cplusplus
}
#endif