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_RECVBUFSIZEp->realBlockSize = rvPoolCalcBlockSize(blockSize); //真实池大小，加了块头p->constructor = constructor; // NULLp->destructor = destructor; //NULLp->data = data; //NULLp->alloc = alloc; // = rvDefaultAllocp->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; // = 1RvSdpStackCfg 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; // 1x->threads = (RvThread *)rvAllocAllocate(genAlloc, numThreads * sizeof(RvThread));x->processPacket = pRecvPacketCb; //设置接收包处理回调函数x->onSocketDelete = NULL;x->genAlloc = genAlloc;x->recvBufAlloc = recvBufAlloc;for(i=0; ithreads[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处理线程，线程程序为rvMegacoSocketEngineThreadRvThreadConstruct(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; //NULLpoolcallbacks.pagefreedata = memregion; //NULLRvObjPoolConstruct(&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 * 1000000limits->min = min; // 100 * 1000000limits->max = max; // 4000 * 1000000stack->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.mgAddrrvMegacoEntityAddressConstruct(&mgAddr, mgGetMidFormat(), 0);rvMegacoEntityAddressConstructA((x), (dnsOrIp), (port), &rvDefaultAlloc)rvStringConstruct(&x->address, dnsOrIp, alloc); //复制IP字符串x->port = port; //设置端口//根据dsnOrip字符判断并调协x->type =为IP或DNS，这里代码省略
ElservMegacoEntityAddressConstruct(&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.mainEntityrvMegacoEntityConstructCommon(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; //2entity->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);//绑定端口及IPRvSocketBind(&rvSock, localAddr, NULL, logMgr);//构造socketDatasocketData = (RvMegacoSocketData *)rvAllocAllocate(x->genAlloc, sizeof(RvMegacoSocketData));//填充socketDatarvMegacoSocketDataConstruct(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->fdRvFdConstruct(&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_READtranslatedEvents = (RvSelectEvents)rvSelectToOS(selectEvents);RV_FD_SET(fd->fd, &selectEngine->rdSet);//设置当这个句柄触发时的回调函数，该回调函数为rvMegacoTransportRecvFromUdpfd->callback = eventsCb; fd->events = selectEvents;rvFdPreempt(selectEngine, RvSelectEmptyPreemptMsg);//message = 0write(selectEngine->preemptionPipeFd[1], &message, sizeof(RvUint8)rvMegacoEntityAddressDestruct(&mgAddr);if ( mgcb.cfg.bareMgcAddr1 != NULL) //如果配置了主MGC的IPrvMegacoEntityAddressConstruct(&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_ROOTterm->alloc = alloc;term->timerMgr = timerMgr;term->userData = NULL;//初始化终端状态描述符rvMegacoTerminationStateDescriptorConstructA(&term->termProps, alloc);//设置终端状态描述符的服务属性为在服务中rvMegacoTerminationStateDescriptorSetServiceState(&term->termProps, RV_MEGACOSERVICESTATE_INSERVICE);//设置状态描述符事件属性BUFRV_MEGACOEVENTBUFFERCONTROL_OFFrvMegacoTerminationStateDescriptorSetLockstepMode(&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);//设置当前MGCrvMdmTermMgrRegisterPackages(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));//构建一个通用包grvMdmPackageConstructBase(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);//构建一个参数，填入第一个值为NRrvMdmParameterValueConstructA(¶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)//构建一个传输层的处理包队列，大小为32RvQueueConstruct(RV_TRANSPORT_QUEUESIZE, sizeof(RvPacketData*), NULL, rvMegacoLogGet(), &x->packetQueue);for(i=0; inumThreads; ++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);//启动一个一次性定时器，超过雪崩时间则调用回调processStartMdmTimeoutmgr->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);elseevent->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)))//<=0nextevent = RvInt64Const(1,0,1); // =1RvSelectSetTimeOut((RvSelectEngine *)tqueue->selEng, curtime, nextevent, tqueue->logMgr); //设置select延时delay = RvInt64Sub(nextservice, RvTimestampGet(NULL)); //用了多少时间//如果执行周期时间没有用完，继续等，否则重新开始if(RvInt64IsGreaterThan(delay, RvInt64Const(0,0,0)))RvThreadNanosleep(delay,NULL);Elsenextservice = 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;// 设置状态为已经启动
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！
