框架初始化流程

RvBool mgStartup()
mgLogInit();
	logMgr = rvMegacoLogGet();	//获取日志句柄
//设置所有源日志句柄的掩码
RvLogSetGlobalMask(logMgr, RV_LOGLEVEL_ERROR | RV_LOGLEVEL_EXCEP | RV_LOGLEVEL_WARNING | RV_LOGLEVEL_INFO);
RvLogRegisterListener(logMgr, mgLogListener, NULL);	//设置输出回调

rvMegacoStackConstruct(&mgcb.stack, numThreads, RV_PRIORITY_MAX)
//添加日志源
RvLogSourceConstruct(rvMegacoLogGet(), &stack->logSource, "MEGACO", "MEGACO Stack");
RvLogSourceConstruct(rvMegacoLogGet(), &stack->tcbLogSource, "TCB", "Transport Control Box");

rvCacheAllocTlsInit();
	//创建一个任务变量，ID存入rvAllocCacheTlsIndex
RvThreadCreateVar(rvCacheAllocTlsVarDestructor, RV_TLSSUBALLOC_VARNAME, rvMegacoLogGet(), &rvAllocCacheTlsIndex);

	//设置回调结构
	stack->genAlloc = &rvAllocCacheTlsAlloc;
	stack->sendBufAlloc = &rvAllocCacheTlsAlloc;
	stack->entityAlloc = &rvAllocCacheTlsAlloc;
	stack->tcbAlloc = &rvAllocCacheTlsAlloc;
	stack->msgAlloc = &rvAllocCacheTlsAlloc;

	//构造一个内存池
	rvPoolConstruct(&stack->recvBufPool, RV_MEGACOSTACK_RECVBUFSIZE);
	rvPoolConstruct宏为
	rvPoolConstructEx1((p), (s), rvPoolPageSize(s), NULL, NULL, NULL, &rvDefaultAlloc)
		RvMutexConstruct(rvMegacoLogGet(), &p->mutex);	//给内存池构造互斥
		p->blockSize = blockSize;	// = RV_MEGACOSTACK_RECVBUFSIZE
		p->realBlockSize = rvPoolCalcBlockSize(blockSize);	//真实池大小，加了块头
		p->constructor = constructor;	// NULL
		p->destructor = destructor;	//NULL
		p->data = data;	//NULL
		p->alloc = alloc;	// = rvDefaultAlloc
		p->pageSize = pageSize;
p->blocksPerPage = (p->pageSize - RV_POOL_ALLOCBLOCKSIZE - sizeof(RvPage)) / p->realBlockSize;
		p->blocks = NULL;
		p->pages = NULL;
		p->numOfBlocks = 0;
		p->numOfAllocBlocks = 0;
//构造一个sendBufAllocDefault，并赋给sendBufAlloc
stack->sendBufAlloc = rvAllocConstruct(&stack->sendBufAllocDefault, &stack->sendBufPool, ~0U, poolAlloc, poolDealloc);
	a->pool = pool;
	a->maxSize = maxSize;
	a->alloc = alloc;
	a->dealloc = dealloc;

priority = maxStackPriority;	// = 1

RvSdpStackCfg		sdpCfg;
sdpCfg.disableSdpLogs = RV_FALSE;
sdpCfg.logContext = NULL;
sdpCfg.logManagerPtr = rvMegacoLogGet();
sdpCfg.pfnPrintLogEntryEvHandler = NULL;

RvSdpMgrConstructWithConfig(&sdpCfg, sizeof(sdpCfg));
	//构造__globals__->_ g_sdpGlobal
RvMemoryAlloc(NULL, sizeof(sdpGlobl), NULL, (void**)& __globals__->_ g_sdpGlobal)
		region = &__globals__->_RvDefaultRegion;
realsize = size + RV_MEMORY_ALLOC_OVERHEAD;
		region->drivercalls->alloc(region->driverRegion, realsize, resultptr);	//分配内存
		allochead = (RvMemoryAllocHead *)*resultptr;	//指向分配的内存
//分配的内存偏移出分配头，给用户实际使用地址 
*resultptr = (void *)((RvInt8 *)*resultptr + RV_MEMORY_ALLOC_HEAD_OVERHEAD);
allochead->region = region;//内存头赋值
//如果_DEBUG宏打开，则在allochead->中填写其它信息
		
		memset(__globals__->_ g_sdpGlobal, 0, sizeof(sdpGlobl));

		__globals__->_g_sdpGlobal->pLogMgr = (RvLogMgr*)pStackConfig->logManagerPtr;
		__globals__->_g_sdpGlobal->bLogMgrSuppliedByApp = RV_TRUE;

		//向megaco日志管理中加入sdp日志源
RvLogSourceConstruct(__globals__->_g_sdpGlobal->pLogMgr, &__globals__->_g_sdpGlobal->logSource, "SDP", "SDP module");

		__globals__->_pSdpLogSource = &g_sdpGlobal->logSource;

		//打印CommonCore信息
		RvLogSourcePrintInterfacesData(pSdpLogSource, RvCCoreInterfaces());

		rvSdpAllocInitialize();
			sdpRvAllocInitialize();
				gTotalMem = 0;
				gMaxUsedMem = 0;
				gTotalCnt = 0;
				RvMutexConstruct(NULL,&gMutex);

		//后面都是判断sdp相关功能宏是否开启，如果开启则打印信息

rvMegacoTransportConstruct(&stack->transport, rvMegacoStackProcessPackets, numThreads, priority, stack->genAlloc, stack->recvBufAlloc);
	x->running = RV_FALSE;
x->numThreads = numThreads;	// 1
	x->threads = (RvThread *)rvAllocAllocate(genAlloc, numThreads * sizeof(RvThread));
	x->processPacket = pRecvPacketCb;	//设置接收包处理回调函数
	x->onSocketDelete = NULL;
	x->genAlloc = genAlloc;
	x->recvBufAlloc = recvBufAlloc;

	for(i=0; i<numThreads; ++i)
		RvChar threadName[32];
		RvSprintf(threadName, "Trans.%d", i);

		//创建一个线程对象，线程函数为rvMegacoTransportProcessPacketQueue
RvThreadConstruct(rvMegacoTransportProcessPacketQueue, x, rvMegacoLogGet(), &x->threads[i]);
RvThreadSetStack(&x->threads[i], NULL, RV_STACKSIZE_TRANSPORT);//栈大小
RvThreadSetName(&x->threads[i], threadName);//线程名字
RvThreadSetPriority(&x->threads[i], priority);//优先级
RvThreadCreate(&x->threads[i]);	//填充线程相关属性值，但不运行

x->socketEngine = rvAllocAllocate(genAlloc, sizeof(RvMegacoSocketEngine));//分配内存
rvMegacoSocketEngineConstruct((RvMegacoSocketEngine *)x->socketEngine, priority);
	logMgr = rvMegacoLogGet();
	se->selectEngine = NULL;
	se->active = RV_FALSE;
	
	RvMutexConstruct(logMgr, &se->lock);
	RvSemaphoreConstruct(0, logMgr, &se->sema);

	//构造SOCKET处理线程，线程程序为rvMegacoSocketEngineThread
	RvThreadConstruct(rvMegacoSocketEngineThread, se, logMgr, &se->thread);
	RvThreadSetStack(&se->thread, NULL, RV_STACKSIZE_SOCKETENGINE);
	RvThreadSetName(&se->thread, "SockEng");
	RvThreadSetPriority(&se->thread, priority);
	RvThreadCreate(&se->thread);

	RvThreadStart(&se->thread);	//启动SOCKET处理线程
	
	//这里等待rvMegacoSocketEngineThread线程给select engine赋值 
	RvSemaphoreWait(&se->sema, logMgr);

