ssmu_init_sip_stack
p_rv = &ssmu_mcb.rv_ctrl;
//中间层配置初始化
ssmu_rv_cfg_mid (p_rv);
p_rv->mid_cfg.maxUserFd = 1; //为上层使用中间层的FD分配一块内存池成员
//为上层使用RV定时器分配N块内存池成员
p_rv->mid_cfg.maxUserTimers = ssmu_mcb.num_tcids * 16;
p_rv->mid_cfg.hLog = NULL; //不关联日志管理模块
//栈初始化配置
ssmu_rv_cfg_stack (p_rv);
RV_CHAR* list = &ssmu_mcb.supported_list[0]; //扩展列表支持
RvChar* listen_addr = ssmu_mcb.local_addr_str; //本地IP地址
//使用栈的预配置初始化配置结构
RvSipStackInitCfg(sizeof(p_rv->stack_cfg), &p_rv->stack_cfg);
//之后使用VTP用户配置来覆盖之前的预配置
//最大的TCP连接数
p_rv->stack_cfg.maxConnections = SSMU_MAX_CALL_LEGS;
//最大用户呼叫对话框数量
p_rv->stack_cfg.maxCallLegs = SSMU_MAX_CALL_LEGS;
//最大事务控制块数量
p_rv->stack_cfg.maxTransactions = SSMU_MAX_CALL_LEGS * 16;
//消息内存池所分配的内存页数量
p_rv->stack_cfg.messagePoolNumofPages = SSMU_MAX_CALL_LEGS * 6;
//涉及到传输层SOCKET个数等处理
p_rv->stack_cfg.maxNumOfLocalAddresses = ssmu_mcb.num_tcids*6 + 6;
//允许传输层添加本地地址
p_rv->stack_cfg.bDLAEnabled = RV_TRUE;
//消息内存池的一个内存页的大小
p_rv->stack_cfg.messagePoolPageSize = 2048;
//通用内存池页大小，就是像分配一个注册客户端控制块这块的内存使用
p_rv->stack_cfg.generalPoolPageSize = 2048;
//传输层收发最大BUF
p_rv->stack_cfg.sendReceiveBufferSize = 1024 * 3;
//注册客户端对象最大数量
p_rv->stack_cfg.maxRegClients = (ssmu_mcb.num_tcids * 2);
//订阅对话框对象最大数量
p_rv->stack_cfg.maxSubscriptions = (ssmu_mcb.num_tcids * 4);
//控制订阅对话框超时后自动发送订阅更新
p_rv->stack_cfg.subsAutoRefresh = RV_TRUE;
//通用内存池的内存页数量
p_rv->stack_cfg.generalPoolNumofPages = ((SSMU_MAX_CALL_LEGS * 3) +
p_rv->stack_cfg.maxRegClients + 5);
//没仔细去看
p_rv->stack_cfg.bDisableRefer3515Behavior = RV_FALSE;
//DNS列表最大成员数
p_rv->stack_cfg.maxElementsInSingleDnsList = 8;
//控制是否允许VIA头域协带RPORT
p_rv->stack_cfg.bUseRportParamInVia = (ssmu_mcb.config.rport_enable) ?
RV_TRUE : RV_FALSE;
//是否支持TCP
p_rv->stack_cfg.tcpEnabled = RV_TRUE;
//TLS功能宏没有开启，暂不关心
p_rv->stack_cfg.numOfTlsEngines = 2;
p_rv->stack_cfg.maxTlsSessions = ssmu_mcb.num_tcids * 2;
p_rv->stack_cfg.pLocalTlsAddr = ssmu_mcb.local_addr_str;
p_rv->stack_cfg.numOfTlsAddresses = 1;
//对于TCP连接将一直持续
p_rv->stack_cfg.ePersistencyLevel =
RVSIP_TRANSPORT_PERSISTENCY_LEVEL_TRANSC_USER;
//设置TCP的最大允许连接数
p_rv->stack_cfg.ePersistencyLevel =
RVSIP_TRANSPORT_PERSISTENCY_LEVEL_TRANSC_USER;
//本地地址
strcpy(p_rv->stack_cfg.localTcpAddress, listen_addr);
strcpy(p_rv->stack_cfg.localUdpAddress, listen_addr);
//本地端口
p_rv->stack_cfg.localUdpPort = ssmu_mcb.config.udp_port_num;
p_rv->stack_cfg.localTcpPort = ssmu_mcb.config.tcp_port_num;
//配置DNS服务地址
if (ssmu_mcb.config.sig_dns_prim != 0)
p_rv->stack_cfg.numOfDnsServers++;
pDns = &ssmu_mcb.config.sig_dns_prim;
sprintf(dnsAddr[p_rv->stack_cfg.numOfDnsServers].strIP, "%u.%u.%u.%u", *pDns,
*(pDns+1), *(pDns+2), *(pDns+3));
dnsAddr[p_rv->stack_cfg.numOfDnsServers].eAddrType =
RVSIP_TRANSPORT_ADDRESS_TYPE_IP;
if (ssmu_mcb.config.sig_dns_secn!= 0)
p_rv->stack_cfg.numOfDnsServers++;
pDns = &ssmu_mcb.config.sig_dns_secn;
sprintf(dnsAddr[p_rv->stack_cfg.numOfDnsServers].strIP, "%u.%u.%u.%u", *pDns,
*(pDns+1), *(pDns+2), *(pDns+3));
dnsAddr[p_rv->stack_cfg.numOfDnsServers].eAddrType =
RVSIP_TRANSPORT_ADDRESS_TYPE_IP;
if( p_rv->stack_cfg.numOfDnsServers != -1 )
p_rv->stack_cfg.numOfDnsServers++;
p_rv->stack_cfg.pDnsServers = dnsAddr;
//标记在收到200OK后手工发ACK
p_rv->stack_cfg.manualAckOn2xx = RV_TRUE;
//设置传输层任务优先级
p_rv->stack_cfg.processingTaskPriority = SSMU_TASK_PRIORITY + 1;
//设置协议栈的所有定时器值
p_rv->stack_cfg.retransmissionT1 = ssmu_mcb.config.retransmissionT1;
p_rv->stack_cfg.retransmissionT2 = ssmu_mcb.config.retransmissionT2;
p_rv->stack_cfg.retransmissionT4 = ssmu_mcb.config.retransmissionT4;
p_rv->stack_cfg.inviteLingerTimer = ssmu_mcb.config.inviteLingerTmD;
p_rv->stack_cfg.generalRequestTimeoutTimer = ssmu_mcb.config.generalRequestTmF;
p_rv->stack_cfg.generalLingerTimer = ssmu_mcb.config.generalLingerTmJ;
//设置会话刷新定时器及刷新使用方法
p_rv->stack_cfg.minSE =
ssmu_mcb.config.session_timer.session_min_expire;
p_rv->stack_cfg.sessionExpires =
ssmu_mcb.config.session_timer.session_desired_expire;
ssmu_mcb.config.session_timer.sip_method = SIP_METHOD_INVITE;
//根据用户配置，生成根据扩展功能列表，目前VTP的扩展功能选项包括
//replaces、100rel、timer、path、sec-agree、P-Early-Media、precondition
ssmu_rv_supported_init(list);
p_rv->stack_cfg.supportedExtensionList = list;
//拒绝不支持的扩展
p_rv->stack_cfg.rejectUnsupportedExtensions = TRUE;
//支持TEL格式URL的解析
p_rv->stack_cfg.bResolveTelUrls = TRUE;
//设置临时应答处理超时时间
p_rv->stack_cfg.provisionalTimer = 240000;
//设置安全联盟所需要资源对象数量
p_rv->stack_cfg.maxSecAgrees = (ssmu_mcb.num_tcids * 2);
p_rv->stack_cfg.maxSecurityObjects = (ssmu_mcb.num_tcids * 2);
//配置AKA鉴权认证的OP值
AkaUseConfiguredOP(ssmu_mcb.config.aka_auth_op);
//RV日志模块配置
ssmu_rv_cfg_log (p_rv);
//过滤全开
RvInt32 iFilters = RVSIP_LOG_INFO_FILTER |
RVSIP_LOG_ERROR_FILTER |
RVSIP_LOG_DEBUG_FILTER |
RVSIP_LOG_EXCEP_FILTER |
RVSIP_LOG_WARN_FILTER |
RVSIP_LOG_LOCKDBG_FILTER|
RVSIP_LOG_ENTER_FILTER |
RVSIP_LOG_LEAVE_FILTER;
//设置栈的日志模块打印回调，
p_rv->stack_cfg.pfnPrintLogEntryEvHandler = ssmu_rv_log_handler;
//设置这些模块的日志过滤全开
p_rv->stack_cfg.callLogFilters = iFilters;
p_rv->stack_cfg.transactionLogFilters = iFilters;
p_rv->stack_cfg.msgLogFilters = iFilters;
p_rv->stack_cfg.transportLogFilters = iFilters;
p_rv->stack_cfg.parserLogFilters = iFilters;
p_rv->stack_cfg.stackLogFilters = iFilters;
p_rv->stack_cfg.msgBuilderLogFilters = iFilters;
p_rv->stack_cfg.authenticatorLogFilters = iFilters;
p_rv->stack_cfg.transmitterLogFilters = iFilters;
p_rv->stack_cfg.resolverLogFilters = iFilters;
p_rv->stack_cfg.regClientLogFilters = iFilters;
p_rv->stack_cfg.subscriptionLogFilters = iFilters;
p_rv->stack_cfg.compartmentLogFilters = iFilters;
p_rv->stack_cfg.authenticatorLogFilters = iFilters;
p_rv->stack_cfg.secAgreeLogFilters = iFilters;
p_rv->stack_cfg.securityLogFilters = iFilters;
//设置这些模块的日志过滤全部关闭
p_rv->stack_cfg.adsFiltersCfg.adsRListLogFilters = 0x00;
p_rv->stack_cfg.adsFiltersCfg.adsRaLogFilters = 0x00;
p_rv->stack_cfg.adsFiltersCfg.adsRPoolLogFilters = 0x00;
p_rv->stack_cfg.adsFiltersCfg.adsHashLogFilters = 0x00;
p_rv->stack_cfg.adsFiltersCfg.adsPQueueLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreSemaphoreLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreMutexLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreLockLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreMemoryLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreThreadLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreQueueLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreTimerLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreTimestampLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreClockLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreTmLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreSocketLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.corePortRangeLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreSelectLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreHostLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreTlsLogFilters = 0x00;
p_rv->stack_cfg.coreFiltersCfg.coreAresLogFilters = 0x00;
//初始化协议栈
ssmu_rv_init_stack (p_rv);
//使用用户配置构造协议栈对象
RvSipStackConstruct(sizeof(p_rv->stack_cfg), &p_rv->stack_cfg, &p_rv->stack_handle);
//初始化通用核心模块
RvCBaseInit();
//初始化全局变量数据
RvStartGlobalDataServices(&glDataSrvStarted);
//校验只执行一次
if (gsGlobalDataStarted)
return RV_OK;
//复位全局变量数据块
memset(gsGlobalsDataArray,0,
sizeof(RvGlDataStruct)*RV_MAX_GL_DATA_INDEX);
//标记已经初始化
gsGlobalDataStarted = RV_TRUE;
//获取全局变量数据块中CCORE的数据区
__globals__ = RvGetGlobalDataPtr(RV_CCORE_GLOBALS_INDEX);
if (__globals__ == NULL) //第一次使用
// 创建CCORE的数据块数据，主要由RvCCoreInitializeGlobals回调函
//数执行，设置核心模块的默认参数，比如线程属性等。
//gsGlobalsDataArray[RV_CCORE_GLOBALS_INDEX].iGlobalData =
RvCCoreInitializeGlobals (RV_CCORE_GLOBALS_INDEX,NULL);
// gsGlobalsDataArray[RV_CCORE_GLOBALS_INDEX].iDestroyFunc =
RvCCoreDestroyGlobals;
// gsGlobalsDataArray[RV_CCORE_GLOBALS_INDEX]. iRefCount = 1;
// gsGlobalsDataArray[RV_CCORE_GLOBALS_INDEX]. iIndex =
RV_CCORE_GLOBALS_INDEX;
RvCreateGlobalData(RV_CCORE_GLOBALS_INDEX,
RvCCoreInitializeGlobals,NULL,RvCCoreDestroyGlobals);
//校验只初始化一次，其中RvCBaseInitCount宏定义为
// RvGetGlobalDataPtr(RV_CCORE_GLOBALS_INDEX)-> _RvCCoreInitCount
if(RvCBaseInitCount != 0)
RvCBaseInitCount++;
return RV_OK;
//通道核心模块初始化
RvCCoreInit();
//校验只初始化一次
if(RvCCoreInitCount != 0)
RvCCoreInitCount++;
return RV_OK;
//调用所有核心模块的初始化，各模块初始化函数的代码注释都放在
//下面，所有模块初始化函数分别为：
// RvTimestampInit
// RvSemaphoreInit
// RvMutexInit
// RvLockInit
// Rv64AsciiInit
// RvTmInit
// RvClockInit
// RvMemoryInit
// RvThreadInit
// RvLogListenerInit
// RvLogInit
// RvSelectInit
// RvSocketInit
// RvIpsecInit
// RvHostInit
// RvTLSInit
// RvAresInit
// RvStdioInit
RvCCoreNumModules = 0;
for(;;)
RvCCoreModules[RvCCoreNumModules].init();
RvCCoreNumModules++;
RvCCoreInitCount++;
RvCBaseNumModules = 0;
//所有基本模块初始化，各模块的代码注释都放在下面，所有基本模块的
//初始化函数分别为：
// RvQueueInit
// RvTimerInit
// RvTimerEngineInit
for(;;)
RvCBaseModules[RvCBaseNumModules].init();
RvCBaseNumModules++;
RvCBaseInitCount++;
//分配系统内存驱动模块分配一块内存（最终就是调用的系统的malloc，分配
//实现详见之前RvMemoryInit内存模块初始化）
RvMemoryAlloc(NULL,sizeof(StackMgr),NULL,(void**)&pStackMgr);
memset(pStackMgr, 0, sizeof(StackMgr));
//预配置临时变量
RvSipStackInitCfg(sizeof(internalCfgStruct),&internalCfgStruct);
//使用用户配置
minCfgSize = RvMin(((RvInt)sizeOfCfg),(RvInt)sizeof(internalCfgStruct));
memcpy(&internalCfgStruct, pStackCfg, minCfgSize);
//构造日志模块
ConstructStackLog(pStackMgr, &internalCfgStruct);
pStackMgr->pLogMgr = NULL;
//构造日志管理对象
RvLogConstruct(&pStackMgr->logMgr);
//设置默认掩码，这里RV_LOGMASK = RV_LOGLEVEL_ALL
logMgr->defaultMask = RV_LOGMASK;
//设置日志管理对象等级模式为与掩码相同
logMgr->level = RV_LOG_MASK;
RvLockConstruct(NULL, &logMgr->lock); //锁构造
//调用所有日志源的构造函数
//这里所有日志源的构造函数分别为
// RvSemaphoreSourceConstruct
// RvMutexSourceConstruct
// RvLockSourceConstruct
// RvMemorySourceConstruct
// RvThreadSourceConstruct
// RvQueueSourceConstruct
// RvTimerSourceConstruct
// RvTimestampSourceConstruct
// RvClockSourceConstruct
// RvTmSourceConstruct
// RvSocketSourceConstruct
// RvPortRangeSourceConstruct
// RvSelectSourceConstruct
// RvHostSourceConstruct
// RvTLSSourceConstruct
// RvAresSourceConstruct
// rvIpsecSourceConstruct
//下面仅将一个日志源函数的流程进行分解
RvLogModules[i].srcConstruct(logMgr);
//分解信号量日志源的构造函数
RvSemaphoreSourceConstruct
RvLogSourceConstruct(logMgr, &logMgr->sema4Source,
"SEMA4", "Semaphores interface");
int vacantIndex = -1;
RvLockGet(&logMgr->lock,NULL);
curSource = logMgr->source;
for (i = 0; i < logMgr->numSources; i++)
//找到第一个可以使用的索引位
if ((vacantIndex < 0) &&
(curSource->timesConstructed == 0))
vacantIndex = i;
//如果之前已经存在，则使用已存在的索引位
else if ((curSource->timesConstructed > 0) &&
(strcmp(curSource->name, name) == 0))
vacantIndex = i;
break;
curSource++;
if (vacantIndex < 0) //没有找到可用的索引位
//新加一个
vacantIndex = logMgr->numSources;
logMgr->numSources++;
//获取日志源对象指针
curSource = &logMgr->source[vacantIndex];
if (curSource->timesConstructed == 0)//之前没有处理
//记载信息
curSource->logMgr = logMgr;
strncpy(curSource->name, name,
sizeof(curSource->name));
curSource->messageTypes = logMgr->defaultMask;
curSource->timesConstructed++; //引用递增
*source = curSource; //返回日志源对象
RvLockRelease(&logMgr->lock,NULL);
//指针赋值
pStackMgr->pLogMgr = &pStackMgr->logMgr;
//标记日志信息需要打印线程ID
RvLogPrintThreadId(pStackMgr->pLogMgr);
logMgr->printThreadId = RV_TRUE;
//这里的日志打印回调就是上层传递的ssmu_rv_log_handler，用于使用
//VTP的日志接口输出
pStackMgr->pfnPrintLogEntryEvHandler =
pStackCfg->pfnPrintLogEntryEvHandler;
pStackMgr->logContext = pStackCfg->logContext;
//注册日志接收者对象，其中回调 LogPrintCallbackFunction 用于格式化
//日志输出信息，最后调用上层设置的回调将日志信息输出。
RvLogRegisterListener(pStackMgr->pLogMgr, LogPrintCallbackFunction,
(void*)pStackMgr);
//标记不使用日志输出文件
pStackMgr->bLogFileListenerEnabled = RV_FALSE;
//设置CORE模块相关日志源过滤
SetTemporaryCoreLogMasks(pStackMgr, pStackCfg);
//将所有日志源先使用默认过滤，即ALL
RvLogSetGlobalMask(pStackMgr->pLogMgr,
SipCommonConvertSipToCoreLogMask(pStackCfg->defaultLogFilters));
//冗余代码
if(pStackCfg->coreLogFilters > 0)
RvLogSetGlobalMask(pStackMgr->pLogMgr, SipCommonConvertSipToCoreLogMask
(pStackCfg->defaultLogFilters));
//将从 RVSIP_CORE_SEMAPHORE至RVSIP_CORE_IMSIPSEC模块的日
//志源过滤设置为用户配置
firstModule = (RvInt32)RVSIP_CORE_SEMAPHORE;
lastModule = (RvInt32)RVSIP_CORE_IMSIPSEC;
for(i = firstModule; i<= lastModule; i++)
moduleMask =
GetModuleLogMaskFromCfg(pStackCfg,(RvSipStackModule)i);
RvLogGetSourceByName(pStackMgr->pLogMgr,
GetModuleName((RvSipStackModule)i),
&tempLogSource);
RvLogSourceSetMask(&tempLogSource,
SipCommonConvertSipToCoreLogMask(moduleMask));
//为所有模块都构造日志源
for(i=0; i<STACK_NUM_OF_LOG_SOURCE_MODULES; i++)
status = ConstructLogSource(pStackMgr,(RvSipStackModule)i);
//将SIP_STACK索引的日志源做为栈管理对象的日志源
pStackMgr->pLogSrc = pStackMgr->pLogSourceArrey[RVSIP_STACK];
//设置所有日志源都使用默认的过滤
RvLogSetGlobalMask(pStackMgr->pLogMgr,
SipCommonConvertSipToCoreLogMask(pStackCfg->defaultLogFilters));
//如果上层有配置CORE模块的过滤，则CORE相关模块都使用用户值
if(pStackCfg->coreLogFilters > 0)
RvSipStackSetNewLogFilters((RvSipStackHandle)pStackMgr,
RVSIP_CORE,pStackCfg->coreLogFilters);
//如果上层有ADS相关模块的过滤，则ADS相关模块都使用用户值
if(pStackCfg->adsLogFilters > 0)
RvSipStackSetNewLogFilters((RvSipStackHandle)pStackMgr,
RVSIP_ADS,pStackCfg->adsLogFilters);
//按用户配置，设置所有日志源的过滤
for(i=0; i<STACK_NUM_OF_LOG_SOURCE_MODULES; i++)
logMask = GetModuleLogMaskFromCfg(pStackCfg,(RvSipStackModule)i);
if(logMask > 0)
RvSipStackSetNewLogFilters((RvSipStackHandle)pStackMgr,
(RvSipStackModule)i,logMask);
//打印相关系统信息，如当前CORE模块版本号，当前系统类型等
RvLogSourcePrintInterfacesData(pStackMgr->pLogSrc, RvCCoreInterfaces());
//参数校正，就是防止上层用户配置超出协议栈允许的配置范围
CalculateConfigParams(pStackMgr, &internalCfgStruct);
//内存池构造
StackAllocateMemoryPools(&internalCfgStruct, pStackMgr);
//消息池的构造
pStackMgr->hMessagePool =
RPOOL_CoreConstruct(pStackCfg->messagePoolPageSize,
pStackCfg->messagePoolNumofPages,
pStackMgr->pLogMgr, RV_TRUE, "MessagePool");
//计算所需要使用的总内存大小
//在RV协议栈里，没有直接使用内存，而是在内存之上封装了
//一个RA接口，这样在分配内存时都会多出一个RA头，这里
//RA主要为了管理分配出来的内存块，并且这里因为使用内存
//池的机制，这样在分配内存大小时，每个内存块都会有一个
//块头，及多一个总的内存池头。
allocSize = RA_AllocationSize(elemSize + sizeof(RPOOL_FirstElem),
maxNumOfBlocks) + sizeof(RPOOL);
//这里分配内存资源，就是用的系统的malloc函数，可以
//从上面内存驱动对象的构建了解这个函数的实现。
RvMemoryAlloc(NULL, allocSize, NULL, (void*)&rpool);
//在malloc好的内存上使用RA模块创建RA内存区
rpool->hra = RA_ConstructFrom(elemSize +
sizeof(RPOOL_FirstElem), maxNumOfBlocks,
(RvChar *)rpool + sizeof(RPOOL), NULL, pLogMgr, name);
//填充内存池头信息
rpool->blockSize =
(RvUint32)RvRoundToSize(elemSize,ADS_ALIGN_NUMBER);
rpool->numOfBlocks = maxNumOfBlocks;
//通用内存池构造
pStackMgr->hGeneralPool =
RPOOL_CoreConstruct(pStackCfg->generalPoolPageSize,
pStackCfg->generalPoolNumofPages,
pStackMgr->pLogMgr, RV_TRUE, "GeneralPool");
//元素池构造，用于订阅机制
pStackMgr->hElementPool =
RPOOL_CoreConstruct(pStackCfg->elementPoolPageSize,
pStackCfg->elementPoolNumofPages, pStackMgr->pLogMgr,
RV_TRUE, "ElementPool");
//栈扩展支持列表的构造
StackConstructSupportedList(internalCfgStruct.supportedExtensionList,
pStackMgr);
//计算支持的扩展数
size = (int)strlen(supportedList);
for(i=0; i<size ; i++)
if(supportedList[i] == ',')
numOfTokens++;
//为 pStackMgr->supportedExtensionList 分配内存资源
RvMemoryAlloc(NULL,numOfTokens * sizeof(RvChar*),pStackMgr->pLogMgr,
(void**)&pStackMgr->supportedExtensionList)
//最终将所有支持的扩展项字符串都复制到
//pStackMgr->supportedExtensionList[]数组中，以及将总的支持数设置
//到pStackMgr->extensionListSize中
//使用时间源设置随机种子
// pStackMgr->seed = RvClockGet(NULL,NULL);
RvRandomGeneratorConstruct(&pStackMgr->seed,
(RvUint32)RvClockGet(NULL,NULL));
//构造所有栈模块。这块内容比较多，单独写在另一个文档中。
//*********** 放在其它文档里描述 ***********
StackConstructModules(&internalCfgStruct, pStackMgr);
//获取从当前线程私有变量中获取select对象句柄，设置
//到pStackMgr->pSelect中
RvSelectGetThreadEngine(pStackMgr->pLogMgr,&pStackMgr->pSelect);
//返回已经创建好的栈管理对象
*hStack = (RvSipStackHandle)pStackMgr;
//将配置返回
memcpy(pStackCfg,&internalCfgStruct,minCfgSize);
//各模块句柄初始化，将栈管理的所有模块句柄分散出来
ssmu_rv_init_handles (p_rv);
RvSipStackGetCallLegMgrHandle (p_rv->stack_handle, &p_rv->call_leg_mgr);
RvSipStackGetLogHandle (p_rv->stack_handle, &p_rv->log_handle);
RvSipStackGetRegClientMgrHandle (p_rv->stack_handle, &p_rv->reg_client_mgr);
RvSipStackGetAuthenticatorHandle(p_rv->stack_handle, &p_rv->auth_client_mgr);
RvSipStackGetTransportMgrHandle (p_rv->stack_handle, &p_rv->transport_mgr);
RvSelectGetThreadEngine (NULL, &p_rv->select_engine);
RvSipStackGetResolverMgrHandle (p_rv->stack_handle, &p_rv->resolver_mgr);
RvSipStackGetSecAgreeMgrHandle (p_rv->stack_handle, &p_rv->g_hSecAgreeMgr);
//鉴权初始化，仅仅设置鉴权模块的用户句柄为NULL
ssmu_rv_init_auth (p_rv);
RvSipAuthenticatorSetAppHandle (p_rv->auth_client_mgr, NULL);
//用户内存池构造
ssmu_rv_init_rpool (p_rv);
p_rv->rv_app_pool = RPOOL_Construct(1024, 10, p_rv->log_handle,
RV_FALSE, "ApplicationPool");
//SDP模块构造
ssmu_rv_init_sdp (p_rv);
RvSdpMgrConstruct();
RvSdpMgrConstructWithConfig(NULL, 0);
//基本模块构造，因为之前已经执行过RvCBaseInit函数了，所以
//需要的基本模块都已经完成了。
RvCBaseInit();
//获取SDP使用的全局数据
__globals__ = (RvSdpGlobals *)
RvGetGlobalDataPtr(RV_SDP_GLOBALS_INDEX);
//第一次使用，当前为NULL
if (__globals__ == NULL)
//这里会使用RvSdpInitializeGlobals回调进行SDP模块的全局
//数据块初始化
RvCreateGlobalData(RV_SDP_GLOBALS_INDEX,RvSdpInitializeGlobals,
NULL,RvSdpDestroyGlobals)
//重新获取SDP使用的全局数据指针
__globals__ =
(RvSdpGlobals *)RvGetGlobalDataPtr(RV_SDP_GLOBALS_INDEX);
__globals__->_sdpRefCount ++; //引用递增
//设置SDP模块的默认malloc内存驱动
// __globals__->_ gSdpDefaultAlloc = rvAllocGetDefaultAllocator
rvSdpSetDefaultAllocator(rvAllocGetDefaultAllocator());
//编码初始化
rvSdpCodecInitialize();
//复位SDP模块中全局数据中的解析表
memset(gsParsersTable,0,sizeof(gsParsersTable));
gsParsersTableLen = 0;
//各种编码初始化
RvSdpCodec_H263_Init(rvSdpGetDefaultAllocator());
RvSdpCodec_H261_Init(rvSdpGetDefaultAllocator());
……
RvSdpCodec_PCMA_Init(rvSdpGetDefaultAllocator());
RvSdpCodecParserInternal *cp;
//构造编码解析，这里传参是当前编码的FMTP解析参数
//以及当前编码的属性解析参数
cp =
RvSdpCodecParserInternalConstruct(gs_PCMA_FmtpParserData,
gs_PCMA_AttrsParserData,a);
//分配内存资源
cp = rvSdpAllocAllocate(a,sizeof(RvSdpCodecParserInternal));
//设置编码解析的内存管理为默认的内存驱动对象
cp->iAllocator = a;
//遍历传参的当前编码FMTP属性
for (cnt = 0; fpdArr[cnt].iParamNum >=0 &&
fpdArr[cnt].iFmtpParamValueSyntax; cnt++)
//获取每个FMTP传参
fpd = &(fpdArr[cnt]);
//根据参数类型及语法构造编码参数数据
f = RvSdpParamDataConstruct(fpd->iParamNum,
fpd->iFmtpParamValueSyntax,a);
fd->iAllocator = a; //设置内存管理对象
fd->iParamName = xxx//参数名字
fd->iParamNameLen =xxx//参数名字长度
fd->iParamNum = xxx//参数的类型索引
//如果参数语法有=号，则表示有参数的
//取值语法，这里使用
// RvSdpFtmpValueSyntaxConstruct(txt,a)
//进行解析处理。
fd->iValueSyntax =
RvSdpFtmpValueSyntaxConstruct(txt,a);
return fd;
//用参数名称的首字母做为HASH KEY算法
index = tolower((int)f->iParamName[0]) - 'a';
//将之前的构造的参数数据存储到iFmtpParamData
//中，同时将新建的参数数据插入到FMTP参数数据
//列表中。
fm = cp->iFmtpParamData[index];
cp->iFmtpParamData[index] = f;
f->iNextParam = fm;
//遍历传参的当前编码分析属性
for (cnt = 0; apdArr[cnt].iParamNum >=0 &&
apdArr[cnt].iFmtpParamValueSyntax; cnt++)
//获取每个传参属性
fpd = &(apdArr[cnt]);
//构造属性数据
RvSdpParamDataConstruct(fpd->iParamNum,
fpd->iFmtpParamValueSyntax,a);
//将之前构造的属性数据存储到iAttrParamData
//中，同时将新建的属性数据插入到属性参数据
//列表中。
fm = cp->iAttrParamData;
cp->iAttrParamData = f;
f->iNextParam = fm;
return cp;
//初始化中间模块
ssmu_rv_init_mid (p_rv);
RvSipMidInit();
//基本模块构造，因为之前已经执行过RvCBaseInit函数了，所以
//需要的基本模块都已经完成了。
RvCBaseInit();
//Mid管理模块构造
RvSipMidConstruct(sizeof(p_rv->mid_cfg), &p_rv->mid_cfg, &p_rv->mid_mgr);
//将配置复制到临时变量中
memcpy(&internalCfg, pMidCfg, minStructSize);
//给Mid管理模块分配内存资源
RvMemoryAlloc(NULL,sizeof(MidMgr),(RvLogMgr*)internalCfg.hLog,
(void**)&pMidMgr);
pMidMgr->pLogMgr = (RvLogMgr*)internalCfg.hLog; //设置日志管理模块
//构造select互斥量
RvMemoryAlloc(NULL,sizeof(RvMutex),pMidMgr->pLogMgr,
(void**)&pMidMgr->pSelectMutex);
RvMutexConstruct(pMidMgr->pLogMgr,pMidMgr->pSelectMutex);
//构造定时器互斥量
RvMemoryAlloc(NULL,sizeof(RvMutex),pMidMgr->pLogMgr,
(void**)&pMidMgr->pTimerMutex);
RvMutexConstruct(pMidMgr->pLogMgr,pMidMgr->pTimerMutex);
//分配MID模块所需要的所有资源
MidMgrAllocateResources(pMidMgr, &internalCfg);
//构造用户定时器列表池
pMidMgr->userTimerPool =
RLIST_PoolListConstruct(pMidCfg->maxUserTimers, 1,sizeof(MidTimer),pMidMgr->pLogMgr,"User Timer");
//填充用户定时器列表头
pMidMgr->hUserTimers = RLIST_ListConstruct(pMidMgr->userTimerPool);
//构造用户描述符池
pMidMgr->userFDPool = RLIST_PoolListConstruct(pMidCfg->maxUserFd,
1,sizeof(SeliUserFd),pMidMgr->pLogMgr,"User Fd");
//填充用户描述符列表头
pMidMgr->hUserFds = RLIST_ListConstruct(pMidMgr->userFDPool);
//设置MID管理模块最大定时器数量
pMidMgr->maxTimers = pMidCfg->maxUserTimers;
//构造MID管理对象中的select对象
RvSelectConstruct(2048,pMidCfg->maxUserTimers,pMidCfg->sig_dev,
pMidMgr->pLogMgr,&pMidMgr->pSelect);
//获取当前线程管理句柄
th = RvThreadCurrent();
if (th == NULL)
RvMemoryAlloc(NULL,sizeof(RvThread),logMgr,(void **)&th);
//基于当前用户线程构造线程管理对象
RvThreadConstructFromUserThread(logMgr, th);
//构造线程管理对象
RvThreadConstruct(rvDummyThreadFunc, NULL, logMgr, th);
RvLockGet(&RvThreadLock,logMgr); //加锁
//设置线程状态为特定用户线程
th->state = RV_THREAD_STATE_SPECIAL;
//线程名称
strncpy(th->name, "RvUserDefault",
RV_THREAD_MAX_NAMESIZE);
th->id = RvThreadCurrentId(); //获取用户线程ID
//获取用户线程优先级
RvThreadGetOsPriority(th->id, (RvInt32*)&th->priority);
//设置线程私有变量
RvThreadSetupThreadPtr(th);
RvLockRelease(&RvThreadLock,logMgr); //解锁
//将当前线程管理句柄设置到临时变量里
constructedThread = th;
//从当前线程的私有变量中获取当前select对象
RvThreadGetVar(rvSelectTlsVarIndex, logMgr,(void **)&selectEngine);
//select对象分配资源
RvMemoryAlloc(NULL,sizeof(RvSelectEngine),logMgr, &selectEngine);
//设置日志管理对象，和当前构造select的线程
selectEngine->logMgr = logMgr;
selectEngine->constructedThread = constructedThread;
//设置select对象的初始回调函数，空
RvSelectPreemptionHandlersConstruct(selectEngine);
//select对象的锁构造
RvLockConstruct(selectEngine->logMgr, &selectEngine->lock);
//select对象的水桶型HASH表构造
fdBucketHashConstruct(selectEngine, maxHashSize);
//参数复位
selectEngine->maxFd = rvSelectMaxDescriptors;
selectEngine->maxFdInSelect = 0;
RV_FD_ZERO(&selectEngine->rdSet);
RV_FD_ZERO(&selectEngine->wrSet);
selectEngine->usageCnt = 1; //递增select对象的引用计数
//将当前构造好的select对象句柄设置到当前线程的私有变量中
RvThreadSetVar(rvSelectTlsVarIndex,(void *)selectEngine,logMgr);
//构造select对象的定时器队列
RvTimerQueueConstruct(RV_TIMER_QTYPE_FIXED, maxTimers, 0, 0, 0,
RV_SELECT_TIMERS_PER_PAGE, NULL, selectEngine, logMgr,
&selectEngine->tqueue);
selectEngine->maxTimers = maxTimers; //记载支持的最大定时器
//移除锁构造
RvLockConstruct(logMgr, &selectEngine->removalLock);
selectEngine->removalSyncList = 0;
//返回已经创建好的select对象
*engine = selectEngine;
return status;
//初始化回调接口
ssmu_rv_init_cbs (p_rv);
//对话相关回调设置
p_rv->call_leg_ev_handler.pfnCallLegCreatedEvHandler =
ssmu_rv_created_call_leg_ev_cb;
p_rv->call_leg_ev_handler.pfnStateChangedEvHandler =
ssmu_rv_call_leg_state_changed_ev_cb;
p_rv->call_leg_ev_handler.pfnMsgReceivedEvHandler =
ssmu_rv_received_msg_call_leg_ev_cb;
p_rv->call_leg_ev_handler.pfnMsgToSendEvHandler =
ssmu_rv_tosend_msg_call_leg_ev_cb;
p_rv->call_leg_ev_handler.pfnTranscRequestRcvdEvHandler =
ssmu_rv_transaction_req_recvd_call_leg_ev_cb;
p_rv->call_leg_ev_handler.pfnTranscResolvedEvHandler =
ssmu_rv_transaction_resolved_call_leg_ev_cb;
p_rv->call_leg_ev_handler.pfnModifyResultRcvdEvHandler =
ssmu_rv_modify_result_recvd_ev_cb;
p_rv->call_leg_ev_handler.pfnTranscStateChangedEvHandler =
ssmu_rv_trans_state_changed_ev_cb;
p_rv->call_leg_ev_handler.pfnTranscCreatedEvHandler =
ssmu_rv_trans_created_ev_cb;
p_rv->call_leg_ev_handler.pfnFinalDestResolvedEvHandler =
ssmu_rv_call_leg_dest_resolvedev_cb;
p_rv->call_leg_ev_handler.pfnReInviteCreatedEvHandler =
ssmu_rv_reinvite_recv_ev_cb;
p_rv->call_leg_ev_handler.pfnReInviteStateChangedEvHandler =
ssmu_rv_reinvite_state_changed_ev_cb;
p_rv->call_leg_ev_handler.pfnPrackStateChangedEvEvHandler =
ssmu_rv_prack_state_changed_ev_cb;
p_rv->call_leg_ev_handler.pfnSigCompMsgNotRespondedEvHandler =
AppCallLegSigCompMsgNotRespondedEvHandler;
//会话刷新相关回调设置
ssmu_rv_init_session_cbs(p_rv);
p_rv->call_leg_ev_handler.pfnSessionTimerNegotiationFaultEvHandler =
ssmu_rv_call_leg_session_notify_fault_cb;
p_rv->call_leg_ev_handler.pfnSessionTimerNotificationEvHandler =
ssmu_rv_call_leg_session_notify_cb;
p_rv->call_leg_ev_handler.pfnSessionTimerRefreshAlertEvHandler =
ssmu_rv_call_leg_session_refresh_cb;
//向协议栈挂载呼叫对话相关回调
RvSipCallLegMgrSetEvHandlers(p_rv->call_leg_mgr, &p_rv->call_leg_ev_handler,
sizeof(RvSipCallLegEvHandlers));
RvMutexLock(&pMgr->hMutex,pMgr->pLogMgr);
memcpy(&(pMgr->callLegEvHandlers),pEvHandlers,minStructSize);
RvMutexUnlock(&pMgr->hMutex,pMgr->pLogMgr);
//注册相关回调设置
ssmu_reg_setup_cbs();
//回调设置
evh.pfnStateChangedEvHandler = ssmu_reg_state_changed_ev_cb;
evh.pfnMsgReceivedEvHandler = ssmu_reg_recvd_msg_ev_cb;
evh.pfnMsgToSendEvHandler = ssmu_reg_tosend_msg_ev_cb;
evh.pfnFinalDestResolvedEvHandler = ssmu_reg_dest_resolved_ev_cb;
evh.pfnSigCompMsgNotRespondedEvHandler =
AppRegClientSigCompMsgNotRespondedEv;
//向协议栈挂载回调
RvSipRegClientMgrSetEvHandlers(p_rv->reg_client_mgr, &evh, sizeof(evh));
RegClientMgrLock(pRegClientMgr);
memcpy(&(pRegClientMgr->regClientEvHandlers), pEvHandlers, structSize);
RegClientMgrUnLock(pRegClientMgr);
//鉴权相关回调设置
ssmu_auth_setup_cbs();
//回调设置
evh.pfnMD5AuthenticationHandler = ssmu_auth_md5_ev_cb;
evh.pfnGetSharedSecretAuthenticationHandler = ssmu_auth_get_secret_ev_cb;
//向协议栈挂载回调
RvSipAuthenticatorSetEvHandlers(p_rv->auth_client_mgr, &evh, sizeof(evh);
RvMutexLock(&pAuthMgr->lock,pAuthMgr->pLogMgr);
memcpy(&(pAuthMgr->evHandlers), evHandlers, evHandlersSize);
RvMutexUnlock(&pAuthMgr->lock,pAuthMgr->pLogMgr);
//事务管理相关回调设置
ssmu_trans_setup_cbs();
//回调设置
transcEvHandlers.pfnEvMsgReceived=ssmu_trans_msg_rcv_cb;
transcEvHandlers.pfnEvMsgToSend=ssmu_trans_msg_to_send_cb;
transcEvHandlers.pfnEvStateChanged=ssmu_trans_state_changed_cb;
transcEvHandlers.pfnEvTransactionCreated=ssmu_trans_created_cb;
transcEvHandlers.pfnEvFinalDestResolved=ssmu_trans_dest_resolvedev_cb;
transcEvHandlers.pfnEvSigCompMsgNotResponded =
ssmu_trans_sigcomp_not_resp_cb;
//向协议栈挂载回调
RvSipTransactionMgrSetEvHandlers(p_rv->trans_mgr, NULL, &transcEvHandlers,
sizeof(RvSipTransactionEvHandlers);
RvMutexLock(&pTranscMgr->hLock,pTranscMgr->pLogMgr);
memcpy(&(pTranscMgr->pAppEvHandlers), pHandlers, minStructSize);
RvMutexUnlock(&pTranscMgr->hLock,pTranscMgr->pLogMgr);
//订阅相关回调设置
ssmu_subs_setup_cbs();
//回调设置
appEvHandlers.pfnStateChangedEvHandler = ssmu_subs_state_changed_ev_cb;
appEvHandlers.pfnMsgReceivedEvHandler = ssmu_subs_msg_received_ev_cb;
appEvHandlers.pfnMsgToSendEvHandler = ssmu_subs_msg_to_send_ev_cb;
appEvHandlers.pfnSubsExpiredEvHandler = ssmu_subs_expired_ev_cb;
appEvHandlers.pfnNotifyEvHandler = ssmu_subs_notify_ev_cb;
appEvHandlers.pfnExpirationAlertEvHandler = ssmu_subs_alert_ev_cb;
appEvHandlers.pfnReferNotifyReadyEvHandler =
ssmu_subs_refer_notify_ready_ev_cb;
appEvHandlers.pfnFinalDestResolvedEvHandler = ssmu_subs_dest_resolvedev_cb;
appEvHandlers.pfnSigCompMsgNotRespondedEvHandler =
AppSubsSigCompMsgNotRespondedEv;
//向协议栈挂载回调
RvSipSubsMgrSetEvHandlers( ssmu_mcb.rv_ctrl.subs_mgr, &appEvHandlers,
sizeof(RvSipSubsEvHandlers));
RvMutexLock(&pMgr->hMutex,pMgr->pLogMgr);
memcpy(&(pMgr->subsEvHandlers),pEvHandlers,minStructSize);
RvMutexUnlock(&pMgr->hMutex,pMgr->pLogMgr);
//网络连接相关回调
ssmu_conn_setup_cbs();
//回调设置
p_ev->pfnEvBufferReceived = ssmu_transport_buffer_received_ev;
p_ev->pfnEvBufferToSend = ssmu_transport_buffer_to_send_ev;
//向协议栈挂载回调
RvSipTransportMgrSetEvHandlers(p_rv->transport_mgr, NULL, p_ev,
sizeof(*p_ev));
RvMutexLock(&pTransportMgr->udpBufferLock,pTransportMgr->pLogMgr);
memcpy(&(pTransportMgr->appEvHandlers), pHandlers, minStructSize);
RvMutexUnlock(&pTransportMgr->udpBufferLock,pTransportMgr->pLogMgr);
//安全联盟相关回调
ssmu_sec_agree_setup_cbs();
//回调设置
appSecAgreeEvHandlers.pfnSecAgreeStateChangedEvHandler =
AppClientSecAgreeStateChangedEvHandler;
appSecAgreeEvHandlers.pfnSecAgreeStatusEvHandler =
AppClientSecAgreeStatusEvHandler;
//向协议栈挂载回调
RvSipSecAgreeMgrSetSecAgreeEvHandlers(ssmu_mcb.rv_ctrl.g_hSecAgreeMgr,
&appSecAgreeEvHandlers, sizeof(RvSipSecAgreeEvHandlers));
RvMutexLock(&pSecAgreeMgr->hMutex,pSecAgreeMgr->pLogMgr);
memcpy(&(pSecAgreeMgr->appEvHandlers),pEvHandlers,minStructSize);
RvMutexUnlock(&pSecAgreeMgr->hMutex,pSecAgreeMgr->pLogMgr);
//如果开启信令压缩功能，则初始化信令压缩
if (ssmu_mcb.config.sipcomp_enable)
AppInitSigComp();
//使用协议栈的初始化函数复位默认的信令压缩配置
RvSigCompInitCfg(sizeof(sigCompCfg), &sigCompCfg);
//信令压缩管理对象构造
RvSigCompConstruct(sizeof(RvSigCompCfg),&sigCompCfg, &hSigCompMgr);
//基本模块初如化，前面已经初始化过了。
RvCBaseInit ();
//又执行了一遍复位默认的信令压缩配置
RvSigCompInitCfg(sizeof(internalCfgStruct),&internalCfgStruct);
//把用户配置覆盖到上面生成的临时配置，其中都一样，因为
//用户配置也是用的默认复位函数。
memcpy(&internalCfgStruct, pSigCompCfg, minCfgSize);
//为信令压缩管理对象分配内存资源
RvMemoryAlloc(NULL, sizeof(SigCompMgr), \
(RvLogMgr *)pSigCompCfg->logHandle, (void**)&pSigCompMgr);
//锁构造
RvMutexConstruct(pSigCompMgr->pLogMgr, &pSigCompMgr->lock);
pSigCompMgr->pLock = &pSigCompMgr->lock;
//参数合法校正
pSigCompMgr->sigCompVersion =
RvMax(SIGCOMP_VERSION,1);
……
pSigCompMgr->dynMaxTotalStatesSize =
RvMax(pSigCompCfg->dynMaxTotalStatesSize,0);
//分配一个算法列表池
algoListPoolHndl = RLIST_PoolListConstruct
(RVSIGCOMP_MAX_NUM_ALGORITHMS, 1,
sizeof(RvSigCompAlgorithm), pSigCompMgr->pLogMgr,
"SigCompAlgoListPool");
//分配一个字典列表池
dictListPoolHndl = RLIST_PoolListConstruct
(RVSIGCOMP_MAX_NUM_DICTIONARIES, 1,
sizeof(RvSigCompDictionary), pSigCompMgr->pLogMgr,
"SigCompDictListPool");
//构造一个算法列表
algoListHndl = RLIST_ListConstruct (algoListPoolHndl);
//构造一个字典列表
dictListHndl = RLIST_ListConstruct (dictListPoolHndl);
//将之前构造的列表及列表池设置到信令压缩管理对象中
pSigCompMgr->hDictionaryList = dictListHndl;
pSigCompMgr->hAlgorithmList = algoListHndl;
pSigCompMgr->hDictionaryListPool = dictListPoolHndl;
pSigCompMgr->hAlgorithmListPool = algoListPoolHndl;
//信令压缩引擎构造
SigCompCompressorDispatcherConstruct (pSigCompMgr);
//将压缩引擎的管理对象指向当前管理对象
pSigCompMgr->compressorDispMgr.pSCMgr = pSigCompMgr;
//信令解压缩引擎构造
SigCompDecompressorDispatcherConstruct (pSigCompMgr);
SigCompDecompressorDispatcherConstructSa(\
&pSCMgr->decompressorDispMgr,\
hManager,\
pSCMgr->maxTempCompartments,\
pSCMgr->timeoutForTempCompartments,\
pSCMgr->decompMemSize, pSCMgr->cyclePerBit);
//参数设置
pSelf->cyclesPerBit = cyclesPerBit;
pSelf->decompressionMemorySize=\
decompressionMemorySize;
pSelf->firstPendingMachine = NULL;
pSelf->lastPendingMachine = NULL;
pSelf->hManager = hManager;
pSelf->timeout = (timeout + 500) / 1000;
pSelf->curMessageId = 0;
//内存块构造
pSelf->perUdvmBlocks =\
RA_Construct(sizeof(SigCompPerUdvmBlock) \
+maxUdvmMemorySize, maxUdvmMachines,\
GET_RA_PRINT_FUNC(pSelf),
//锁构造
RvMutexConstruct(pSelf->pLogMgr, &pSelf->lock);
pSelf->pLock = &pSelf->lock;
//容器句柄构造
SigCompCompartmentHandlerConstruct(pSigCompMgr);
//将容器的管理对象指向当前管理对象
pSigCompMgr->compartmentHandlerMgr.pSCMgr = pSigCompMgr;
//分配一组内存
compHndlrCompRA = RA_Construct(sizeof(SigCompCompartment),
compNum, NULL, pLogMgr, "compartments array");
pSigCompMgr->compartmentHandlerMgr.hCompartmentRA = \ compHndlrCompRA;
//遍历总容器数
for(counter = 0; counter < compNum; counter++)
//从内存数组中分配一块内存
RA_Alloc(compHndlrCompRA, &pCompartment);
//为每个容器构造锁
RvMutexConstruct(pLogMgr, &pCompartment->lock);
//上面为每个容器构造完锁后，把每个容器的内存块在
//释放回内存数组中。
for(counter = 0; counter < compNum; counter++)
pCompartment = RA_GetAnyElement(compHndlrCompRA,\
counter);
RA_DeAllocByPtr(compHndlrCompRA, \
(RA_Element)pCompartment);
//复位内存数组使用计数
RA_ResetMaxUsageCounter(compHndlrCompRA);
//为每个容器创建一个状态列表池
hStateListPool = RLIST_PoolListConstruct((compNum * \
pSigCompMgr->maxStatesPerCompartment),\
compNum, sizeof(SigCompCompartmentState),\
pLogMgr, "compartment states list pool");
pSigCompMgr->compartmentHandlerMgr.hStateListPool = \
hStateListPool;
//构造信令压缩管理对象锁
RvMutexConstruct(pSigCompMgr->pLogMgr, \ &pSigCompMgr->compartmentHandlerMgr.lock);
pSigCompMgr->compartmentHandlerMgr.pLock =\
&pSigCompMgr->compartmentHandlerMgr.lock;
pSigCompMgr->compartmentHandlerMgr.maxStateMemoryPerCo mpartment = pSigCompMgr->stateMemSize;
//状态句柄构造
SigCompStateHandlerConstruct ((RvSigCompMgrHandle)pSigCompMgr);
//参数设置
pSCMgr->stateHandlerMgr.pSCMgr = pSCMgr;
pSCMgr->stateHandlerMgr.pLogMgr = pSCMgr->pLogMgr;
pSCMgr->stateHandlerMgr.pLogSrc = pSCMgr->pLogSource;
pSCMgr->stateHandlerMgr.smallBufSize =\
pSCMgr->smallBufPoolSize;
pSCMgr->stateHandlerMgr.smallBufAmount= \
pSCMgr->smallPoolAmount;
//构造小内存数组
pSCMgr->stateHandlerMgr.smallBufRA =\
RA_Construct(pSCMgr->smallBufPoolSize,\
pSCMgr->smallPoolAmount, NULL,\
pSCMgr->pLogMgr, "small buffers RA");
pSCMgr->stateHandlerMgr.mediumBufSize = \
pSCMgr->mediumBufPoolSize;
pSCMgr->stateHandlerMgr.mediumBufAmount =\
pSCMgr->mediumPoolAmount;
//构造中内存数组
pSCMgr->stateHandlerMgr.mediumBufRA = \
RA_Construct(pSCMgr->mediumBufPoolSize,\
pSCMgr->mediumPoolAmount, NULL, pSCMgr->pLogMgr,\ "medium buffers RA");
//构造大内存数组
pSCMgr->stateHandlerMgr.largeBufSize = \
pSCMgr->largeBufPoolSize;
pSCMgr->stateHandlerMgr.largeBufAmount = \
pSCMgr->largePoolAmount;
pSCMgr->stateHandlerMgr.largeBufRA = \
RA_Construct(pSCMgr->largeBufPoolSize,\
pSCMgr->largePoolAmount, NULL, pSCMgr->pLogMgr, \
"large buffers RA");
//构造一块HASH内存结构
numOfUserElements = pSCMgr->smallPoolAmount +\
pSCMgr->mediumPoolAmount +\
pSCMgr->largePoolAmount;
hashTableSize = numOfUserElements;
pSCMgr->stateHandlerMgr.hHashTable = \ HASH_Construct(hashTableSize,\
numOfUserElements,\
SigCompStateHashFunction,\
sizeof(SigCompState *),\
sizeof(SigCompMinimalStateID),\
pSCMgr->pLogMgr,\
"SigCompStateHandler statesDB");
//构造状态内存空间
pSCMgr->stateHandlerMgr.statesRA =
RA_Construct(sizeof(SigCompState),
//构造锁
RvMutexConstruct(pSCMgr->pLogMgr,、
&pSCMgr->stateHandlerMgr.lock);
pSCMgr->stateHandlerMgr.pLock = 、
&pSCMgr->stateHandlerMgr.lock;
//复位内存使用计数
RA_ResetMaxUsageCounter(pSCMgr->stateHandlerMgr.statesRA);
//将构造好的信令压缩管理对象返回给上层
*hSigCompMgr = (RvSigCompMgrHandle)pSigCompMgr;
//初始化空的信令压缩算法
AppInitSigCompNullAlgorithm(hSigCompMgr);
//初始化算法结构变量
SigCompAlgNullInit(hSigCompMgr, sizeof(sigCompAlg), &sigCompAlg);
memcpy(internalAlgStruct.algorithmName, \
NULL_ALGORITHM_NAME,\
sizeof(internalAlgStruct.algorithmName));
internalAlgStruct.bSharedCompression = RV_FALSE;
internalAlgStruct.contextSize = 0;
internalAlgStruct.decompBytecodeAddr = 128;
internalAlgStruct.decompBytecodeInst = 128;
internalAlgStruct.pDecompBytecode =\
decompressionBytecode;
internalAlgStruct.decompBytecodeSize =\
sizeof(decompressionBytecode);
internalAlgStruct.decompCPB = 1;
internalAlgStruct.decompDMS = 8192;
internalAlgStruct.decompSMS = 0;
internalAlgStruct.decompVer = 0x01;
internalAlgStruct.pfnCompressionFunc = \
SigCompAlgNullCompress;
memcpy(pAlgStruct, &internalAlgStruct, algStructSize);
//将空压缩算法加入到算法对象列表中
RvSigCompAlgorithmAdd(hSigCompMgr, &sigCompAlg);
//查找是否已经存在
SigCompAlgorithmFind (pSigCompMgr,\
pAlgorithm->algorithmName, &phAlgorithm);
//如果已经存在则返回
if (phAlgorithm != NULL)
return (RV_OK);
//构造压缩状态
SigCompStateHandlerCreateState (\
&pSigCompMgr->stateHandlerMgr,\
pAlgorithm->decompBytecodeSize, &pState);
//查找状态内存管理已经没有可用的分配内存，则返回错误
freeElements = RA_NumOfFreeElements(pSHMgr->statesRA);
if (freeElements == 0)
return(RV_ERROR_OUTOFRESOURCES);
raPool = pSHMgr->smallBufRA;
bufSize = pSHMgr->smallBufSize;
//为状态对象分配一块内存
RA_Alloc(pSHMgr->statesRA, (RA_Element *)&pState);
//为状态对象数据分配一块内存
RA_Alloc(raPool,(RA_Element *)&pDataBuffer);
//状态对象初始化
pState->dataBufRA = raPool;
pState->statesRA = pSHMgr->statesRA;
pState->stateBufSize = bufSize;
pState->stateDataSize = (RvUint16) requestedSize;
pState->pData = pDataBuffer;
pState->retentionPriority = 0;
pState->isUsed = 0;
pState->stateAddress = 0;
pState->stateInstruction = 0;
pState->minimumAccessLength = 6;
//返回构造的状态对象
*ppState = pState;
//设置状态对象的优先级成员
SigCompStateHandlerStateSetPriority (\
&(pSigCompMgr->stateHandlerMgr), \
(RV_UINT16_MAX), pState);
pState->retentionPriority = (priority & RV_UINT16_MAX);
//将解压缩字节码复制到状态对象的数据成员中
SigCompStateHandlerStateWriteData (\
&pSigCompMgr->stateHandlerMgr,\
pState, 0, pAlgorithm->decompBytecodeSize,\
pAlgorithm->pDecompBytecode);
startPosition = pState->pData + startLocation;
memcpy(startPosition, pData, dataLength);
//构造SHA1状态ID到 pState->stateID
SigCompStateHandlerStateSetID(\
&pSigCompMgr->stateHandlerMgr, pState);
//将状态对象插入到pSHMgr->hHashTable表中，其中哈希表的
//KEY为pState->stated，哈希值为pState状态对象
SigCompStateHandlerSaveState(&pSigCompMgr->stateHandlerMgr,
NULL, NULL, &pState);
//将空算法对象插入到算法对象列表的尾部
RLIST_InsertTail(pSigCompMgr->hAlgorithmListPool,\
pSigCompMgr->hAlgorithmList, &hElement);
memcpy ((void *)hElement, (void *)pAlgorithm, \
sizeof (RvSigCompAlgorithm));
//调用算法初始化完成回调，这里为NULL
SigCompCallbackAlgorithmInitializedEv(pSigCompMgr,pAlgorithm);
//信令压缩字典构造
AppInitSigCompDictionary(hSigCompMgr);
//静态字典变量初始化
SigCompStaticDictionary3485Init(hSigCompMgr, sizeof(staticDictStruct),\
&staticDictStruct);
internalDictStruct.minimalAccessLength = 6;
internalDictStruct.dictionarySize = 0x12E4;
internalDictStruct.dictionary = staticDictionaryRFC3485Value;
memcpy(pDictStruct, &internalDictStruct, dictStructSize);
//将字典对象插入到字典列表中
RvSigCompDictionaryAdd(hSigCompMgr, &staticDictStruct);
//为字典对象构造一个状态对象
SigCompStateHandlerCreateStateForDictionary(\
&(pSigCompMgr->stateHandlerMgr),\
pDictionary->dictionarySize, &pState);
//分配内存
RA_Alloc(pSHMgr->statesRA,(RA_Element *)&pState);
//参数初始化
pState->dataBufRA = NULL;
pState->statesRA = pSHMgr->statesRA;
pState->stateBufSize = requestedSize;
pState->stateDataSize = (RvUint16) requestedSize;
pState->pData = NULL;
pState->retentionPriority = 0;
pState->isUsed = 0;
pState->stateAddress = 0;
pState->stateInstruction = 0;
pState->minimumAccessLength = 6;
*ppState = pState; //返回状态对象
//设置状态对象的数据为字典值
pState->pData = pDictionary->dictionary;
//设置状态对象的优先级
SigCompStateHandlerStateSetPriority(\
&(pSigCompMgr->stateHandlerMgr), (RV_UINT16_MAX),\
pState);
//设置状态ID
SigCompStateHandlerStateSetID(\
&pSigCompMgr->stateHandlerMgr, pState);
//将状态对象插入到pSHMgr->hHashTable表中，其中哈希表的
//KEY为pState->stateID，哈希值为pState状态对象
SigCompStateHandlerSaveState(、
&pSigCompMgr->stateHandlerMgr, NULL, NULL, &pState);
//将字典对象插入到字典列表中
RLIST_InsertTail (pSigCompMgr->hDictionaryListPool,\
pSigCompMgr->hDictionaryList, &hElement);
memcpy ((RvUint8 *)hElement, (RvUint8 *)pDictionary, \
sizeof (RvSigCompDictionary));
//不清楚
pSigCompMgr->localIdList[pSigCompMgr->localIdListUsedLength] =
(RvUint8)pDictionary->minimalAccessLength;
pSigCompMgr->localIdListUsedLength++;
memcpy(&(pSigCompMgr->localIdList[pSigCompMgr->localIdListUsedLength]), (pState->stateID), pDictionary->minimalAccessLength);
pSigCompMgr->localIdListUsedLength += \
pDictionary->minimalAccessLength;
//设置信令压缩对象相关句柄
RvSipStackSetSigCompMgrHandle(ssmu_mcb.rv_ctrl.stack_handle,\
hSigCompMgr);
// pStackMgr->hCompartmentMgr = hSigCompMgr
SipCompartmentMgrSetSigCompMgrHandle(\
pStackMgr->hCompartmentMgr,hSigCompMgr);
// pStackMgr->hTransport ->hSigCompMgr = hSigCompMgr
SipTransportMgrSetSigCompMgrHandle(pStackMgr->hTransport,\
hSigCompMgr);
pStackMgr->hSigCompMgr = hSigCompMgr;
//初始化IMS 用户元素
for (tcid=0; tcid<GG_MAX_TCIDS; tcid++)
ImsUEInit(tcid);
//构造用户内存池
ssmu_mcb.tcid[tcid].g_appPool =
RPOOL_Construct(1024,10,ssmu_mcb.rv_ctrl.log_handle,
RV_FALSE,"ApplicationPool");
//复位
ssmu_mcb.tcid[tcid].g_ImsUE.g_clientExpires = UNDEFINED;
ssmu_mcb.tcid[tcid].g_ImsUE.g_portS = UNDEFINED;
//如果开始了信令压缩功能，则设置默认的压缩类型
if (ssmu_mcb.config.sipcomp_enable)
ssmu_mcb.tcid[tcid].g_ImsUE.g_eCompType= RVSIP_COMP_SIGCOMP;
//复位ROUTE列表，该ROUTE列表用于IMS时的路由记录
AppResetRouteHopHeaderList(tcid);
//设置TOS服务
ssmu_rv_init_tos (p_rv);
//设置本地UDP接口的TOS
ssmup_set_tos_for_lcl_addr( p_rv->transport_mgr, ssmu_mcb.config.sig_tos, \
RVSIP_TRANSPORT_UDP);
//获取本地接口的第一个地址
RvSipTransportMgrLocalAddressGetFirst(hTransportMgr, eTransportType,
&hLocalAddr);
TransportMgrLocalAddressGetFirst(hTransportMgr,eTransportType,\
phLocalAddr);
//本地UDP类型的地址列表
hLocalAddrList = pTransportMgr->hLocalUdpAddrList;
TransportMgrLocalAddrListLock(pTransportMgr);
//获取列表中第一个地址成员
RLIST_GetHead(pTransportMgr->hLocalAddrPool, hLocalAddrList,
(RLIST_ITEM_HANDLE*)phLocalAddr);
TransportMgrLocalAddrListUnlock(pTransportMgr);
while (NULL != hLocalAddr) //遍历当前UDP本地列表中所有地址
//设置当前地址的TOS值
RvSipTransportMgrLocalAddressSetIpTosSockOption(hLocalAddr,nw_tos);
TransportMgrLocalAddressSetTypeOfService(pTransportMgr,
hLocalAddr,typeOfService);
TransportMgrLocalAddrLock(pLocalAddr);
//设置当前本地SOCKET的TOS
RvSocketSetTypeOfService(&pLocalAddr->ccSocket,typeOfService,\
pTransportMgr->pLogMgr);
//获取SOCKET类型，这里假设是IPv4
RvSocketGetAddressType(sock, logMgr, &addrType);
RvSocketSetToS4(sock, typeOfService, logMgr);
//设置本地套接口选项
RvSocketSetSockOpt(sock, IPPROTO_IP, IP_TOS, \
(char *)&tos, sizeof(tos))
TransportMgrLocalAddrUnlock(pLocalAddr);
//获取地址列表的下一个地址
RvSipTransportMgrLocalAddressGetNext(hLocalAddr, &hLocalAddr);
TransportMgrLocalAddressGetNext(hBaseLocalAddr,phLocalAddr);
hLocalAddrList = pTransportMgr->hLocalUdpAddrList;
RLIST_GetNext(pTransportMgr->hLocalAddrPool, hLocalAddrList,
(RLIST_ITEM_HANDLE)pBaseLocalAddr,
(RLIST_ITEM_HANDLE*)phLocalAddr);
//设置本地TCP接口的TOS，同上面的UDP类似，就不描述了
ssmup_set_tos_for_lcl_addr( p_rv->transport_mgr, ssmu_mcb.config.sig_tos, \
RVSIP_TRANSPORT_TCP);
--------------------------------------------------------------------------------------------------------------------------
RvTimestampInit //时间戳模块初始化
RvAdTimestampInit();
//获取系统当前时间并设置到全局变量 RvStartingTime 中
struct timespec tp;
clock_gettime(CLOCK_REALTIME, &tp);
RvStartingTime = tp.tv_sec;
--------------------------------------------------------------------------------------------------------------------------
RvSemaphoreInit //系统量模块初始化
//无
--------------------------------------------------------------------------------------------------------------------------
RvMutexInit //互斥量模块初始化
//无
--------------------------------------------------------------------------------------------------------------------------
RvLockInit //锁模块初始化
//无
--------------------------------------------------------------------------------------------------------------------------
Rv64AsciiInit //64位字符模块初始化
//无
--------------------------------------------------------------------------------------------------------------------------
RvTmInit //时间模块初始化
//无
--------------------------------------------------------------------------------------------------------------------------
RvClockInit //时钟模块初始化
RvAdClockInit(); //空
--------------------------------------------------------------------------------------------------------------------------
RvMemoryInit //内存模块初始化
rvActualNumDrivers = 1; //默认内存驱动对象数量为1
//设置内存驱动对象默认的出错错误码，这里错误码宏RvMemoryErrorCode是一个
//位组合变量，包含前20位是RV_ERROR_LIBCODE_CCORE，前10位是
// RV_CCORE_MODULE_MEMORY，最后位是错误码RV_ERROR_UNKNOWN
RvDriverStatus[0] = RvMemoryErrorCode(RV_ERROR_UNKNOWN);
//构造用户锁，这里锁机制是用的系统的线程互斥量
RvLockConstruct(NULL, &RvUserDefaultLock);
//构造内存锁
RvLockConstruct(NULL, &RvMemoryLock);
//对象列表构造
RvObjListConstruct(&RvDefaultRegion, &RvDefaultRegion.listElem, &RvRegionList);
//计算RvDefaultRegion.listElem成员在RvDefaultRegion结构中的偏移量
objlist->offset = (RvInt8 *)elementptr - (RvInt8 *)itemtemp;
RvObjListReset(objlist); //列表复位
//内存设备初始化，当前初始化函数为空
RvMemoryDrivers[0].init();
//内存模块构造
RvMemoryConstruct(RV_MEMORY_DRIVER_OSMEM, (RvChar*)"Default", NULL, 0, NULL,
RvMemoryDefaultMemCB, NULL,NULL, &RvDefaultRegion);
region->drivernum = drivernum; //驱动号为0，表示使用系统内存
//设置默认系统内存的一组内存驱动回调函数
// init = RvOsMemInit (空函数)
// end = RvOsMemEnd （空函数）
// construct = RvOsMemConstruct （主要在内存构造时用记录一些信息）
// destruct = RvOsMemDestruct （信息复位）
// alloc = RvOsMemAlloc （这里就是调用的系统的malloc，及信息记录）
// free = RvOsMemFree （使用系统的free，及信息记录）
// info = RvOsMemGetInfo (信息记录)
region->drivercalls = &RvMemoryDrivers[drivernum];
region->start = start; //NULL
region->size = size; //0
region->moremem = moremem; //NULL
region->nomem = nomem; // RvMemoryDefaultMemCB
region->driverRegion = NULL;
strncpy(region->name, name, RV_MEMORY_MAX_NAMESIZE);
region->driverRegion = (void *)®ion->driverData.osMemData;
//这里构造内存数据区，感觉没什么用，因为分配大小都是0
region->drivercalls->construct(region->start, region->size,
RV_MEMORY_ALLOC_OVERHEAD, region->moremem, attr, region->driverRegion);
//将当前这个内存寄存器加入到内存寄存器列表中
RvLockGet(&RvMemoryLock,logMgr);
RvObjListInsertBefore(&RvRegionList, NULL, region);
RvLockRelease(&RvMemoryLock,logMgr);
//这段代码不会执行，当前只支持的内存驱动只有系统内存
for (; RvMemoryDrivers[rvActualNumDrivers].init != NULL; ++rvActualNumDrivers)
RvDriverStatus[rvActualNumDrivers] =
RvMemoryDrivers[rvActualNumDrivers].init();
--------------------------------------------------------------------------------------------------------------------------
RvThreadInit 线程控制块初始化
RvLockConstruct(NULL, &RvThreadLock); //构造锁
//线程变量初始化
for(i = 0; i < RV_THREAD_MAX_VARS; i++)
RvThreadVars[i].active = RV_FALSE;
RvThreadVars[i].name[0] = '\0';
//线程模块初始化
RvAdThreadInit();
// 校验只能执行一次
if(!threadKeyAllocated)
//构造线程私有变量，及线程退出清理回调
pthread_key_create(&RvThreadCurrentKey, RvThreadExitted)
threadKeyAllocated = RV_TRUE;
--------------------------------------------------------------------------------------------------------------------------
RvLogListenerInit //日志接收模块初始化（就是日志的输出对象）
//空
--------------------------------------------------------------------------------------------------------------------------
RvLogInit //日志模块初始化
//空
--------------------------------------------------------------------------------------------------------------------------
RvIpsecInit //IMS IPSEC安全验证
rvAdIpsecInit();
RvLockConstruct(NULL,&gsLinuxSPI_ID_Lock); //锁构造
bzero(gsLinuxSPI_ID_Arr,sizeof(gsLinuxSPI_ID_Arr)); //复位控制块
--------------------------------------------------------------------------------------------------------------------------
RvHostInit //本地主机模块初始化
//获取操作系统的主机名
RvHostFindLocalName(sizeof(rvHostLocalName), rvHostLocalName);
gethostname(name, (int)nameLength);
--------------------------------------------------------------------------------------------------------------------------
RvAresInit //DNS模块初始化
//创建一个线程变量
RvThreadCreateVar(0, "RvAresStatus", 0, &gsStatusTLS);
ares_init(); //对于LINUX系统类型时，该函数为空
RvAresCacheDInit();
gsStartTime = RvTimestampGet(0); //获取当前时间
RvLockConstruct(0, &gsGlobalInstanceLock); //锁构建
--------------------------------------------------------------------------------------------------------------------------
RvStdioInit //标准IO模块初始化
//空
--------------------------------------------------------------------------------------------------------------------------
RvQueueInit //消息队列模块初始化
//空
--------------------------------------------------------------------------------------------------------------------------
RvTimerInit //定时器模块初始化
//创建线程一个变量
RvThreadCreateVar(RvTimerDestructSleepChannelTLS, "TimerSleepCannel", 0, &gsSleepChannelTLSIndex);
--------------------------------------------------------------------------------------------------------------------------
RvTimerEngineInit //定时器引擎初始化
//空
1622
06-13
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
