librtmp源码分析--日志部分

log.h文件

#ifndef __RTMP_LOG_H__
#define __RTMP_LOG_H__

#include <stdio.h>
#include <stdarg.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif
/* Enable this to get full debugging output */
/* #define _DEBUG */

#ifdef _DEBUG
#undef NODEBUG
#endif

typedef enum
{ RTMP_LOGCRIT=0, RTMP_LOGERROR, RTMP_LOGWARNING, RTMP_LOGINFO,
RTMP_LOGDEBUG, RTMP_LOGDEBUG2, RTMP_LOGALL
} RTMP_LogLevel;

extern RTMP_LogLevel RTMP_debuglevel;

typedef void (RTMP_LogCallback)(int level, const char *fmt, va_list);//定义一种类型：函数类型
void RTMP_LogSetCallback(RTMP_LogCallback *cb);
void RTMP_LogSetOutput(FILE *file);
#ifdef __GNUC__
void RTMP_LogPrintf(const char *format, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
void RTMP_LogStatus(const char *format, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
void RTMP_Log(int level, const char *format, ...) __attribute__ ((__format__ (__printf__, 2, 3)));
#else
void RTMP_LogPrintf(const char *format, ...);
void RTMP_LogStatus(const char *format, ...);
void RTMP_Log(int level, const char *format, ...);
#endif
void RTMP_LogHex(int level, const uint8_t *data, unsigned long len);
void RTMP_LogHexString(int level, const uint8_t *data, unsigned long len);
void RTMP_LogSetLevel(RTMP_LogLevel lvl);
RTMP_LogLevel RTMP_LogGetLevel(void);

#ifdef __cplusplus
}
#endif

#endif

关于__attribute__((__format__(__printf__(a,b)))的作用：

功能：__attribute__ format属性可以给被声明的函数加上类似printf或者scanf的特征，它可以使编译器检查函数声明和函数实际调用参数之间的格式化字符串是否匹配。format属性告诉编译器，按照printf, scanf等标准C函数参数格式规则对该函数的参数进行检查。这在我们自己封装调试信息的接口时非常的有用。

　　format的语法格式为：

format (archetype, string-index, first-to-check)

　　其中，“archetype”指定是哪种风格；“string-index”指定传入函数的第几个参数是格式化字符串；“first-to-check”指定从函数的第几个参数开始按上述规则进行检查。

具体的使用如下所示：

__attribute__((format(printf, a, b)))
__attribute__((format(scanf, a, b)))

　　其中参数m与n的含义为：
　　　　a：第几个参数为格式化字符串(format string);
　　　　b：参数集合中的第一个，即参数“…”里的第一个参数在函数参数总数排在第几。

　　下面直接给个例子来说明：

#include <stdio.h>
#include <stdarg.h>
#if 1
#define CHECK_FMT(a, b) __attribute__((format(printf, a, b)))
#else
#define CHECK_FMT(a, b)
#endif
void TRACE(const char *fmt, ...) CHECK_FMT(1, 2);
void TRACE(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
(void)printf(fmt, ap);
va_end(ap);
}
int main(void)
{
TRACE("iValue = %d\n", 6);
TRACE("iValue = %d\n", "test");
return 0;
}

log.c文件

扫描二维码关注公众号，回复： 126436 查看本文章

#include <stdio.h>

#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>

#include "rtmp_sys.h"
#include "log.h"

#define MAX_PRINT_LEN 2048

/*枚举类型

typedef enum
{ RTMP_LOGCRIT=0, RTMP_LOGERROR, RTMP_LOGWARNING, RTMP_LOGINFO,
RTMP_LOGDEBUG, RTMP_LOGDEBUG2, RTMP_LOGALL
} RTMP_LogLevel;

//这是一个其他文件也会使用的全局变量

RTMP_LogLevel RTMP_debuglevel = RTMP_LOGERROR;

static int neednl;

static FILE *fmsg;

//定义一个函数指针指向日志回调函数，日志回调函数就是用于打印

static RTMP_LogCallback rtmp_log_default, *cb = rtmp_log_default;

//日志等级

static const char *levels[] = {
"CRIT", "ERROR", "WARNING", "INFO",
"DEBUG", "DEBUG2"

};

//穿插介绍可变参数的原理，后面会用到

******************************************************************************************************************

函数参数的传递原理

　　函数参数是以数据结构:栈的形式存取,从右至左入栈。

　　首先是参数的内存存放格式：参数存放在内存的堆栈段中，在执行函数的时候，从最后一个开始入栈。因此栈底高地址，栈顶低地址，举个例子如下：
void func(int x, float y, char z);
　　那么，调用函数的时候，实参 char z 先进栈，然后是 float y，最后是 int x，因此在内存中变量的存放次序是 x->y->z，因此，从理论上说，我们只要探测到任意一个变量的地址，并且知道其他变量的类型，通过指针移位运算，则总可以顺藤摸瓜找到其他的输入变量。

　　下面是 <stdarg.h> 里面重要的几个宏定义如下：
typedef char* va_list;
void va_start ( va_list ap, prev_param ); /* ANSI version */
type va_arg ( va_list ap, type );
void va_end ( va_list ap );

它们的定义如下：

typedef char * va_list ;

#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) //得到变量n的大小（结果必须是int的倍数，不满足则往大补）

#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) //v是省略号之前的那个参数，v加上自身的大小就得到可变参数中第一个参数的首地址

#define va_arg(ap,type) ( *(type *)((ap += _INTSIZEOF(type)) - _INTSIZEOF(type)) ) //取出ap指向的参数的值，并使ap指向下一个参数
#define va_end(ap) ( ap = (va_list)0 ) //这句结束时调用，让指针变量ap指向NULL

整个使用流程如下：

<Step 1> 在调用参数表之前，定义一个 va_list 类型的变量，(假设va_list 类型变量被定义为ap)；
<Step 2> 然后应该对ap 进行初始化，让它指向可变参数表里面的第一个参数，这是通过 va_start 来实现的，第一个参数是 ap 本身，第二个参数是在变参表前面紧挨着的一个变量,即“...”之前的那个参数；
<Step 3> 然后是获取参数，调用va_arg，它的第一个参数是ap，第二个参数是要获取的参数的指定类型，然后返回这个指定类型的值，并且把 ap 的位置指向变参表的下一个变量位置；
<Step 4> 获取所有的参数之后，我们有必要将这个 ap 指针关掉，以免发生危险，方法是调用 va_end，他是输入的参数 ap 置为 NULL，应该养成获取完参数表之后关闭指针的习惯。说白了，就是让我们的程序具有健壮性。通常va_start和va_end是成对出现。

例如 int max(int n, ...); 其函数内部应该如此实现：
#include <iostream.h>
void fun(int a, ...)
{
　　int *temp = &a;

　　temp++;

　　for (int i = 0; i < a; ++i)
　　{
　　　　cout << *temp << endl;
　　　　temp++;
　　}
}
int main()
{
　　int a = 1;
　　int b = 2;
　　int c = 3;
　　int d = 4;
　　fun(4, a, b, c, d);
　　system("pause");
　　return 0;
}

Output::
1
2
3
4

3:获取省略号指定的参数
　　在函数体中声明一个va_list，然后用va_start函数来获取参数列表中的参数，使用完毕后调用va_end()结束。像这段代码：
void TestFun(char* pszDest, int DestLen, const char* pszFormat, ...)
{
va_list args;
va_start(args, pszFormat); //一定要“...”之前的那个参数
_vsnprintf(pszDest, DestLen, pszFormat, args);
va_end(args);
}

4.演示如何使用参数个数可变的函数，采用ANSI标准形式
#include 〈stdio.h〉
#include 〈string.h〉
#include 〈stdarg.h〉

/*函数原型声明，至少需要一个确定的参数，注意括号内的省略号*/
int demo( char, ... );
void main( void )
{
   demo("DEMO", "This", "is", "a", "demo!", "");
}

/*ANSI标准形式的声明方式，括号内的省略号表示可选参数*/
int demo( char msg, ... )
{
       /*定义保存函数参数的结构*/
   va_list argp;
   int argno = 0;
   char para;
　　   /*argp指向传入的第一个可选参数，msg是最后一个确定的参数*/
   va_start( argp, msg );
   while (1)
       {
    para = va_arg( argp, char);
         if ( strcmp( para, "") == 0 )
               break;
           printf("Parameter #%d is: %s\n", argno, para);
         argno++;
}
va_end( argp );
/*将argp置为NULL*/
return 0;
}

以上是对va_start和va_end的介绍。

下面介绍_vnsprintf

_vsnprintf，C语言库函数之一，属于可变参数。用于向字符串中打印数据、数据格式用户自定义。
头文件:
#include <stdarg.h>
函数声明:
int vsnprintf(char* str, size_t size, const char* format, va_list ap);
参数说明:
char *str [out],把生成的格式化的字符串存放在这里.
size_t size [in], str可接受的最大字节数,防止产生数组越界.
const char *format [in], 指定输出格式的字符串，它决定了你需要提供的可变参数的类型、个数和顺序。
va_list ap [in], va_list变量. va:variable-argument:可变参数
函数功能：将可变参数格式化输出到一个字符数组。
用法类似于vsprintf，不过加了size的限制，防止了内存溢出（size为str所指的存储空间的大小）。
返回值：执行成功，返回写入到字符数组str中的字符个数（不包含终止符），最大不超过size；执行失败，返回负值，并置errno.[1]

使用示例：

#include <stdio.h>
#include <stdarg.h>
char buffer[80];
int vspf(char *fmt, ...)
{
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsprintf(buffer, fmt, argptr);
va_end(argptr);
return(cnt);
}

int main(void)
{
int inumber = 30;
int fnumber = 90.0;
char string[4] = "abc";
vspf("%d %d %c%c%c", inumber, fnumber, string);
printf("%s\n", buffer);
while(1);
return 0;
}

*************************************************************************************************************/
//这是默认的日志打印函数，当用户自己没有设置时
static void rtmp_log_default(int level, const char *format, va_list vl)
{
char str[MAX_PRINT_LEN]="";

vsnprintf(str, MAX_PRINT_LEN-1, format, vl);

/* Filter out 'no-name'

strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。

*/
if ( RTMP_debuglevel<RTMP_LOGALL && strstr(str, "no-name" ) != NULL )
return;

//如果文件描述符还未分配，就让它指向标准出错
if ( !fmsg ) fmsg = stderr;

//规定日志级别小于等于日志级别的，才会记录日志，其他级别不做记录

//RTMP_debuglevel = RTMP_LOGERROR;
if ( level <= RTMP_debuglevel ) {
if (neednl) {
putc('\n', fmsg);//先将之前的缓冲写入文件fmsg，因为缓冲遇到换行符会刷入到磁盘
neednl = 0;
}
fprintf(fmsg, "%s: %s\n", levels[level], str);
#ifdef _DEBUG
fflush(fmsg);//如果定义了调式宏，将缓冲写入文件
#endif
}
}

void RTMP_LogSetOutput(FILE *file)
{
fmsg = file;
}

void RTMP_LogSetLevel(RTMP_LogLevel level)
{
RTMP_debuglevel = level;
}

void RTMP_LogSetCallback(RTMP_LogCallback *cbp)
{
cb = cbp;
}

RTMP_LogLevel RTMP_LogGetLevel()
{
return RTMP_debuglevel;
}

//写日志
void RTMP_Log(int level, const char *format, ...)
{
va_list args;

if ( level > RTMP_debuglevel )
return;

va_start(args, format);
cb(level, format, args);
va_end(args);
}

static const char hexdig[] = "0123456789abcdef";

void RTMP_LogHex(int level, const uint8_t *data, unsigned long len)
{
unsigned long i;
char line[50], *ptr;

if ( level > RTMP_debuglevel )
return;

ptr = line;

for(i=0; i<len; i++) {
*ptr++ = hexdig[0x0f & (data[i] >> 4)];
*ptr++ = hexdig[0x0f & data[i]];
if ((i & 0x0f) == 0x0f) {
*ptr = '\0';
ptr = line;
RTMP_Log(level, "%s", line);
} else {
*ptr++ = ' ';
}
}
if (i & 0x0f) {
*ptr = '\0';
RTMP_Log(level, "%s", line);
}
}

void RTMP_LogHexString(int level, const uint8_t *data, unsigned long len)
{
#define BP_OFFSET 9
#define BP_GRAPH 60
#define BP_LEN 80
char line[BP_LEN];
unsigned long i;

if ( !data || level > RTMP_debuglevel )
return;

/* in case len is zero */
line[0] = '\0';

for ( i = 0 ; i < len ; i++ ) {
int n = i % 16;
unsigned off;

if( !n ) {
if( i ) RTMP_Log( level, "%s", line );
memset( line, ' ', sizeof(line)-2 );
line[sizeof(line)-2] = '\0';

off = i % 0x0ffffU;

line[2] = hexdig[0x0f & (off >> 12)];
line[3] = hexdig[0x0f & (off >> 8)];
line[4] = hexdig[0x0f & (off >> 4)];
line[5] = hexdig[0x0f & off];
line[6] = ':';
}

off = BP_OFFSET + n*3 + ((n >= 8)?1:0);
line[off] = hexdig[0x0f & ( data[i] >> 4 )];
line[off+1] = hexdig[0x0f & data[i]];

off = BP_GRAPH + n + ((n >= 8)?1:0);

if ( isprint( data[i] )) {
line[BP_GRAPH + n] = data[i];
} else {
line[BP_GRAPH + n] = '.';
}
}

RTMP_Log( level, "%s", line );
}

/* These should only be used by apps, never by the library itself */
void RTMP_LogPrintf(const char *format, ...)
{
char str[MAX_PRINT_LEN]="";
int len;
va_list args;
va_start(args, format);
len = vsnprintf(str, MAX_PRINT_LEN-1, format, args);
va_end(args);

if ( RTMP_debuglevel==RTMP_LOGCRIT )
return;

if ( !fmsg ) fmsg = stderr;

if (neednl) {
putc('\n', fmsg);
neednl = 0;
}

if (len > MAX_PRINT_LEN-1)
len = MAX_PRINT_LEN-1;
fprintf(fmsg, "%s", str);
if (str[len-1] == '\n')
fflush(fmsg);
}

void RTMP_LogStatus(const char *format, ...)
{
char str[MAX_PRINT_LEN]="";
va_list args;
va_start(args, format);
vsnprintf(str, MAX_PRINT_LEN-1, format, args);
va_end(args);

if ( RTMP_debuglevel==RTMP_LOGCRIT )
return;

if ( !fmsg ) fmsg = stderr;

fprintf(fmsg, "%s", str);
fflush(fmsg);
neednl = 1;
}

librtmp源码分析--日志部分

猜你喜欢