//设置当SOCKET被删除时的回调
rvMegacoTransportRegisterSocketDeleteCb(&stack->transport, rvMegacoEntityOnSocketDelete);
	x->onSocketDelete = socketDeleteCb;

rvMegacoTimerMgrConstruct(&stack->timerMgr, 512, rvMegacoLogGet());
	timerMgr->logMgr = logMgr;
	RvLogSourceConstruct(logMgr, &timerMgr->logSource, "TIMERMGR", 
	"TimerMgr");

	RvTimerQueueConstruct(RV_TIMER_QTYPE_DYNAMIC, maxTimers, 0, 0, 0, 32, NULL, NULL, logMgr, &timerMgr->timerQ);
		tqueue->logMgr = logMgr;
		tqueue->timerSource = &logMgr->timerSource;
		RvLockConstruct(logMgr, &tqueue->lock);
		RvSemaphoreConstruct(0,logMgr, &tqueue->wait);
		
		pooltype = RV_OBJPOOL_TYPE_DYNAMIC;
		pqueuetype = RV_PQUEUE_TYPE_DYNAMIC;
		salvage = RV_OBJPOOL_SALVAGE_ALLOWED;

		poolcallbacks.objconstruct = RvTimerEventConstruct;
		poolcallbacks.objdestruct = RvTimerEventDestruct;
		poolcallbacks.pagealloc = RvTimerMemAlloc;
		poolcallbacks.pagefree = RvTimerMemFree;
		poolcallbacks.objconstructdata = tqueue;
		poolcallbacks.objdestructdata = NULL;
		poolcallbacks.pageallocdata = memregion;	//NULL
		poolcallbacks.pagefreedata = memregion;	//NULL

	RvObjPoolConstruct(&timerevent, &timerevent.element, &poolcallbacks, sizeof(RvTimerEvent), pagetimers, 0, pooltype, salvage, maxtimers, mintimers, freelevel, &tqueue->pool)
		objpool->autoexpand = RV_TRUE;
		objpool->autoreduct = RV_TRUE;
		objpool->maxitems = maxitems;
		objpool->allowsalvage = salvage;
		objpool->reductlevel = freelevel;
			objpool->itemsize = itemsize;
	objpool->blocksize = itemsize + RV_ALIGN_SIZE - 1 - ((itemsize - 1) % RV_ALIGN_SIZE);
			objpool->blocksize += RV_OBJPOOL_ITEM_OVERHEAD;
			objpool->pageitems = pageitems;
	objpool->pagesize = (pageitems * objpool->blocksize) + RV_OBJPOOL_PAGE_OVERHEAD;
			memcpy(&objpool->callbacks, callbacks, sizeof(*callbacks));
			RvObjListConstruct(itemtemp, elementptr, &objpool->freelist)
			RvObjListConstruct(&poolpage, &poolpage.pagelistelem, &objpool->pagelist)

		numtimers = starttimers - RvObjPoolTotalItems(&tqueue->pool);
		RvObjPoolAddItems(&tqueue->pool, numtimers) ;
			numpages = ((numitems - 1) / objpool->pageitems) + 1;
			RvObjPoolAddPages(objpool, numpages);	//没细看

		startevents = RvObjPoolTotalItems(&tqueue->pool);
		pqueuecallbacks.memalloc = RvTimerMemAlloc;
		pqueuecallbacks.memfree = RvTimerMemFree;
		pqueuecallbacks.itemcmp = RvTimerPQueueItemCmp;
		pqueuecallbacks.newindex = RvTimerPQueueNewIndex;
		pqueuecallbacks.memallocdata = memregion;
		pqueuecallbacks.memfreedata = memregion;
		
		RvPQueueConstruct(pqueuetype, startevents, &pqueuecallbacks, &tqueue->pqueue)	//构造一个空的优先级队列
		
		tqueue->callcount = 0;
		tqueue->qState = RV_TIMERQUEUE_ENABLED;
		tqueue->selEng = selEng;	//NULL

	//创建一个定时器线程
	RvTimerEngineConstruct(&timerMgr->timerEng, &timerMgr->timerQ, RV_TIME64_NSECPERMSEC * RvInt64Const(1,0,100));
		tengine->period = period;
		tengine->tqueue = tqueue;
		tengine->stopped = RV_FALSE;
		tengine->paused = RV_FALSE;
		RvThreadConstruct(RvTimerEngineThread, tengine, NULL, &tengine->thread);
	
//设置线程对象属性
RvTimerEngineSetOptions(&timerMgr->timerEng, "TimerEng", NULL, RV_STACKSIZE_TIMERMGR, RV_THREAD_PRIORITY_DEFAULT, NULL);
		
		RvTimerEngineStart(&timerMgr->timerEng);	//运行线程

stack->defaultTos = 0;
stack->encodeCompact = RV_TRUE;
stack->getKey = NULL;
stack->authenticate = NULL;
stack->rawRecvCb = stack->rawSendCb = NULL;
stack->parseErrorCb = NULL;
stack->priority = priority;

//发送延时
stack->sendDelay = rvMegacoStackGetSendDelayDefault(stack);	// 50

//重传超时范围
rvMegacoRetransTimeoutLimitsConstruct (&stack->timeoutLimits, (RvInt64)rvMegacoStackGetInitialRetransTimeoutDefault(stack) * RV_TIME64_NSECPERMSEC, (RvInt64)rvMegacoStackGetMinRetransTimeoutDefault(stack) * RV_TIME64_NSECPERMSEC, (RvInt64)rvMegacoStackGetMaxRetransTimeoutDefault(stack) * RV_TIME64_NSECPERMSEC);
	limits->initial = initial;	//2000 * 1000000
	limits->min = min;		// 100 * 1000000
	limits->max = max;		// 4000 * 1000000

stack->tMax = (RvInt64)rvMegacoStackGetRetransWindowDefault(stack) * RV_TIME64_NSECPERMSEC;	//25000 * 1000000
// 30000 * 1000000
stack->tHist = rvMegacoStackGetTransactionHistoryTimerDefault(stack);
stack->maxPacketSize = RV_MEGACOSTACK_MAXPACKET_DEFAULT;	//1400

//复位统计信息
rvMegacoStackStatisticsConstruct(&stack->statistics);

RvMutexConstruct(rvMegacoLogGet(), &stack->statsLock);//构建锁

//添一个二进制的物理ID root，不是太明白
rvMegacoBinaryTermIdConverterConstruct(&stack->idCvtr, stack->genAlloc);
	_RvVectorRvVoidPtrConstruct(&x->patterns, alloc);
	x->alloc = alloc;
	rvMegacoBinaryTermIdConverterAddPattern(x, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 64, "root");
	RvMegacoBinaryTermIdPattern *p = (RvMegacoBinaryTermIdPattern *)rvAllocAllocate(x->alloc, sizeof(RvMegacoBinaryTermIdPattern));
	rvMegacoBinaryTermIdPatternConstruct(p, (const unsigned char *)prefix, numPrefixBits, pattern, x->alloc);
	rvPtrVectorPushBack(&x->patterns, p);

//构造二进制的， *包，及*事件，不是太明白
rvMegacoPackageDbConstruct(&stack->itemCvtr, stack->genAlloc);
	rvMegacoPackageDbNodeConstruct(db, 0, "", RV_MEGACOPARAMETERTYPE_NOT_APPLICABLE, alloc);

//创建TCB更新线程
stack->done = RV_FALSE;
RvThreadConstruct(rvMegacoStackProcessTcbUpdates, stack, rvMegacoLogGet(), &stack->tcbUpdateThread);
RvThreadSetName(&stack->tcbUpdateThread, "TCB Upd");
RvThreadSetPriority(&stack->tcbUpdateThread, priority);
RvThreadSetStack(&stack->tcbUpdateThread, NULL, RV_STACKSIZE_SOCKETENGINE);
RvThreadCreate(&stack->tcbUpdateThread);

RvSemaphoreConstruct(0, rvMegacoLogGet(), &stack->tcbUpdateSem);
RvMutexConstruct(rvMegacoLogGet(), &stack->tcbListLock);
rvPtrVectorConstruct(&stack->goodTcbs, stack->genAlloc);
rvPtrVectorConstruct(&stack->badTcbs, stack->genAlloc);

//开启rvMegacoStackProcessTcbUpdates线程
RvThreadStart(&stack->tcbUpdateThread);

// mgcb.stack. sendDelay = 0
rvMegacoStackSetSendDelay(&mgcb.stack, rvMegacoStackGetSendDelayMin(&mgcb.stack));

//根据用户配置设置mgcb.stack. encodeCompact是否启用（消息格式：长或短）
rvMegacoStackSetCompactEncodingMode(&mgcb.stack, mgcb.cfg.isMessageCompact);

//如果用户配置了支持二进制编码包，则增加对应物理ID，注册基本包，这里先不看，先看文本方式的
if (mgcb.cfg.encodingType == RV_MEGACOENCODING_BINARY)
	rvMegacoStackAddBinaryTermIdPattern(&mgcb.stack, "\x00", 1, "aaln/%30");
	rvMegacoStackAddBinaryTermIdPattern(&mgcb.stack, "\x40", 2, "rv/%14/%16");
	rvMegacoStackAddBinaryTermIdPattern(&mgcb.stack, "\x80", 1, "rtp/%31");
	rvMegacoStackRegisterBinaryBasicPackages(&mgcb.stack);

if (mgcb.cfg.midFormat == MID_MG_MAC)	//如果用户配置了MAC为消息ID
	//这里mgGetMidFormat()判断，如果mgcb.cfg.midFormat为域名或ＭＡＣ，则返回mgcb.cfg.mgName，否则返回mgcb.cfg.mgAddr
	rvMegacoEntityAddressConstruct(&mgAddr, mgGetMidFormat(), 0);
		rvMegacoEntityAddressConstructA((x), (dnsOrIp), (port), &rvDefaultAlloc)
		rvStringConstruct(&x->address, dnsOrIp, alloc);	//复制IP字符串
		x->port = port;	//设置端口
		//根据dsnOrip字符判断并调协x->type =为IP或DNS，这里代码省略
Else
	rvMegacoEntityAddressConstruct(&mgAddr, mgGetMidFormat(), mgcb.cfg.mgPort);

rvMegacoEntityConstructLocalEx(&mgcb.mainEntity, &mgAddr, RV_TRUE, RV_MEGACOENTITYTYPE_MG, mgcb.cfg.transportType, mgcb.cfg.encodingType, &mgcb.stack, mgcb.cfg.mgAddr, mgcb.cfg.mgPort)
	rvMegacoAddressConstructByName(&entity->socketAddr, ip, port)
		RvAddressConstruct(RV_ADDRESS_TYPE_IPV4, thisPtr);
			addr->addrtype = addrtype;
			//构建一个空地址
			RvAddressIpv4Construct(&addr->data.ipv4, RV_ADDRESS_IPV4_ANYADDRESS, RV_ADDRESS_IPV4_ANYPORT)
			RvAddressSetString(dnsOrIp, thisPtr);	//设置地址
			RvAddressSetIpPort(thisPtr, port);	//设置端口

	//初始化mgcb.mainEntity
	rvMegacoEntityConstructCommon(entity, mid, primary, entityType, transportType, encoding, stack);
		RvMutexConstruct(rvMegacoLogGet(), &entity->mutex);
		rvMegacoEntityAddressConstructCopy(&entity->mId, address, stack->entityAlloc);
		entity->entityType = entityType;
		entity->transportType = transportType;
		entity->encoding = encoding;
		entity->stack = stack;
		entity->primary = primary;
		entity->socket = RV_INVALID_SOCKET;
		entity->tos = stack->defaultTos;
		//这个hashConstruct函数没源码
		rvHashConstruct(RvMegacoTransactionId, RvMegacoTcbPtr)( &entity->tcbs, RV_MEGACOENTITY_TCBBUCKETS, hashTransactionId, stack->entityAlloc, stack->genAlloc);
		entity->tcbCount = 0;
		RvMutexConstruct(rvMegacoLogGet(), &entity->tcbLock);
		RvSemaphoreConstruct(1, rvMegacoLogGet(), &entity->tcbSem);

	entity->version = rvMegacoVersion;	//2
	entity->isLocal = RV_TRUE;
	//没源码
	rvHashConstruct(RvMegacoEntityAddress, RvMegacoEntityPtr)(&entity->u.local.remotes, RV_MEGACOENTITY_REMOTEBUCKETS, hashEntityAddress, stack->entityAlloc, stack->genAlloc);

entity->u.local.nextTransactionId = 1;
entity->u.local.processRequest = NULL;
entity->u.local.processError = NULL;
//获取随机数
RvRandomGeneratorConstruct(&entity->u.local.randomGenerator, rvMegacoEntityGetRandomSeed(entity));

switch(transportType)
case RV_TRANSPORTTYPE_UDP:
	rvSock = rvMegacoTransportAddUdpSocketEx(&stack->transport, &entity->socketAddr, entity);
		//这里仅使用系统socket函数创建一个socket句柄
		RvSocketConstruct(RvAddressGetType(localAddr), RvSocketProtocolUdp, logMgr, &rvSock);
			RvSocketConstructHere(sock, addressType, protocolType, logMgr);
		//绑定端口及IP
		RvSocketBind(&rvSock, localAddr, NULL, logMgr);
		
		//构造socketData
		socketData = (RvMegacoSocketData *)rvAllocAllocate(x->genAlloc, sizeof(RvMegacoSocketData));
	
		//填充socketData
		rvMegacoSocketDataConstruct(socketData, x, &rvSock, userData);
			x->transport = transport;	//将stack->transport保存
			//socket转换为文件句柄存入stack->transport.fd中
			RvFdConstruct(&x->fd, s, rvMegacoLogGet());
			x->userData = userData ；//将mgcb.mainEntity保存
			RvMutexConstruct(rvMegacoLogGet(), &x->mutex);
			x->packetsQueued = 0;
			x->removed = RV_FALSE;
			RvSemaphoreConstruct(1, rvMegacoLogGet(), &x->unregisterSem);

		//将创建的socket转化为文件描述符存入socketData->fd
		RvFdConstruct(&socketData->fd, &rvSock, logMgr);

		RvSelectAdd(SEL_ENG(x), &socketData->fd, RV_SELECT_READ, rvMegacoTransportRecvFromUdp);
			fdBucketHashAdd(selectEngine, fd);	//将socket文件句柄放入hash表
			allocatedBucketHash = RV_TRUE;

			if (fd->fd > (RvSocket)selectEngine->maxFdInSelect)
				selectEngine->maxFdInSelect = fd->fd;

			//= RV_SELECT_READ
			translatedEvents = (RvSelectEvents)rvSelectToOS(selectEvents);

			RV_FD_SET(fd->fd, &selectEngine->rdSet);
			
	//设置当这个句柄触发时的回调函数，该回调函数为rvMegacoTransportRecvFromUdp
			fd->callback = eventsCb;	
			fd->events = selectEvents;

			rvFdPreempt(selectEngine, RvSelectEmptyPreemptMsg);
				//message = 0
				write(selectEngine->preemptionPipeFd[1], &message, sizeof(RvUint8)

rvMegacoEntityAddressDestruct(&mgAddr);

if ( mgcb.cfg.bareMgcAddr1 != NULL)	//如果配置了主MGC的IP
	rvMegacoEntityAddressConstruct(&mgc1Addr, mgcb.cfg.bareMgcAddr1, 0)

	rvMdmTermMgrConstruct(&mgcb.termMgr, &mgcb.mainEntity, &mgc1Addr, mgcb.cfg.bareMgcAddr1, mgcb.cfg.mgcAddr1Port)
	RvLogSourceConstruct(rvMegacoLogGet(), &mgr->logSource, "TermMgr", "Termination manager layer");	//增加一个日志源
	
	RvMutexConstruct(rvMegacoLogGet(), &mgr->lock);
	mgr->genAlloc =rvAllocCacheTlsAlloc;
	mgr->pkgAlloc =rvAllocCacheTlsAlloc;
	mgr->termAlloc =rvAllocCacheTlsAlloc;
	mgr->termStateAlloc =rvAllocCacheTlsAlloc;
	mgr->contextAlloc =rvAllocCacheTlsAlloc;
	mgr->transStateAlloc =rvAllocCacheTlsAlloc;
	mgr->actionStateAlloc =rvAllocCacheTlsAlloc;
	mgr->cmdStateAlloc =rvAllocCacheTlsAlloc;
		mgr->userData = NULL;
		mgr->localEntity = localEntity;

		RvClockGet(rvMegacoLogGet(), ¤tTime);	//获取当前时间
	
RvRandomGeneratorConstruct(&mgr->randomGen, RvTimeGetNsecs(¤tTime));	//构造一个随机数生成对象

//使用和栈相同的定时器管理对象
rvMdmTermTimerMgrConstruct(&mgr->termTimerMgr, rvMegacoStackGetTimerMgr(localEntity->stack), &mgr->lock, mgr->genAlloc);

		rvPtrListConstruct(&mgr->termClassList, mgr->genAlloc);//构造链表

	//构造ROOT终端，其中rvMdmTermMgrCreateTermClass函数参数构造一个空的终端类对象，并加入到mgr->termClassList中，然后返回构造的类对象指针
		rvMdmTermConstruct(&mgr->rootTermination, RV_MDMTERMTYPE_ROOT, rvMdmTermMgrCreateTermClass(mgr), "ROOT", mgr->genAlloc, &mgr->termTimerMgr);
			term->serialVer = SERIAL_VER;	//1
			// terminationId = “ROOT”
			rvMegacoTerminationIdConstructA(&term->terminationId, id, alloc);
			term->type = type;	// RV_MDMTERMTYPE_ROOT
			term->alloc = alloc;
			term->timerMgr = timerMgr;
			term->userData = NULL;
			//初始化终端状态描述符
			rvMegacoTerminationStateDescriptorConstructA(&term->termProps, alloc);
			//设置终端状态描述符的服务属性为在服务中
			rvMegacoTerminationStateDescriptorSetServiceState(&term->termProps, RV_MEGACOSERVICESTATE_INSERVICE);
			//设置状态描述符事件属性BUFRV_MEGACOEVENTBUFFERCONTROL_OFF
			rvMegacoTerminationStateDescriptorSetLockstepMode(&term->termProps, RV_FALSE);
			term->state = rvMdmTermClassGetIdleState(termClass);//不清楚无源码
			term->regTimer = NULL;	//注册定时器

		//构造一个静止定时器管理对象，用于做心跳包 
		rvMdmTermInactivityTimerConstructA(&mgr->inactivityTimer, &mgr->rootTermination, mgr->genAlloc);
			inactTimer->isActive            = RV_FALSE;
			inactTimer->mit                 = RV_UINT64_MIN;
			inactTimer->lastActivityTime    = RV_UINT64_MIN;
			inactTimer->rootTerm            = rootTerm;
			inactTimer->timer               = NULL;
			inactTimer->alloc               = alloc;
			inactTimer->inactivityNow       = RV_FALSE;
			RvLockConstruct(rvMegacoLogGet(), &inactTimer->lock)
		
		//启心跳定时器，超时后调用回调发送NOTIFY包
		rvMdmTermInactivityTimerConfigure(&mgr->inactivityTimer, 2000); /*20s*/
			//设置心跳时间
			inactTimer->mit = RvUint64Mul( RvUint64FromRvInt32(mit*10), RV_TIME64_NSECPERMSEC);
			//激活定时器
			inactTimer->isActive = RV_TRUE;
			
			rvMdmTermInactivityTimerReset(inactTimer);
				//更新最后活动时间
				inactTimer->lastActivityTime = RvTimestampGet(rvMegacoLogGet());

				inactTimer->timer = rvMdmTermTimerCreate(inactTimer->rootTerm->timerMgr, RvUint64ToRvUint32( RvUint64Div(inactTimer->mit, RV_TIME64_NSECPERMSEC) ), rvMdmTermInactivityTimerExpired, inactTimer);
					t = rvAllocAllocate(timerMgr->alloc, sizeof(RvMdmTermTimer));
					t->timerMgr = timerMgr;
					t->valid = RV_TRUE;
					t->data = data;	// inactTimer对象
					t->func = func;//定时器触发后的回调处理函数
					
					//构造inactTimer->timer->timer对象，传入该定时器触发后的回调函数，其中processTimer函数最后会调用上面的t->func = func回调
					rvMegacoTimerConstruct(timerMgr->tMgr, &t->timer, ms, processTimer, t);
					//创建一个一次性定时器，加入栈的timerMgr->timerQ列表，并设置了一个回调函数rvMegacoTimerFunc，其中这个回调函数会调用上面的processTimer回调，然后又调用上上的rvMdmTermInactivityTimerExpired回调，最终执行心跳超时后，如何处理。太麻烦了这里……
					rvMegacoTimerStart(&t->timer);
		
		//构建一个MAP结构，作用不清楚
		rvMdmTermDbConstruct(&mgr->termDb, mgr->genAlloc);
	
		//构建一个空上下文
		rvMdmContextConstruct(&mgr->nullContext, 0, mgr, mgr->genAlloc);
			context->serialVer = SERIAL_VER;
			rvMegacoContextIdConstructSpecial(&context->id, RV_MEGACOCONTEXTID_NULL);
				x->id = 0;
				x->type = type;	//空类型
			rvMdmTermDbConstruct(&context->db, alloc);
			context->isEmergency = RV_FALSE; //非紧急
			context->priority = 0;	//优先级
			context->termMgr = mgr;
			context->alloc = alloc;
			context->userData = NULL;
			context->refs = 0;
		
		//构建上下文HASH表
		rvHashConstruct(RvUint32, RvMdmContextPtr)(&mgr->contextTable,
        RV_MDMTERMMGR_CONTEXTBUCKETS, hashContextId, mgr->genAlloc, mgr->genAlloc);
		
		//设置下一个上下文实例为HASH表最后
		mgr->nextContextIter = rvHashEnd(RvUint32, RvMdmContextPtr)(&mgr->contextTable);

		mgr->maxContexts = 0xFFFFFFFF;
		mgr->maxTermPerContext = 0xFFFFFFFF;
		mgr->contextIdMin = 1;
		mgr->contextIdMax = 0xFFFFFFFD;
		mgr->nextContextId = 1;
		
		rvPtrListConstruct(&mgr->mgcs, mgr->genAlloc);	//构建MGC列表结构
		mgr->currentMgc = rvPtrListEnd(&mgr->mgcs);
		mgr->mgcContacted = RV_FALSE;
		mgr->mgcEverContacted = RV_FALSE;
		rvMegacoEntityAddressConstructA(&mgr->lastConnectedAddress, "", 0, mgr->genAlloc);
		mgr->startState = RV_MDMTERMMGRSTARTSTATE_STOPPED;
		mgr->startTimer = NULL;

		rvMegacoServiceChangeDescriptorConstructA(&mgr->startSc, mgr->genAlloc);
			x->version = rvMegacoServiceChangeDescriptorNoVersion;
			x->method = RV_MEGACOSERVICECHANGEMETHOD_NOTSET;
			rvStringConstruct(&x->otherMethod, "", alloc);
			x->reason = RV_MEGACOSERVICECHANGEREASON_NOTSET;
			x->delay = 0;
			rvMegacoEntityAddressConstructA(&x->newMgc, "", 0, alloc);
			rvMegacoEntityAddressConstructA(&x->newAddress, "", 0, alloc);
			x->newPort = 0;
			rvStringConstruct(&x->profile, "", alloc);
			x->profileVersion = 0;
			rvMegacoParameterListConstructA(&x->extensions, alloc);
			rvTimeStampConstructBlank(&x->timeStamp);//空时间戳
			rvMegacoAuditDescriptorConstructA(&x->auditInfo, RV_MEGACOAUDITITEMS_NONE, alloc);	//建一个审计描述符
			mgr->state = RV_MDMENTITYCONNECTIONSTATUS_UNREGISTERED;
			mgr->mwd = RV_MDMTERMMGR_DEFAULTMWD;	//雪崩时间
			rvListConstruct(RvMdmDeferredEvent)(&mgr->deferredEvents, mgr->genAlloc);	//构造延期事件列表
			mgr->deferEvents = RV_FALSE;
			mgr->processingDeferredEvents = RV_FALSE;
			//不清楚
			rvMdmPackageDbConstruct(&mgr->packageData, mgr->pkgAlloc);
			mgr->selectF = defaultTermMgrSelectTermination;//没代码
			mgr->deleteEphF = defaultTermMgrDeleteEphTerm;//和没有一样
			mgr->connectF = defaultTermMgrConnect;//同上
			mgr->disconnectF = defaultTermMgrDisconnect; //同上
			mgr->contextCreatedF = defaultContextCreated; //同上
			mgr->contextDeletedF = defaultContextDeleted; //同上
			mgr->connStatusF = NULL;

			rvMdmTermMgrAddMgc(mgr, mgcMid, mgcIp, mgcPort)
				remote = (RvMegacoEntity *)rvAllocAllocate(mgr->genAlloc, sizeof(RvMegacoEntity));
				rvMegacoEntityConstructRemoteEx(remote, mId, RV_TRUE, mgr->localEntity, ip, port)
					rvMegacoAddressConstructByName(&socketAddr, ip, port)
					rvMegacoEntityConstructRemoteByAddress(entity, mid, &socketAddr, primary, local);
						entityType =RV_MEGACOENTITYTYPE_MGC;
						rvMegacoEntityConstructCommon(entity, entAddress, primary, entityType, rvMegacoEntityGetTransportType(local), rvMegacoEntityGetEncoding(local), stack);
						entity->version = 1;
						entity->isLocal = RV_FALSE;
						entity->u.remote.localEntity = local;
						RvAddressCopy(address, &entity->socketAddr);
						rvPtrVectorConstruct(&entity->u.remote.transactionsToSend, stack->entityAlloc);
						rvStrStreamConstruct(&entity->u.remote.msgStream, RV_MEGACOENTITY_ENCODEBUFINITSIZE, stack->sendBufAlloc);
						rvMegacoResponseAckConstructA(&entity->u.remote.acks, stack->genAlloc);
						//构建一个远端发送定时器，这里有个发送回调函数
						rvMegacoTimerConstruct(&(stack->timerMgr), &entity->u.remote.sendTimer, 0, rvMegacoEntityOnSendTimer, entity);
						entity->u.remote.timerRunning = RV_FALSE;
	//不清楚			  rvMegacoRoundTripStatsConstruct(&entity->u.remote.roundTripStats, &local->u.local.randomGenerator);
	entity->u.remote.deleteMe = RV_FALSE;
	RvSemaphoreConstruct(1, rvMegacoLogGet(), &entity->u.remote.packetSem);
	entity->u.remote.activePackets = 0;
	rvDequeConstruct(RvMegacoTransactionId)(&entity->u.remote.responses, stack->genAlloc);
	rvDequeConstruct(RvUint)(&entity->u.remote.numToDelete, stack->genAlloc);
	//构建一个应答定时器，并设置回调
	rvMegacoTimerConstruct(&(stack->timerMgr), &entity->u.remote.responseTimer, 0, rvMegacoEntityProcessResponseTimer, entity);

	rvMegacoEntityResetSendBuffer(entity);
		rvStrStreamSeekPos(&remote->u.remote.msgStream, RV_MEGACOENTITY_SENDBUFHDRSIZE);
		rvMegacoMessageHeaderEncode(rvMegacoEntityGetAddress(remote->u.remote.localEntity), rvMegacoEntityGetProtocolVersion(remote), &remote->u.remote.msgStream, remote->stack->encodeCompact, &remote->stack->logSource);
		
		remote->u.remote.maxTransactionSize =(remote->transportType == RV_TRANSPORTTYPE_TCP ? RV_MEGACO_TPKT_MAXLENGTH : 65000) - (rvStrStreamTellPos(&remote->u.remote.msgStream) - sizeof(RvMegacoTpkt));

					RvAddressDestruct(&socketAddr);
				remote->myAllocator = mgr->genAlloc;

				rvPtrListPushBack(&mgr->mgcs, remote);//加入mgc队列
				mgr->currentMgc = rvPtrListBegin(&mgr->mgcs);//设置当前MGC
		
		rvMdmTermMgrRegisterPackages(mgr);
			//空参数
			rvMdmParameterValueConstructA(&stringParam, "", mgr->pkgAlloc);
			rvMdmParameterValueSetQuotes(&stringParam, RV_TRUE);
			
			//建造一个范围参数
			rvMdmParameterValueConstructRangeA(&uint32Param, "0", "4294967295", mgr->pkgAlloc);

			pkg = rvMdmTermMgrCreatePackage(mgr, "g");
				rvStringConstruct(&pkgStr, name, mgr->pkgAlloc);//复制到临时变量
				pkg = (RvMdmPackage *)rvAllocAllocate(mgr->pkgAlloc, sizeof(RvMdmPackage));
				//构建一个通用包g
				rvMdmPackageConstructBase(pkg, name, abstract, mgr->pkgAlloc);
					rvStringConstruct(&x->name, name, alloc);	//复制包名
					x->alloc = alloc;
					x->refs = 0;
					rvPtrListConstruct(&x->versions, alloc);
					x->basePackage = NULL;
					x->abstract = abstract; //FALSE
				//无源码，这里应该是将包名和包对象放入mgr->packageData容器中，其中包名为关键字，包对象为值
				rvMapSetValue(RvIString, RvMdmPackagePtr)(&mgr->packageData, &pkgStr, &pkg);
				
				rvStringDestruct(&pkgStr);
			
			rvMdmRegisterEvent(pkg, "cause");
				//构建一个事件，事件ID为cause，其它为空
				rvMdmEventDataConstructA(&event, id, pkg->alloc);
				rvMdmPackageRegisterEvent(pkg, &event);
					//根据指定包版本，获取包RvMdmPackageVersion对象仓库，这里的RvMdmPackageVersion对象里面存放与包相关的事件、信号、属性、统计、数图
					RvMdmPackageVersion *pv = rvMdmPackageGetVersionData(pkg, version);
					//这里传的版本号是1，则将新建的cause事件加入g包的版本1仓库的eventinfo的map中
					rvMapSetValue(RvIString, RvMdmPackageEventInfo)(&pv->eventInfo, &event->id, rvMdmEventDataGetInfo(event));
				rvMdmEventDataDestruct(&event);
			
			//构建一个参数，填入第一个值为NR
			rvMdmParameterValueConstructA(¶m, "NR", pkg->alloc);

			//将所有枚举参数加入上面构造成参数对象中
			rvMdmParameterValueOr(¶m, "UR");
			rvMdmParameterValueOr(¶m, "FT");
			rvMdmParameterValueOr(¶m, "FP");
			rvMdmParameterValueOr(¶m, "IW");
			rvMdmParameterValueOr(¶m, "UN");
			
			rvMdmPackageRegisterObservedEventParameter(pkg, "cause", "Generalcause", ¶m);
				//获取版本1的存储位置
				RvMdmPackageVersion *pv = rvMdmPackageGetVersionData(pkg, version);
				rvStringConstruct(&evStr, event, pkg->alloc);
				eventInfo = rvMapFindValue(RvIString, RvMdmPackageEventInfo)(&pv->eventInfo, &evStr);	//查找是否有cause事件
				if(eventInfo != NULL)	//如果有
					//设置cause事件的ObservedEvent参数
					rvMegacoParameterListSet2(&eventInfo->obsEventParams, name, value);
				rvStringDestruct(&evStr);
			rvMdmParameterValueDestruct(¶m);
			//设置cause事件的Failurecause参数
			rvMdmPackageRegisterObservedEventParameter(pkg, "cause", "Failurecause", &stringParam);

			//这里不一一列举了，主要是把H.248中定义的基本包都注册到终端管理中，其中还注册了Inactivity定时器超时包

			rvMegacoEntityRegisterRecvRequestCB(localEntity, rvMdmTermMgrProcessTransaction, mgr);
				local->u.local.processRequest = f;//设置本地实例的处理请求回调函数
				local->u.local.processRequestData = data;//data为终端管理对象

			mgr->backupCB = NULL;

	rvMegacoEntityAddressDestruct(&mgc1Addr);

	if (mgcb.cfg.bareMgcAddr2 != NULL)	//如果备用MGC的IP也不为空
		rvMegacoEntityAddressConstruct(&mgc2Addr, mgcb.cfg.bareMgcAddr2, 0);
		//同上述函数添加一样，构建一个远端实便，并加入mgr->mgcs中
		rvMdmTermMgrAddMgc(&mgcb.termMgr, &mgc2Addr, mgcb.cfg.bareMgcAddr2, mgcb.cfg.mgcAddr2Port);
		rvMegacoEntityAddressDestruct(&mgc2Addr);

else	//否则如果用户没有配置主MGC的IP地址
	rvMegacoEntityAddressConstruct(&mgc2Addr, mgcb.cfg.bareMgcAddr2, 0);
	//同上面一样，这里不看进去了
	rvMdmTermMgrConstruct(&mgcb.termMgr, &mgcb.mainEntity, &mgc2Addr, mgcb.cfg.bareMgcAddr2, mgcb.cfg.mgcAddr2Port)
	rvMegacoEntityAddressDestruct(&mgc2Addr);
//根据用户配置，设置本地MG版本
rvMegacoEntitySetProtocolVersion(&mgcb.mainEntity, mgcb.cfg.mgTopVersion);

rvMegacoEntitySetTypeOfService(&mgcb.mainEntity, mgcb.cfg.h248Dscp);
	entity->tos = tos;
	if ((entity->socket != RV_INVALID_SOCKET) && ((entity->transportType != RV_TRANSPORTTYPE_TCP) || !entity->isLocal))
		//设置信令服务质量类型为用户设置，仅对IPv4 UDP有效
		RvSocketSetTypeOfService(&entity->socket, tos, rvMegacoLogGet());

//向mgcb.termMgr注册一些文本扩展包，方法同上面，其中包括
Ctyp 	呼叫类型识别包
Fax 		传真包
Ipfax		IP传真包
Andisp	模拟显示包
Alert		增强振铃包
Xal		模拟线增强包
Xcg		增强进展音生成包
Auth		鉴权包
Fsk		zte softx caller id package, not standard
Mfd		多频音生成检测包
Srvtn	不清楚
Ftmd	传真/文本电话/Modem信号音检测包
mgRegisterTextPackages();

//注册二进制扩展包，先不看了，后面在看二进制的
mgRegisterBinPackages();

//注册回调
rvMdmTermMgrRegisterSelectTermCB(&mgcb.termMgr, mgTermSelect);
	mgr->selectF = selectF;

//同上设置mgcb.termMgr相关回调
rvMdmTermMgrRegisterDeleteEphTermCB(&mgcb.termMgr, mgTermDelEphermal);
rvMdmTermMgrRegisterConnectCB(&mgcb.termMgr, mgTermConnectMedia);
rvMdmTermMgrRegisterDisconnectCB(&mgcb.termMgr, mgTermDisconnectMedia);
rvMdmTermMgrRegisterContextCreatedCB(&mgcb.termMgr, mgContextCreated);
rvMdmTermMgrRegisterContextDeletedCB(&mgcb.termMgr, mgContextDeleted);
rvMdmTermMgrRegisterEntityConnectionStatusCB(&mgcb.termMgr, mgEntityConnectionStatus);

//获取root物理节点类
rootTermClass = rvMdmTermMgrGetRootTerminationClass(&mgcb.termMgr);

//向root物理节点类加入支持的包 g
rvMdmTermClassAddSupportedPkg(rootTermClass, "g", 1);
	rvMegacoPackagesDescriptorAddPackage(&c->pkgsCaps, name, version);
		rvStringAndIntConstructA(&t, name, version, rvVectorGetAllocator(&x->packages));
		rvVectorPushBack(RvStringAndInt)(&x->packages, &t);
		rvStringAndIntDestruct(&t);

//同上加入root 	it 	包支持
rvMdmTermClassAddSupportedPkg(rootTermClass, "root", 1);
rvMdmTermClassAddSupportedPkg(rootTermClass, "it", 1);

//如果用户设置了数图则增加到rootTerm->state->storedDigitMaps中
if (strlen(mgcb.cfg.digitMapValue) > 0 && strlen(mgcb.cfg.digitMapName) > 0)
	rootTerm = rvMdmTermMgrGetRootTermination(&mgcb.termMgr);
	rvStringConstruct(&digitMapname, mgcb.cfg.digitMapName, mgcb.termMgr.genAlloc);
	rvMegacoDigitMapConstructParseA(&digitMap, mgcb.cfg.digitMapValue, mgcb.termMgr.genAlloc);
	rvMapSetValue(RvIString, RvMegacoDigitMap)(&rootTerm->state->storedDigitMaps, &digitMapname, &digitMap);

//添加root物理节点类支持auth包
rvMdmTermClassAddSupportedPkg(rootTermClass, "auth", 1);
//向root物理节点类设置startSignalF回调
rvMdmTermClassRegisterStartSignalCB(rootTermClass, mgRootTermStartSignal);
//向root物理节点类设置setStateF回调
rvMdmTermClassRegisterSetStateCB(rootTermClass, rootTermSetState);

//构造一个通用物理对象类，初始化并加入mgr->termClassList列表
mgcb.termClass = rvMdmTermMgrCreateTermClass(&mgcb.termMgr);
	termClass = (RvMdmTermClass *)rvAllocAllocate(mgr->genAlloc, sizeof(RvMdmTermClass));
	rvMdmTermClassConstruct(termClass, mgr, mgr->genAlloc);
		c->alloc = alloc;
		c->classData = NULL;
		c->termMgr = termMgr;
		rvMegacoMediaDescriptorConstructA(&c->mediaCaps, alloc);
		rvMegacoPackagesDescriptorConstructA(&c->pkgsCaps, alloc);
		rvMdmTermStateConstruct(&c->idleState, rvMdmTermMgrGetNullContext(termMgr), rvMdmTermMgrGetTimerMgr(termMgr), alloc);
		rvMegacoParameterListConstructA(&c->defaultTermProps, alloc);
		c->startSignalF = defaultTermStartSignal;
		c->stopSignalF = defaultTermStopSignal;
		c->createMediaF = defaultTermCreateMedia;
		c->createMediaExF = NULL;
		c->modifyMediaF = defaultTermModifyMedia;
		c->modifyMediaExF = NULL;
		c->destroyMediaF = defaultTermDestroyMedia;
		c->statsF = defaultTermStats;
		c->resetStatsF = defaultTermResetStats;
		c->setStateF = defaultTermSetState;
		c->serviceStateChangeF = defaultTermOnServiceStateChange;
		c->addToContextF = defaultAddToContext;
		c->moveFromContextF = defaultMoveFromContext;
		c->removeFromContextF = defaultRemoveFromContext;
		c->clearDetectEventF = defaultClearDetectEvent;
		c->newEventsF = NULL;
	rvPtrListPushBack(&mgr->termClassList, termClass);

//设置统计的对象
mgStatisticItemsConstruct(&mgcb.mgTermStatistics);
	rvMdmPackageItemConstruct(&mgTermStatistic->dur, "nt", "dur");
		rvStringConstruct(&x->package, pkg, alloc);
		rvStringConstruct(&x->item, item, alloc);
//同上
rvMdmPackageItemConstruct(&mgTermStatistic->os, "nt", "os");
rvMdmPackageItemConstruct(&mgTermStatistic->or, "nt", "or");
rvMdmPackageItemConstruct(&mgTermStatistic->ps, "rtp", "ps");
rvMdmPackageItemConstruct(&mgTermStatistic->pr, "rtp", "pr");
rvMdmPackageItemConstruct(&mgTermStatistic->pl, "rtp", "pl");
rvMdmPackageItemConstruct(&mgTermStatistic->jit, "rtp", "jit");
rvMdmPackageItemConstruct(&mgTermStatistic->delay, "rtp", "delay");

//设置通用终端类对象的回调
rvMdmTermClassRegisterStartSignalCB(mgcb.termClass, mgTermStartSignal);
rvMdmTermClassRegisterStopSignalCB(mgcb.termClass,  mgTermStopSignal);
rvMdmTermClassRegisterCreateMediaCB(mgcb.termClass, mgTermCreateMedia);
rvMdmTermClassRegisterModifyMediaCB(mgcb.termClass, mgTermModifyMedia);
rvMdmTermClassRegisterDestroyMediaCB(mgcb.termClass, mgTermDestroyMedia);
rvMdmTermClassRegisterAddToContextCB(mgcb.termClass, mgTermAddToContext);
rvMdmTermClassRegisterRemoveFromContextCB(mgcb.termClass, mgTermRemoveFromContext);
rvMdmTermClassRegisterStatsCB(mgcb.termClass, mgTermStats);
rvMdmTermClassRegisterResetStatsCB(mgcb.termClass, mgTermResetStats);
rvMdmTermClassRegisterSetStateCB(mgcb.termClass, mgTermSetState);
rvMdmTermClassRegisterServiceStateChangeCB(mgcb.termClass, mgTermServiceStateControl);
rvMdmTermClassRegisterNewEventsCB(mgcb.termClass, mgTermNewEvents);

//设置通用终端类对象支持的包
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "g", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "al", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "cg", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "dd", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "tonedet", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "ctyp", 2);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "fax", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "ipfax", 2);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "andisp", 2);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "alert", 2);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "xal", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "xcg", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "rtp", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "nt", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "fsk", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "mfd", 1);
rvMdmTermClassAddSupportedPkg(mgcb.termClass, "srvtn", 1);

//根据用户配置设置一些值
mgSetStackValues();
	//设置长定时器rvMegacoDigitMapDefaultLongTimeout值
	//设置短定时器rvMegacoDigitMapDefaultShortTimeout值
	//设置启始定时器rvMegacoDigitMapDefaultStartTimeout值
	//设置心跳超时值，给MGC发送通知
	rvMdmTermInactivityTimerConfigure(&mgcb.termMgr.inactivityTimer,用户值);
	rvMdmTermMgrSetMwd(&mgcb.termMgr,用户值);//设置雪崩值mwd
	//设置鉴权相关值
	strncpy(md5_key, mgcb.cfg.authKey, sizeof(md5_key)-1);
	strncpy(md5_mgId, mgcb.cfg.authName, sizeof(md5_mgId) -1);

rvMegacoSystemRegisterStack(&mgcb.stack);
	//将协议栈加入系统栈表中，难到还有有多个？？？
	rvPtrVectorPushBack(&rvMegacoSystem.stacks, stack);
	rvMegacoStackStart(stack);
		rvMegacoTransportStart(&stack->transport);
			//启用传输层
			if(!x->running)
				//构建一个传输层的处理包队列，大小为32
				RvQueueConstruct(RV_TRANSPORT_QUEUESIZE, sizeof(RvPacketData*), NULL, rvMegacoLogGet(), &x->packetQueue);
				for(i=0; i<x->numThreads; ++i)	//这里传输层线程仅有一个
					//启动传输层包处理线程函数
					RvThreadStart(&x->threads[i]);
			
			//在这之前传输层对象中的SOCKET引擎线程函数已经运行，但停在那里了，等待running为true，这里就是开启的
			rvMegacoSocketEngineStart((RvMegacoSocketEngine *)x->socketEngine);
				se->active = RV_TRUE;

			x->running = RV_TRUE;

rvMdmTermMgrStart(&mgcb.termMgr, NULL);
	if(mgr->startState == RV_MDMTERMMGRSTARTSTATE_STOPPED)
		//生成一个0到mwd的随机数
		RvRandomGeneratorGetInRange(&mgr->randomGen, (RvRandom)mgr->mwd, &randVal);
		//启动一个一次性定时器，超过雪崩时间则调用回调processStartMdmTimeout
		mgr->startTimer = rvMdmTermTimerCreate(&mgr->termTimerMgr, (RvInt)randVal + 1, processStartMdmTimeout, mgr);
		//设置未注册
		mgr->state = RV_MDMENTITYCONNECTIONSTATUS_UNREGISTERED;
		//设置启动定时器正在启动，还没有触发
		mgr->startState = RV_MDMTERMMGRSTARTSTATE_STARTTIMERRUNNING;

mgcb.mgStarted = RV_TRUE;

(mgstartup结束)

rvMegacoSocketEngineThread线程函数为
==-====================================================================
RvSelectConstruct(2048, 0, logMgr, &se->selectEngine);	//创建select程序
//释放信号量，让rvMegacoSocketEngineConstruct继续运行
RvSemaphorePost(&se->sema, logMgr);

//等待线程激活
while (!se->active)
	RvTimeConstruct(0, 100*RV_TIME_NSECPERMSEC, &st);
	RvThreadSleep(&st, logMgr);

RvTimerEngineThread线程函数为
nextservice = RvTimestampGet(NULL);	//获取当前时间
while(tengine->stopped == RV_FALSE)	//循环
	nextservice = RvInt64Add(nextservice, tengine->period);//加一个执行周期时间
	if(tengine->paused == RV_FALSE)
		RvTimerQueueService(tengine->tqueue, 0, NULL, NULL, NULL)
			eventcount = &defaultcount
			*eventcount = 0;
			curtime = RvTimestampGet(tqueue->logMgr);	//当前时间
			
			//条件为(result == RV_OK) && (tqueue->qState != RV_TIMERQUEUE_DELETED) && ((maxevents == 0) || (*eventcount < maxevents))
			Do
				//取出一个事件
				event = (RvTimerEvent *)RvPQueuePeek(&tqueue->pqueue);

				if((event == NULL) || (RvInt64IsGreaterThan(event->triggertime, curtime)) || (tqueue->qState == RV_TIMERQUEUE_DISABLED && alternativeCb != NULL))
					break;
				
				RvPQueueRemove(&tqueue->pqueue, event->index);//队列中删除
				event->state = RV_TIMER_EVENTSTATE_TRIGGERED;//标记为触发
				*eventcount += 1;
				tqueue->callcount += 1;

				timerInfo.event = event;
				timerInfo.id = event->id;
				event->callback(event->userdata, &timerInfo);//调用事件的回调
				
				//循环定时器，重新加入队列
				if((event->timertype == RV_TIMER_TYPE_PERIODIC) && (event->canceled == RV_FALSE) && (callbackresult == RV_TRUE) && (tqueue->qState != RV_TIMERQUEUE_DELETED))
					event->state = RV_TIMER_EVENTSTATE_QUEUED;
					event->triggertime = RvInt64Add(event->triggertime, event->triggerlength);
					RvPQueuePut(&tqueue->pqueue, event)
				Else	//一次性定时器
					if(event->sleepChannel != 0)	//使用唤醒函数回调
						for(sleepChannel = event->sleepChannel; sleepChannel != 0; sleepChannel = sleepChannel->next)
							sleepChannel->vt->wakeup(sleepChannel, tqueue->logMgr);
					else
						event->state = RV_TIMER_EVENTSTATE_NOTINUSE;
						RvObjPoolReleaseItem(&tqueue->pool, event);
						
						if(tqueue->qState == RV_TIMERQUEUE_DELETED && tqueue->callcount == 0)
							RvSemaphorePost(&tqueue->wait,tqueue->logMgr);

			RvTimerQueueNextEvent(tqueue,&nextevent);	//获得下一事件时间
			if (RvInt64IsLessThanOrEqual(nextevent, RvInt64Const(0,0,0)))//<=0
				nextevent = RvInt64Const(1,0,1); // =1
			RvSelectSetTimeOut((RvSelectEngine *)tqueue->selEng, curtime, nextevent, tqueue->logMgr);	//设置select延时

	delay = RvInt64Sub(nextservice, RvTimestampGet(NULL));	//用了多少时间
	//如果执行周期时间没有用完，继续等，否则重新开始
	if(RvInt64IsGreaterThan(delay, RvInt64Const(0,0,0)))
		RvThreadNanosleep(delay,NULL);
	Else
		nextservice = RvTimestampGet(NULL);

rvMegacoStackProcessTcbUpdates
rvPtrVectorConstruct(&good, stack->genAlloc);
rvPtrVectorConstruct(&bad, stack->genAlloc);

//这里没有仔细看，大概是事务控制块的状态变迁及重传定时器的复位
for(;;)
	RvSemaphoreWait(&stack->tcbUpdateSem, rvMegacoLogGet());
	if(stack->done) break;

	rvPtrVectorCopy(&good, &stack->goodTcbs);
	rvPtrVectorCopy(&bad, &stack->badTcbs);
	rvPtrVectorClear(&stack->goodTcbs);
	rvPtrVectorClear(&stack->badTcbs);

	if (rvPtrVectorSize(&good) > 0)
		for(iter=rvPtrVectorBegin(&good); iter!=rvPtrVectorEnd(&good); iter=rvPtrVectorIterNext(iter))
			rvMegacoTcbUpdateOnSend((RvMegacoTcb *)*rvPtrVectorIterData(iter));
				switch(tcbPtr->state)
				case RV_MEGACOTCBSTATE_REQUEST_QUEUED:
				……
				
				if(timeout)
					rvMegacoTcbResetTimer(tcbPtr, timeout);
	
	if (rvPtrVectorSize(&bad) > 0)
		for(iter=rvPtrVectorBegin(&bad); iter!=rvPtrVectorEnd(&bad); iter=rvPtrVectorIterNext(iter))
			rvMegacoTcbUpdateFailedSend((RvMegacoTcb *)*rvPtrVectorIterData(iter));
				switch(tcbPtr->state)
				case RV_MEGACOTCBSTATE_REQUEST_QUEUED:
				……
				rvMegacoTcbResetTimer(tcbPtr, RV_MEGACOTCB_IMMEDIATE_TIMEOUT);

rvPtrVectorDestruct(&good);
rvPtrVectorDestruct(&bad);

==============================================================================
static void processStartMdmTimeout(RvMdmTermTimer *timer, void *data) 线程函数
==============================================================================
mgr->startTimer = NULL;	//清除定时器对象

rvMdmTermMgrCheckStartMdm(mgr);
	//如果当前启动状态为开启定时器运行，则只是启动了定时器，并没有真正运行
	if (mgr->startState == RV_MDMTERMMGRSTARTSTATE_STARTTIMERRUNNING)
		//如果当前状态为“未注册”或“连接断开”
		if ((mgr->state == RV_MDMENTITYCONNECTIONSTATUS_UNREGISTERED) ||(mgr->state == RV_MDMENTITYCONNECTIONSTATUS_DISCONNECTED))
			//获取service change描述符
			RvMegacoServiceChangeDescriptor * scDesc = &mgr->startSc;
			
			scReason = RV_MEGACOSERVICECHANGEREASON_COLDBOOT;//冷启动

			//将注册包发出
			rvMdmTermMgrSendServiceChange(mgr, rvMdmTermMgrGetRootTermination(mgr), scDesc, scReason, rvMdmTermMgrProcessRootServiceChangeReply);

			rvMdmTermMgrSetState(mgr, RV_MDMENTITYCONNECTIONSTATUS_REGISTERING);	//设置状态为正在注册

		if(mgr->startTimer != NULL)
			rvMdmTermTimerCancel(mgr->startTimer);
			mgr->startTimer = NULL;

		mgr->startState = RV_MDMTERMMGRSTARTSTATE_STARTED;// 设置状态为已经启动