#include "precomp.h" // // MGC.CPP // MCS Glue Layer, Legacy from simultaneous R.11 and T.120 support // // Copyright(c) Microsoft 1997- // #define MLZ_FILE_ZONE ZONE_NET // // // CONSTANT DATA // // These arrays map between MCAT and DC-Grouwpare constants. They are not // in separate data file since only referenced from this source file. // // UINT McsErrToNetErr (UINT rcMCS); const UINT c_RetCodeMap1[] = { 0, NET_RC_MGC_NOT_SUPPORTED, NET_RC_MGC_NOT_INITIALIZED, NET_RC_MGC_ALREADY_INITIALIZED, NET_RC_MGC_INIT_FAIL, NET_RC_MGC_INVALID_REMOTE_ADDRESS, NET_RC_NO_MEMORY, NET_RC_MGC_CALL_FAILED, NET_RC_MGC_NOT_SUPPORTED, NET_RC_MGC_NOT_SUPPORTED, NET_RC_MGC_NOT_SUPPORTED, // security failed }; const UINT c_RetCodeMap2[] = { NET_RC_MGC_DOMAIN_IN_USE, NET_RC_MGC_INVALID_DOMAIN, NET_RC_MGC_NOT_ATTACHED, NET_RC_MGC_INVALID_USER_HANDLE, NET_RC_MGC_TOO_MUCH_IN_USE, NET_RC_MGC_INVALID_CONN_HANDLE, NET_RC_MGC_INVALID_UP_DOWN_PARM, NET_RC_MGC_NOT_SUPPORTED, NET_RC_MGC_TOO_MUCH_IN_USE }; #define MG_NUM_OF_MCS_RESULTS 15 #define MG_INVALID_MCS_RESULT MG_NUM_OF_MCS_RESULTS NET_RESULT c_ResultMap[MG_NUM_OF_MCS_RESULTS+1] = { NET_RESULT_OK, NET_RESULT_NOK, NET_RESULT_NOK, NET_RESULT_CHANNEL_UNAVAILABLE, NET_RESULT_DOMAIN_UNAVAILABLE, NET_RESULT_NOK, NET_RESULT_REJECTED, NET_RESULT_NOK, NET_RESULT_NOK, NET_RESULT_TOKEN_ALREADY_GRABBED, NET_RESULT_TOKEN_NOT_OWNED, NET_RESULT_NOK, NET_RESULT_NOK, NET_RESULT_NOT_SPECIFIED, NET_RESULT_USER_REJECTED, NET_RESULT_UNKNOWN }; // // MG_Register() // BOOL MG_Register ( MGTASK task, PMG_CLIENT * ppmgClient, PUT_CLIENT putTask ) { PMG_CLIENT pmgClient = NULL; CMTASK cmTask; BOOL rc = FALSE; DebugEntry(MG_Register); UT_Lock(UTLOCK_T120); ASSERT(task >= MGTASK_FIRST); ASSERT(task < MGTASK_MAX); // // Check the putTask passed in: // ValidateUTClient(putTask); // // Does this already exist? // if (g_amgClients[task].putTask != NULL) { ERROR_OUT(("MG task %d already exists", task)); DC_QUIT; } pmgClient = &(g_amgClients[task]); ZeroMemory(pmgClient, sizeof(MG_CLIENT)); pmgClient->putTask = putTask; // // Register an exit procedure // UT_RegisterExit(putTask, MGExitProc, pmgClient); pmgClient->exitProcReg = TRUE; // // We register a high priority event handler (join by key handler) to // intercept various events which are generated as part of the join by // key processing. We register it now, before the call to // MG_ChannelJoin below, to prevent events which we cant stop from // going to the client if UT_RegisterEvent fails. This high priority // handler also looks after our internal scheduling of pending // requests. // UT_RegisterEvent(putTask, MGEventHandler, pmgClient, UT_PRIORITY_OBMAN); pmgClient->eventProcReg = TRUE; // // Register our hidden event handler for the client (the parameter to // be passed to the event handler is the pointer to the client CB): // UT_RegisterEvent(putTask, MGLongStopHandler, pmgClient, UT_PRIORITY_NETWORK); pmgClient->lowEventProcReg = TRUE; // // Register as a call manager secondary. // switch (task) { case MGTASK_OM: cmTask = CMTASK_OM; break; case MGTASK_DCS: cmTask = CMTASK_DCS; break; default: ASSERT(FALSE); ERROR_OUT(("Invalid task %d", task)); DC_QUIT; } if (!CMS_Register(putTask, cmTask, &(pmgClient->pcmClient))) { ERROR_OUT(("CMS_Register failed")); DC_QUIT; } rc = TRUE; DC_EXIT_POINT: *ppmgClient = pmgClient; UT_Unlock(UTLOCK_T120); DebugExitBOOL(MG_Register, rc); return(rc); } // // MG_Deregister(...) // void MG_Deregister(PMG_CLIENT * ppmgClient) { PMG_CLIENT pmgClient; DebugEntry(MG_Deregister); UT_Lock(UTLOCK_T120); ASSERT(ppmgClient); pmgClient = *ppmgClient; ValidateMGClient(pmgClient); MGExitProc(pmgClient); // // Dereg CMS handler. In abnormal situations, the CMS exit proc will // clean it up for us. // if (pmgClient->pcmClient) { CMS_Deregister(&pmgClient->pcmClient); } *ppmgClient = NULL; UT_Unlock(UTLOCK_T120); DebugExitVOID(MG_Deregister); } // // MGExitProc() // void CALLBACK MGExitProc(LPVOID uData) { PMG_CLIENT pmgClient = (PMG_CLIENT)uData; PMG_BUFFER pmgBuffer; DebugEntry(MGExitProc); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); // // If the client has attached, detach it // if (pmgClient->userAttached) { MG_Detach(pmgClient); } // // Free all buffers the client may be using: // pmgBuffer = (PMG_BUFFER)COM_BasedListFirst(&(pmgClient->buffers), FIELD_OFFSET(MG_BUFFER, clientChain)); while (pmgBuffer != NULL) { ValidateMGBuffer(pmgBuffer); // // This implicitly frees any user memory or MCS memory associated // with the buffer CB. // MGFreeBuffer(pmgClient, &pmgBuffer); // // MGFreeBuffer removed this CB from the list, so we get the first // one in what's left of the list - if the list is now empty, this // will give us NULL and we will break out of the while loop: // pmgBuffer = (PMG_BUFFER)COM_BasedListFirst(&(pmgClient->buffers), FIELD_OFFSET(MG_BUFFER, clientChain)); } // // Deregister our event handler and exit procedure: // if (pmgClient->exitProcReg) { UT_DeregisterExit(pmgClient->putTask, MGExitProc, pmgClient); pmgClient->exitProcReg = FALSE; } if (pmgClient->lowEventProcReg) { UT_DeregisterEvent(pmgClient->putTask, MGLongStopHandler, pmgClient); pmgClient->lowEventProcReg = FALSE; } if (pmgClient->eventProcReg) { UT_DeregisterEvent(pmgClient->putTask, MGEventHandler, pmgClient); pmgClient->eventProcReg = FALSE; } // // We should only ever be asked to free a client CB which has had all // of its child resources already freed, so do a quick sanity check: // ASSERT(pmgClient->buffers.next == 0); // // Set the putTask to NULL; that's how we know if a client is in use or // not. // pmgClient->putTask = NULL; UT_Unlock(UTLOCK_T120); DebugExitVOID(MGExitProc); } // // MG_Attach(...) // UINT MG_Attach ( PMG_CLIENT pmgClient, UINT_PTR callID, PNET_FLOW_CONTROL pFlowControl ) { UINT rc = 0; DebugEntry(MG_Attach); UT_Lock(UTLOCK_T120); ValidateCMP(g_pcmPrimary); ValidateMGClient(pmgClient); if (!g_pcmPrimary->callID) { // // We aren't in a call yet/anymore. // WARNING_OUT(("MG_Attach failing; not in T.120 call")); rc = NET_RC_MGC_NOT_CONNECTED; DC_QUIT; } ASSERT(callID == g_pcmPrimary->callID); ASSERT(!pmgClient->userAttached); pmgClient->userIDMCS = NET_UNUSED_IDMCS; ZeroMemory(&pmgClient->flo, sizeof(FLO_STATIC_DATA)); pmgClient->userAttached = TRUE; // // Call through to the underlying MCS layer (normally, we need our // callbacks to happen with a task switch but since this is Windows it // doesn't really matter anyway): // rc = MCS_AttachRequest(&(pmgClient->m_piMCSSap), (DomainSelector) &g_pcmPrimary->callID, sizeof(g_pcmPrimary->callID), (MCSCallBack) MGCallback, (void *) pmgClient, ATTACHMENT_DISCONNECT_IN_DATA_LOSS); if (rc != 0) { WARNING_OUT(("MCSAttachUserRequest failed with error %x", rc)); MGDetach(pmgClient); rc = McsErrToNetErr(rc); DC_QUIT; } if (++g_mgAttachCount == 1) { UT_PostEvent(pmgClient->putTask, pmgClient->putTask, MG_TIMER_PERIOD, NET_MG_WATCHDOG, 0, 0); } ASSERT(g_mgAttachCount <= MGTASK_MAX); // // It is assumed that the client will use the same latencies for every // attachment, so we keep them at the client level. // pmgClient->flowControl = *pFlowControl; DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitDWORD(MG_Attach, rc); return(rc); } // // MG_Detach(...) // void MG_Detach ( PMG_CLIENT pmgClient ) { DebugEntry(MG_Detach); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_Detach: client %x not attached", pmgClient)); DC_QUIT; } // // Call FLO_UserTerm to ensure that flow control is stopped on all the // channels that have been flow controlled on our behalf. // FLO_UserTerm(pmgClient); // // Clear out the buffers, variabls. // MGDetach(pmgClient); DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitVOID(MG_Detach); } // // MG_ChannelJoin(...) // UINT MG_ChannelJoin ( PMG_CLIENT pmgClient, NET_CHANNEL_ID * pCorrelator, NET_CHANNEL_ID channel ) { PMG_BUFFER pmgBuffer; UINT rc = 0; DebugEntry(MG_ChannelJoin); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_ChannelJoin: client %x not attached", pmgClient)); rc = NET_RC_MGC_INVALID_USER_HANDLE; DC_QUIT; } // // MCAT may bounce this request, so we must queue the request // rc = MGNewBuffer(pmgClient, MG_RQ_CHANNEL_JOIN, &pmgBuffer); if (rc != 0) { DC_QUIT; } MGNewCorrelator(pmgClient, pCorrelator); pmgBuffer->work = *pCorrelator; pmgBuffer->channelId = (ChannelID)channel; TRACE_OUT(("Inserting join message 0x%08x into pending chain", pmgBuffer)); COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitDWORD(MG_ChannelJoin, rc); return(rc); } // // MG_ChannelJoinByKey(...) // UINT MG_ChannelJoinByKey ( PMG_CLIENT pmgClient, NET_CHANNEL_ID * pCorrelator, WORD channelKey ) { PMG_BUFFER pmgBuffer; UINT rc = 0; DebugEntry(MG_ChannelJoinByKey); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_ChannelJoinByKey: client %x not attached", pmgClient)); rc = NET_RC_MGC_INVALID_USER_HANDLE; DC_QUIT; } // // MCAT may bounce this request, so we must queue the request // rc = MGNewBuffer(pmgClient, MG_RQ_CHANNEL_JOIN_BY_KEY, &pmgBuffer); if (rc != 0) { DC_QUIT; } // // Store the various pieces of information in the joinByKeyInfo // structure of the client CB // MGNewCorrelator(pmgClient, pCorrelator); pmgBuffer->work = *pCorrelator; pmgBuffer->channelKey = (ChannelID)channelKey; pmgBuffer->channelId = 0; TRACE_OUT(("Inserting join message 0x%08x into pending chain", pmgBuffer)); COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitDWORD(MG_ChannelJoinByKey, rc); return(rc); } // // MG_ChannelLeave(...) // void MG_ChannelLeave ( PMG_CLIENT pmgClient, NET_CHANNEL_ID channel ) { PMG_BUFFER pmgBuffer; DebugEntry(MG_ChannelLeave); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_ChannelLeave: client %x not attached", pmgClient)); DC_QUIT; } // // MCAT may bounce this request, so instead of processing it straight // away, we put it on the user's request queue and kick off a process // queue loop: This is a request CB, but we don't need any data buffer // if (MGNewBuffer(pmgClient, MG_RQ_CHANNEL_LEAVE, &pmgBuffer) != 0) { DC_QUIT; } // // Fill in the specific data fields in the request CB: // pmgBuffer->channelId = (ChannelID)channel; COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitVOID(MG_ChannelLeave); } // // MG_SendData(...) // UINT MG_SendData ( PMG_CLIENT pmgClient, NET_PRIORITY priority, NET_CHANNEL_ID channel, UINT length, void ** ppData ) { PMG_BUFFER pmgBuffer; UINT numControlBlocks; UINT i; UINT rc; DebugEntry(MG_SendData); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_SendData: client %x not attached", pmgClient)); rc = NET_RC_MGC_INVALID_USER_HANDLE; DC_QUIT; } // // Check for a packet greater than the permitted size // It must not cause the length to wrap into the flow flag // ASSERT(TSHR_MAX_SEND_PKT + sizeof(TSHR_NET_PKT_HEADER) < TSHR_PKT_FLOW); ASSERT(length <= TSHR_MAX_SEND_PKT); // // Ensure we have a priority which is valid for our use of MCS. // priority = (NET_PRIORITY)(MG_VALID_PRIORITY(priority)); if (pmgClient->userIDMCS == NET_UNUSED_IDMCS) { // // We are not yet attached, so don't try to send data. // ERROR_OUT(("Sending data prior to attach indication")); rc = NET_RC_INVALID_STATE; DC_QUIT; } // // The parameter points to a data buffer pointer. This buffer // pointer should point to a buffer which the client acquired using // MG_GetBuffer. MG_GetBuffer should have added a buffer CB to the // client's buffer list containing the same pointer. Note that if the // NET_SEND_ALL_PRIORITIES flag is set then there will be four buffers // in the client's buffer list containing the same pointer. // // So, we search through the client's buffer list looking for a match // on the data buffer pointer. Move to the first position in the list. // COM_BasedListFind(LIST_FIND_FROM_FIRST, &(pmgClient->buffers), (void**)&pmgBuffer, FIELD_OFFSET(MG_BUFFER, clientChain), FIELD_OFFSET(MG_BUFFER, pDataBuffer), (DWORD_PTR)*ppData, FIELD_SIZE(MG_BUFFER, pDataBuffer)); ValidateMGBuffer(pmgBuffer); // // Check the NET_SEND_ALL_PRIORITIES flag to see if it is set // if (pmgBuffer->priority & NET_SEND_ALL_PRIORITIES) { // // Check that the priority and channel has not changed. Changing // the priority between calling MG_GetBuffer and calling // MG_SendData is not allowed. // ASSERT(pmgBuffer->channelId == channel); ASSERT(priority & NET_SEND_ALL_PRIORITIES); // // The flag is set so there should be multiple control buffers // waiting to be sent. // numControlBlocks = MG_NUM_PRIORITIES; } else { // // Check that the priority and channel has not changed. // ASSERT(pmgBuffer->channelId == channel); ASSERT(pmgBuffer->priority == priority); // // The flag is not set so there should be only one control buffer // waiting. // numControlBlocks = 1; } // // Now send the control blocks // for (i = 0; i < numControlBlocks; i++) { ValidateMGBuffer(pmgBuffer); // // Clear the NET_SEND_ALL_PRIORITIES flag. // pmgBuffer->priority &= ~NET_SEND_ALL_PRIORITIES; // // Set up the packet length for the send (this may be different // from the length in the buffer header since the app may not have // used all the buffer). // ASSERT(length + sizeof(TSHR_NET_PKT_HEADER) <= pmgBuffer->length); pmgBuffer->pPktHeader->header.pktLength = (TSHR_UINT16)(length + sizeof(TSHR_NET_PKT_HEADER)); // // If the length has changed then tell FC about it. // if ((length + sizeof(MG_INT_PKT_HEADER)) < pmgBuffer->length) { FLO_ReallocSend(pmgClient, pmgBuffer->pStr, pmgBuffer->length - (length + sizeof(MG_INT_PKT_HEADER))); } TRACE_OUT(("Inserting send 0x%08x into pend chain, pri %u, chan 0x%08x", pmgBuffer, pmgBuffer->priority, pmgBuffer->channelId)); COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); // // If there is one or more control block left to find then search // the client's buffer list for it. // if ((numControlBlocks - (i + 1)) > 0) { COM_BasedListFind(LIST_FIND_FROM_NEXT, &(pmgClient->buffers), (void**)&pmgBuffer, FIELD_OFFSET(MG_BUFFER, clientChain), FIELD_OFFSET(MG_BUFFER, pDataBuffer), (DWORD_PTR)*ppData, FIELD_SIZE(MG_BUFFER, pDataBuffer)); } } UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); // // Everything went OK - set the ppData pointer to NULL to prevent // the caller from accessing the memory. // *ppData = NULL; rc = 0; DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitDWORD(MG_SendData, rc); return(rc); } // // MG_TokenGrab(...) // UINT MG_TokenGrab ( PMG_CLIENT pmgClient, NET_TOKEN_ID tokenID ) { PMG_BUFFER pmgBuffer; UINT rc = 0; DebugEntry(MG_TokenGrab); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_TokenGrab: client 0x%08x not attached", pmgClient)); rc = NET_RC_MGC_INVALID_USER_HANDLE; DC_QUIT; } // // MCAT may bounce this request, so instead of processing it straight // away, we put it on the user's request queue and kick off a process // queue loop: // rc = MGNewBuffer(pmgClient, MG_RQ_TOKEN_GRAB, &pmgBuffer); if (rc != 0) { WARNING_OUT(("MGNewBuffer failed in MG_TokenGrab")); DC_QUIT; } pmgBuffer->channelId = (ChannelID)tokenID; COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitDWORD(MG_TokenGrab, rc); return(rc); } // // MG_TokenInhibit(...) // UINT MG_TokenInhibit ( PMG_CLIENT pmgClient, NET_TOKEN_ID tokenID ) { PMG_BUFFER pmgBuffer; UINT rc = 0; DebugEntry(MG_TokenInhibit); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_TokenInhibit: client 0x%08x not attached", pmgClient)); rc = NET_RC_MGC_INVALID_USER_HANDLE; DC_QUIT; } // // MCAT may bounce this request, so instead of processing it straight // away, we put it on the user's request queue and kick off a process // queue loop: // rc = MGNewBuffer(pmgClient, MG_RQ_TOKEN_INHIBIT, &pmgBuffer); if (rc != 0) { WARNING_OUT(("MGNewBuffer failed in MG_TokenInhibit")); DC_QUIT; } pmgBuffer->channelId = (ChannelID)tokenID; COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitDWORD(MG_TokenInhibit, rc); return(rc); } // // MG_GetBuffer(...) // UINT MG_GetBuffer ( PMG_CLIENT pmgClient, UINT length, NET_PRIORITY priority, NET_CHANNEL_ID channel, void ** ppData ) { PMG_BUFFER pmgBuffer; UINT rc; DebugEntry(MG_GetBuffer); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_GetBuffer: client 0x%08x not attached", pmgClient)); rc = NET_RC_MGC_INVALID_USER_HANDLE; DC_QUIT; } // // Ensure we have a priority which is valid for our use of MCS. // priority = (NET_PRIORITY)(MG_VALID_PRIORITY(priority)); // // Obtain a buffer and store the info in a buffer CB hung off the // client's list: // rc = MGNewTxBuffer(pmgClient, priority, channel, length, &pmgBuffer); if (rc != 0) { DC_QUIT; } // // We always return a pointer to the data buffer to an application. // The MG packet header is only used when giving data to MCS or // receiving data from MCS. // *ppData = pmgBuffer->pDataBuffer; DC_EXIT_POINT: UT_Unlock(UTLOCK_T120); DebugExitDWORD(MG_GetBuffer, rc); return(rc); } // // MG_FreeBuffer(...) // void MG_FreeBuffer ( PMG_CLIENT pmgClient, void ** ppData ) { PMG_BUFFER pmgBuffer; DebugEntry(MG_FreeBuffer); UT_Lock(UTLOCK_T120); ValidateMGClient(pmgClient); // // Find the buffer CB associated with the buffer - an application // always uses a pointer to the data buffer rather than the packet // header. // COM_BasedListFind(LIST_FIND_FROM_FIRST, &(pmgClient->buffers), (void**)&pmgBuffer, FIELD_OFFSET(MG_BUFFER, clientChain), FIELD_OFFSET(MG_BUFFER, pDataBuffer), (DWORD_PTR)*ppData, FIELD_SIZE(MG_BUFFER, pDataBuffer)); ValidateMGBuffer(pmgBuffer); // // If the app is freeing a send buffer (e.g. because it decided not to // send it) then inform flow control: // if (pmgBuffer->type == MG_TX_BUFFER) { FLO_ReallocSend(pmgClient, pmgBuffer->pStr, pmgBuffer->length); } // // Now free the buffer CB and all associated data: // MGFreeBuffer(pmgClient, &pmgBuffer); // // Reset the client's pointer: // *ppData = NULL; UT_Unlock(UTLOCK_T120); DebugExitVOID(MG_FreeBuffer); } // // MG_FlowControlStart // void MG_FlowControlStart ( PMG_CLIENT pmgClient, NET_CHANNEL_ID channel, NET_PRIORITY priority, UINT backlog, UINT maxBytesOutstanding ) { DebugEntry(MG_FlowControlStart); ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MG_FlowControlStart: client 0x%08x not attached", pmgClient)); DC_QUIT; } // // Ensure we have a priority which is valid for our use of MCS. // priority = (NET_PRIORITY)(MG_VALID_PRIORITY(priority)); FLO_StartControl(pmgClient, channel, priority, backlog, maxBytesOutstanding); DC_EXIT_POINT: DebugExitVOID(MG_FlowControlStart); } // // MGLongStopHandler(...) // BOOL CALLBACK MGLongStopHandler ( LPVOID pData, UINT event, UINT_PTR UNUSEDparam1, UINT_PTR param2 ) { PMG_CLIENT pmgClient; BOOL processed = FALSE; DebugEntry(MGLongStopHandler); pmgClient = (PMG_CLIENT)pData; ValidateMGClient(pmgClient); if (event == NET_EVENT_CHANNEL_JOIN) { WARNING_OUT(("Failed to process NET_EVENT_CHANNEL_JOIN; freeing buffer 0x%08x", param2)); MG_FreeBuffer(pmgClient, (void **)¶m2); processed = TRUE; } else if (event == NET_FLOW) { WARNING_OUT(("Failed to process NET_FLOW; freeing buffer 0x%08x", param2)); processed = TRUE; } DebugExitBOOL(MGLongStopHandler, processed); return(processed); } // // MGEventHandler(...) // BOOL CALLBACK MGEventHandler ( LPVOID pData, UINT event, UINT_PTR param1, UINT_PTR param2 ) { PMG_CLIENT pmgClient; PNET_JOIN_CNF_EVENT pNetJoinCnf = NULL; BOOL processed = TRUE; PMG_BUFFER pmgBuffer; BOOL joinComplete = FALSE; UINT result = NET_RESULT_USER_REJECTED; DebugEntry(MGEventHandler); pmgClient = (PMG_CLIENT)pData; ValidateMGClient(pmgClient); switch (event) { case NET_EVENT_CHANNEL_JOIN: { // // If there are no join requests queued off the client CB then // we have nothing more to do. The only NET events we are // interested in are NET_EV_JOIN_CONFIRM events - pass any others // on. // if (pmgClient->joinChain.next == 0) { // // Pass the event on... // processed = FALSE; DC_QUIT; } // // We must be careful not to process a completed channel join // which we intend to go to the client. The correlator is only // filled in on completed events and is always non-zero. // pNetJoinCnf = (PNET_JOIN_CNF_EVENT)param2; if (pNetJoinCnf->correlator != 0) { // // Pass the event on... // processed = FALSE; DC_QUIT; } // // There is only ever one join request outstanding per client, // so the join confirm is for the first join request in the // list. // pmgBuffer = (PMG_BUFFER)COM_BasedListFirst(&(pmgClient->joinChain), FIELD_OFFSET(MG_BUFFER, pendChain)); ValidateMGBuffer(pmgBuffer); // // We will post a join confirm to the application. Set up the // parameters which are needed. // result = pNetJoinCnf->result; // // Assume for now that we have completed the pending join // request. // joinComplete = TRUE; // // If the result is a failure, we've finished // if (result != NET_RESULT_OK) { WARNING_OUT(("Failed to join channel 0x%08x, result %u", pmgBuffer->channelId, pNetJoinCnf->result)); DC_QUIT; } // // The join request was successful. There are three different // scenarios for issuing a join request... // // (a) A regular channel join. // (b) Stage 1 of a channel join by key (get MCS to assign a // channel number, which we will try to register). // (c) Stage 2 of a channel join by key (join the registered // channel). // if (pmgBuffer->type == MG_RQ_CHANNEL_JOIN) { // // This is the completion of a regular channel join. Copy // the channel Id from the join confirm to the bufferCB // (the join request may have been for channel 0). // pmgBuffer->channelId = (ChannelID)pNetJoinCnf->channel; TRACE_OUT(("Channel join complete, channel 0x%08x", pmgBuffer->channelId)); DC_QUIT; } // // This is channel join by key // if (pmgBuffer->channelId != 0) { // // This is the completion of a channel join by key. // TRACE_OUT(("Channel join by key complete, channel 0x%08x, key %d", pmgBuffer->channelId, pmgBuffer->channelKey)); DC_QUIT; } // // This is Stage 1 of a channel join by key. Fill in the // channel Id which MCS has assigned us into the bufferCB, // otherwise we'll lose track of the channel Id which we're // registering. // pmgBuffer->channelId = (ChannelID)pNetJoinCnf->channel; // // This must be completion of stage 1 of a join by key. We now // have to register the channel Id. // TRACE_OUT(("Registering channel 0x%08x, key %d", pmgBuffer->channelId, pmgBuffer->channelKey)); if (!CMS_ChannelRegister(pmgClient->pcmClient, pmgBuffer->channelKey, pmgBuffer->channelId)) { WARNING_OUT(("Failed to register channel, " "channel 0x%08x, key %d, result %u", pmgBuffer->channelId, pmgBuffer->channelKey, param1)); // // This causes us to post an error notification // result = NET_RESULT_USER_REJECTED; DC_QUIT; } TRACE_OUT(("Waiting for CMS_CHANNEL_REGISTER_CONFIRM")); // // We're now waiting for a CMS_CHANNEL_REGISTER_CONFIRM, so we // haven't finished processing the join request // joinComplete = FALSE; break; } case CMS_CHANNEL_REGISTER_CONFIRM: { // // If there are no join requests queued off the client CB then // we have nothing more to do. // if (pmgClient->joinChain.next == 0) { processed = FALSE; DC_QUIT; } TRACE_OUT(("CMS_CHANNEL_REGISTER rcvd, result %u, channel %u", param1, param2)); // // Assume for now that we have completed the pending join // request. // joinComplete = TRUE; // // There is only ever one join request outstanding per client, // so the channel register confirm is for the first join // request in the list. // pmgBuffer = (PMG_BUFFER)COM_BasedListFirst(&(pmgClient->joinChain), FIELD_OFFSET(MG_BUFFER, pendChain)); ValidateMGBuffer(pmgBuffer); // // Param1 contains the result, LOWORD(param2) contains the // channel number of the registered channel (NOT necessarily // the same as the channel we tried to register). // if (!param1) { WARNING_OUT(("Failed to register channel, " "channel 0x%08x, key %d, result %u", pmgBuffer->channelId, pmgBuffer->channelKey, param1)); result = NET_RESULT_USER_REJECTED; DC_QUIT; } // // If the channel number returned in the confirm event is the // same as the channel number which we tried to register, then // we have finished. Otherwise we have to leave the channel we // tried to register and join the channel returned instead. // if (LOWORD(param2) == pmgBuffer->channelId) { TRACE_OUT(("Channel join by key complete, " "channel 0x%08x, key %d", pmgBuffer->channelId, pmgBuffer->channelKey)); result = NET_RESULT_OK; DC_QUIT; } MG_ChannelLeave(pmgClient, pmgBuffer->channelId); pmgBuffer->channelId = (ChannelID)LOWORD(param2); // // Now we simply requeue the request onto the pending execution // chain, but now with a set channel id to join // TRACE_OUT(("Inserting 0x%08x into pending chain",pmgBuffer)); COM_BasedListRemove(&(pmgBuffer->pendChain)); COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); // // We are now waiting for a join confirm (we've not finished // yet !). However, we've requeued the bufferCB, so we can now // process another join request (or the one we've requeued if // its the only one). // joinComplete = FALSE; pmgClient->joinPending = FALSE; MGProcessPendingQueue(pmgClient); break; } case NET_MG_SCHEDULE: { MGProcessPendingQueue(pmgClient); break; } case NET_MG_WATCHDOG: { MGProcessDomainWatchdog(pmgClient); break; } default: { // // Don't do anything - we want to pass this event on. // processed = FALSE; break; } } DC_EXIT_POINT: if (processed && pNetJoinCnf) { // // Call MG_FreeBuffer to free up the event memory (we know that // MG_FreeBuffer doesn't use the hUser so we pass in zero): // MG_FreeBuffer(pmgClient, (void **)&pNetJoinCnf); } if (joinComplete) { // // We have either completed the channel join, or failed - // either way we have finished processing the join request. // // We have to: // - post a NET_EVENT_CHANNEL_JOIN event to the client // - free up the bufferCB // - reset the client's joinPending state // MGPostJoinConfirm(pmgClient, (NET_RESULT)result, pmgBuffer->channelId, (NET_CHANNEL_ID)pmgBuffer->work); MGFreeBuffer(pmgClient, &pmgBuffer); pmgClient->joinPending = FALSE; } DebugExitBOOL(MGEventHandler, processed); return(processed); } // // MGCallback(...) // #ifdef _DEBUG const char * c_szMCSMsgTbl[22] = { "MCS_CONNECT_PROVIDER_INDICATION", // 0 "MCS_CONNECT_PROVIDER_CONFIRM", // 1 "MCS_DISCONNECT_PROVIDER_INDICATION", // 2 "MCS_ATTACH_USER_CONFIRM", // 3 "MCS_DETACH_USER_INDICATION", // 4 "MCS_CHANNEL_JOIN_CONFIRM", // 5 "MCS_CHANNEL_LEAVE_INDICATION", // 6 "MCS_CHANNEL_CONVENE_CONFIRM", // 7 "MCS_CHANNEL_DISBAND_INDICATION", // 8 "MCS_CHANNEL_ADMIT_INDICATION", // 9 "MCS_CHANNEL_EXPEL_INDICATION", // 10 "MCS_SEND_DATA_INDICATION", // 11 "MCS_UNIFORM_SEND_DATA_INDICATION", // 12 "MCS_TOKEN_GRAB_CONFIRM", // 13 "MCS_TOKEN_INHIBIT_CONFIRM", // 14 "MCS_TOKEN_GIVE_INDICATION", // 15 "MCS_TOKEN_GIVE_CONFIRM", // 16 "MCS_TOKEN_PLEASE_INDICATION", // 17 "MCS_TOKEN_RELEASE_CONFIRM", // 18 "MCS_TOKEN_TEST_CONFIRM", // 19 "MCS_TOKEN_RELEASE_INDICATION", // 20 "MCS_TRANSMIT_BUFFER_AVAILABLE_INDICATION", // 21 }; // MCS_MERGE_DOMAIN_INDICATION 200 // MCS_TRANSPORT_STATUS_INDICATION 101 char * DbgGetMCSMsgStr(unsigned short mcsMessageType) { if (mcsMessageType <= 21) { return (char *) c_szMCSMsgTbl[mcsMessageType]; } #ifdef USE_MERGE_DOMAIN_CODE else if (mcsMessageType == MCS_MERGE_DOMAIN_INDICATION) { return "MCS_MERGE_DOMAIN_INDICATION"; } #endif // USE_MERGE_DOMAIN_CODE else if (mcsMessageType == MCS_TRANSPORT_STATUS_INDICATION) { return "MCS_TRANSPORT_STATUS_INDICATION"; } return "Unknown"; } #endif // _DEBUG void CALLBACK MGCallback ( unsigned int mcsMessageType, UINT_PTR eventData, UINT_PTR pData ) { PMG_CLIENT pmgClient; PMG_BUFFER pmgBuffer; UINT rc = 0; DebugEntry(MGCallback); UT_Lock(UTLOCK_T120); pmgClient = (PMG_CLIENT)pData; ValidateMGClient(pmgClient); if (!pmgClient->userAttached) { TRACE_OUT(("MGCallback: client 0x%08x not attached", pmgClient)); DC_QUIT; } ValidateCMP(g_pcmPrimary); switch (mcsMessageType) { case MCS_UNIFORM_SEND_DATA_INDICATION: case MCS_SEND_DATA_INDICATION: { // // The processing for a SEND_DATA_INDICATION is complicated // significantly by MCS segmenting packets, so we call // MGHandleSendInd to do all the work , then quit out of the // function rather than special casing throughout. // rc = MGHandleSendInd(pmgClient, (PSendData)eventData); DC_QUIT; break; } case MCS_ATTACH_USER_CONFIRM: { NET_UID user; NET_RESULT result; user = LOWUSHORT(eventData); result = TranslateResult(HIGHUSHORT(eventData)); // // If the attach did not succeed, clean up: // if (HIGHUSHORT(eventData) != RESULT_SUCCESSFUL) { WARNING_OUT(("MG_Attach failed; cleaning up")); MGDetach(pmgClient); } else { pmgClient->userIDMCS = user; // // Now initialize flow control for this user attachment // ZeroMemory(&(pmgClient->flo), sizeof(pmgClient->flo)); pmgClient->flo.callBack = MGFLOCallBack; } UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_EVENT_USER_ATTACH, MAKELONG(user, result), g_pcmPrimary->callID); break; } case MCS_DETACH_USER_INDICATION: { NET_UID user; user = LOWUSHORT(eventData); // // If the detach is for the local user, then clean up // the user CB: // if (user == pmgClient->userIDMCS) { // // First terminate flow control // FLO_UserTerm(pmgClient); MGDetach(pmgClient); } else { // // Just remove the offending user from flow control // FLO_RemoveUser(pmgClient, user); } UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_EVENT_USER_DETACH, user, g_pcmPrimary->callID); break; } case MCS_CHANNEL_JOIN_CONFIRM: { PNET_JOIN_CNF_EVENT pNetEvent; UINT i; // // Allocate a buffer for the event // rc = MGNewDataBuffer(pmgClient, MG_EV_BUFFER, sizeof(MG_INT_PKT_HEADER) + sizeof(NET_JOIN_CNF_EVENT), &pmgBuffer); if (rc != 0) { WARNING_OUT(("MGNewDataBuffer failed in MGCallback")); DC_QUIT; } pNetEvent = (PNET_JOIN_CNF_EVENT)pmgBuffer->pDataBuffer; // // Fill in the call ID: // pNetEvent->callID = g_pcmPrimary->callID; pNetEvent->channel = LOWUSHORT(eventData); pNetEvent->result = TranslateResult(HIGHUSHORT(eventData)); // // Now establish flow control for the newly joined channel // Only control priorities that have a non-zero latency // And remember to ignore our own user channel! And top priority. // if (HIGHUSHORT(eventData) == RESULT_SUCCESSFUL) { if (pNetEvent->channel != pmgClient->userIDMCS) { for (i = 0; i < NET_NUM_PRIORITIES; i++) { if ((i == MG_VALID_PRIORITY(i)) && (pmgClient->flowControl.latency[i] != 0)) { FLO_StartControl(pmgClient, pNetEvent->channel, i, pmgClient->flowControl.latency[i], pmgClient->flowControl.streamSize[i]); } } } } // // OK, we've built the DCG event so now post it to our client: // UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_EVENT_CHANNEL_JOIN, 0, (UINT_PTR)pNetEvent); pmgBuffer->eventPosted = TRUE; break; } case MCS_CHANNEL_LEAVE_INDICATION: { NET_CHANNEL_ID channel; channel = LOWUSHORT(eventData); MGProcessEndFlow(pmgClient, channel); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_EVENT_CHANNEL_LEAVE, channel, g_pcmPrimary->callID); break; } case MCS_TOKEN_GRAB_CONFIRM: { NET_RESULT result; result = TranslateResult(HIGHUSHORT(eventData)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_EVENT_TOKEN_GRAB, result, g_pcmPrimary->callID); break; } case MCS_TOKEN_INHIBIT_CONFIRM: { NET_RESULT result; result = TranslateResult(HIGHUSHORT(eventData)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_EVENT_TOKEN_INHIBIT, result, g_pcmPrimary->callID); break; } default: break; } UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); DC_EXIT_POINT: if (rc != 0) { // // We hit an error, but must return OK to MCS - otherwise it will // keep sending us the callback forever! // WARNING_OUT(("MGCallback: Error 0x%08x processing MCS message %u", rc, mcsMessageType)); } UT_Unlock(UTLOCK_T120); DebugExitDWORD(MGCallback, MCS_NO_ERROR); } // // ProcessEndFlow(...) // void MGProcessEndFlow ( PMG_CLIENT pmgClient, ChannelID channel ) { UINT i; DebugEntry(MGProcessEndFlow); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); // // Terminate flow control for the newly left channel // if (channel != pmgClient->userIDMCS) { for (i = 0; i < NET_NUM_PRIORITIES; i++) { if ((i == MG_VALID_PRIORITY(i)) && (pmgClient->flowControl.latency[i] != 0)) { TRACE_OUT(("Ending flow control on channel 0x%08x priority %u", channel, i)); FLO_EndControl(pmgClient, channel, i); } } } DebugExitVOID(MGProcessEndFlow); } // // MGHandleSendInd(...) // UINT MGHandleSendInd ( PMG_CLIENT pmgClient, PSendData pSendData ) { PMG_BUFFER pmgBuffer; PNET_SEND_IND_EVENT pEvent; NET_PRIORITY priority; LPBYTE pData; UINT cbData; UINT rc = 0; TSHR_NET_PKT_HEADER pktHeader; DebugEntry(MGHandleSendInd); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); priority = (NET_PRIORITY)MG_VALID_PRIORITY( (NET_PRIORITY)pSendData->data_priority); pData = pSendData->user_data.value; ASSERT(pData != NULL); cbData = pSendData->user_data.length; ASSERT(cbData > sizeof(TSHR_NET_PKT_HEADER)); TRACE_OUT(("MCS Data Indication: flags 0x%08x, size %u, first dword 0x%08x", pSendData->segmentation, pSendData->user_data.length, *((DWORD *)pData))); ASSERT (pSendData->segmentation == (SEGMENTATION_BEGIN | SEGMENTATION_END)); TRACE_OUT(("Only segment: channel %u, priority %u, length %u", pSendData->channel_id, pSendData->data_priority, cbData)); // // Look at the header // memcpy(&pktHeader, pData, sizeof(TSHR_NET_PKT_HEADER)); // // Trace out the MG header word // TRACE_OUT(("Got 1st MG segment (header=%X)", pktHeader.pktLength)); // // First of all try for a flow control packet // if (pktHeader.pktLength & TSHR_PKT_FLOW) { TRACE_OUT(("Flow control packet")); if (pktHeader.pktLength == TSHR_PKT_FLOW) { FLO_ReceivedPacket(pmgClient, (PTSHR_FLO_CONTROL)(pData + sizeof(TSHR_NET_PKT_HEADER))); } else { WARNING_OUT(("Received obsolete throughput packet size 0x%04x", pktHeader.pktLength)); } pmgClient->m_piMCSSap->FreeBuffer((PVoid) pData); DC_QUIT; } // // Allocate headers for the incoming buffer. // // ASSERT((sizeof(NET_SEND_IND_EVENT) + pktHeader.pktLength) <= 0xFFFF); ASSERT(pktHeader.pktLength == cbData); rc = MGNewRxBuffer(pmgClient, priority, pSendData->channel_id, pSendData->initiator, &pmgBuffer); if (rc != 0) { WARNING_OUT(("MGNewRxBuffer of size %u failed", sizeof(NET_SEND_IND_EVENT) + sizeof(MG_INT_PKT_HEADER))); pmgClient->m_piMCSSap->FreeBuffer((PVoid) pData); DC_QUIT; } pEvent = (PNET_SEND_IND_EVENT) pmgBuffer->pDataBuffer; ValidateCMP(g_pcmPrimary); pEvent->callID = g_pcmPrimary->callID; pEvent->priority = priority; pEvent->channel = pSendData->channel_id; // // Copy the length into the data buffer header. // pmgBuffer->pPktHeader->header = pktHeader; // // We want to skip past the packet header to the user data // pData += sizeof(TSHR_NET_PKT_HEADER); cbData -= sizeof(TSHR_NET_PKT_HEADER); // // Set the pointer in the buffer header to point to the received data. // // pEvent->lengthOfData contains the number of bytes received in this // event so far. // ASSERT(pData); pEvent->data_ptr = pData; pEvent->lengthOfData = cbData; TRACE_OUT(("New RX pmgBuffer 0x%08x pDataBuffer 0x%08x", pmgBuffer, pEvent)); // // OK, we've got all the segments, so post it to our client: // UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_EVENT_DATA_RECEIVED, 0, (UINT_PTR)pEvent); pmgBuffer->eventPosted = TRUE; DC_EXIT_POINT: DebugExitDWORD(MGHandleSendInd, rc); return(rc); } // // MGNewBuffer(...) // UINT MGNewBuffer ( PMG_CLIENT pmgClient, UINT bufferType, PMG_BUFFER * ppmgBuffer ) { PMG_BUFFER pmgBuffer; void * pBuffer = NULL; UINT rc = 0; DebugEntry(MGNewBuffer); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); pmgBuffer = new MG_BUFFER; if (!pmgBuffer) { WARNING_OUT(("MGNewBuffer failed; out of memory")); rc = NET_RC_NO_MEMORY; DC_QUIT; } ZeroMemory(pmgBuffer, sizeof(*pmgBuffer)); SET_STAMP(pmgBuffer, MGBUFFER); pmgBuffer->type = bufferType; // // Insert it at the head of this client's list of allocated buffers: // COM_BasedListInsertAfter(&(pmgClient->buffers), &(pmgBuffer->clientChain)); // // return the pointer // *ppmgBuffer = pmgBuffer; DC_EXIT_POINT: DebugExitDWORD(MGNewBuffer, rc); return(rc); } // // MGNewDataBuffer(...) // UINT MGNewDataBuffer ( PMG_CLIENT pmgClient, UINT bufferType, UINT bufferSize, PMG_BUFFER * ppmgBuffer ) { void * pBuffer = NULL; PMG_BUFFER pmgBuffer; UINT rc = 0; DebugEntry(MGNewDataBuffer); // // Buffers include an MG internal packet header that has a length field // which we add to the start of all user data passed to/received from // MCS. This is four byte aligned, and since the data buffer starts // immediately after this, the data buffer will be aligned. // pBuffer = new BYTE[bufferSize]; if (!pBuffer) { WARNING_OUT(("MGNewDataBuffer allocation of size %u failed", bufferSize)); rc = NET_RC_NO_MEMORY; DC_QUIT; } ZeroMemory(pBuffer, bufferSize); // // Now we allocate the buffer CB which we will use to track the use of // the buffer. // rc = MGNewBuffer(pmgClient, bufferType, ppmgBuffer); if (rc != 0) { WARNING_OUT(("MGNewBuffer failed")); DC_QUIT; } // // Initialise the buffer entry // pmgBuffer = *ppmgBuffer; pmgBuffer->length = bufferSize; pmgBuffer->pPktHeader = (PMG_INT_PKT_HEADER)pBuffer; pmgBuffer->pDataBuffer = (LPBYTE)pBuffer + sizeof(MG_INT_PKT_HEADER); // // Initialize the use count of the data buffer // pmgBuffer->pPktHeader->useCount = 1; DC_EXIT_POINT: if (rc != 0) { // // Cleanup: // if (pBuffer != NULL) { WARNING_OUT(("Freeing MG_BUFFER data 0x%08x; MGNewBuffer failed", pBuffer)); delete[] pBuffer; } } DebugExitDWORD(MGNewDataBuffer, rc); return(rc); } // // MGNewTxBuffer(...) // UINT MGNewTxBuffer ( PMG_CLIENT pmgClient, NET_PRIORITY priority, NET_CHANNEL_ID channel, UINT bufferSize, PMG_BUFFER * ppmgBuffer ) { int i; UINT numPrioritiesToUse; UINT rc = 0; UINT nextPriority; PMG_BUFFER pmgBufferArray[MG_NUM_PRIORITIES]; PFLO_STREAM_DATA pStr[MG_NUM_PRIORITIES]; NET_PRIORITY priorities[MG_NUM_PRIORITIES]; DebugEntry(MGNewTxBuffer); ValidateMGClient(pmgClient); ASSERT(priority != NET_TOP_PRIORITY); // // Initialise the control buffer pointer array. The first member of // this array is the normal buffer which is allocated regardless of the // NET_SEND_ALL_PRIORITIES flag. The remaining members are used for // duplicate control buffer pointers needed for sending data on all // priorities. // ZeroMemory(pmgBufferArray, sizeof(pmgBufferArray)); ZeroMemory(pStr, sizeof(pStr)); // // SFR6025: Check for the NET_SEND_ALL_PRIORITIES flag. This means // that the data will be sent at all four priorities. If it // is not set then we just need to send data at one priority. // In either case we need to: // // Check with flow control that it is possible to send data on // all channels // // Allocate an additional three control blocks which all point // to the same data block and bump up the usage count. // // // NOTE: Previously this function just checked with flow control for // a single channel. // if (priority & NET_SEND_ALL_PRIORITIES) { numPrioritiesToUse = MG_NUM_PRIORITIES; } else { numPrioritiesToUse = 1; } // // Disable the flag to prevent FLO_AllocSend being sent an invalid // priority. // priority &= ~NET_SEND_ALL_PRIORITIES; nextPriority = priority; for (i = 0; i < (int) numPrioritiesToUse; i++) { // // Check with flow control to ensure that send space is available. // Start with the requested priority level and continue for the // other priority levels. // priorities[i] = (NET_PRIORITY)nextPriority; rc = FLO_AllocSend(pmgClient, nextPriority, channel, bufferSize + sizeof(MG_INT_PKT_HEADER), &(pStr[i])); // // If we have got back pressure then just return. // if (rc != 0) { TRACE_OUT(("Received back pressure")); // // Free any buffer space allocated by FLO_AllocSend. // for ( --i; i >= 0; i--) { FLO_ReallocSend(pmgClient, pStr[i], bufferSize + sizeof(MG_INT_PKT_HEADER)); } DC_QUIT; } ValidateFLOStr(pStr[i]); // // Move on to the next priority level. There are MG_NUM_PRIORITY // levels, numbered contiguously from MG_PRIORITY_HIGHEST. The // first priority processed can be any level in the valid range so // rather than simply add 1 to get to the next level, we need to // cope with the wrap-around back to MG_PRIORITY_HIGHEST when we // have just processed the last priority, ie MG_PRIORITY_HIGHEST + // MG_NUM_PRIORITIES - 1. This is achieved by rebasing the priority // level to zero (the - MG_PRIORITY_HIGHEST, below), incrementing // the rebased priority (+1), taking the modulus of the number of // priorities to avoid exceeding the limit (% MG_NUM_PRIORITIES) // and then restoring the base by adding back the first priority // level (+ MG_PRIORITY_HIGHEST). // nextPriority = (((nextPriority + 1 - MG_PRIORITY_HIGHEST) % MG_NUM_PRIORITIES) + MG_PRIORITY_HIGHEST); } // // Use MGNewDataBuffer to allocate the buffer // rc = MGNewDataBuffer(pmgClient, MG_TX_BUFFER, bufferSize + sizeof(MG_INT_PKT_HEADER), &pmgBufferArray[0]); if (rc != 0) { WARNING_OUT(("MGNewDataBuffer failed in MGNewTxBuffer")); DC_QUIT; } // // Add the fields required for doing the send // pmgBufferArray[0]->priority = priority; pmgBufferArray[0]->channelId = (ChannelID) channel; pmgBufferArray[0]->senderId = pmgClient->userIDMCS; ValidateFLOStr(pStr[0]); pmgBufferArray[0]->pStr = pStr[0]; // // Now allocate an additional three control blocks which are identical // to the first one if required. // if (numPrioritiesToUse > 1) { // // Firstly re-enable the NET_SEND_ALL_PRIORITIES flag. This is to // ensure that traversing the linked list in MG_SendData is // efficient. // pmgBufferArray[0]->priority |= NET_SEND_ALL_PRIORITIES; // // Create the duplicate buffers and initialise them. // for (i = 1; i < MG_NUM_PRIORITIES; i++) { TRACE_OUT(("Task allocating extra CB, priority %u", priorities[i])); // // Allocate a new control buffer. // rc = MGNewBuffer(pmgClient, MG_TX_BUFFER, &pmgBufferArray[i]); if (rc != 0) { WARNING_OUT(("MGNewBuffer failed")); DC_QUIT; } // // Initialise the buffer control block. The priority values of // these control blocks are in increasing order from that of // pmgBuffer. // pmgBufferArray[i]->priority = priorities[i]; pmgBufferArray[i]->channelId = pmgBufferArray[0]->channelId; pmgBufferArray[i]->senderId = pmgBufferArray[0]->senderId; pmgBufferArray[i]->length = pmgBufferArray[0]->length; pmgBufferArray[i]->pPktHeader = pmgBufferArray[0]->pPktHeader; pmgBufferArray[i]->pDataBuffer = pmgBufferArray[0]->pDataBuffer; ValidateFLOStr(pStr[i]); pmgBufferArray[i]->pStr = pStr[i]; // // Set the NET_SEND_ALL_PRIORITIES flag. // pmgBufferArray[i]->priority |= NET_SEND_ALL_PRIORITIES; // // Now bump up the usage count of the data block. // pmgBufferArray[i]->pPktHeader->useCount++; TRACE_OUT(("Use count of data buffer %#.8lx now %d", pmgBufferArray[i]->pPktHeader, pmgBufferArray[i]->pPktHeader->useCount)); } } // // Assign the passed first control buffer allocated to the passed // control buffer parameter. // *ppmgBuffer = pmgBufferArray[0]; DC_EXIT_POINT: // // In the event of a problem we free any buffers that we have already // allocated. // if (rc != 0) { for (i = 0; i < MG_NUM_PRIORITIES; i++) { if (pmgBufferArray[i] != NULL) { TRACE_OUT(("About to free control buffer %u", i)); MGFreeBuffer(pmgClient, &pmgBufferArray[i]); } } } DebugExitDWORD(MGNewTxBuffer, rc); return(rc); } // // MGNewRxBuffer(...) // UINT MGNewRxBuffer ( PMG_CLIENT pmgClient, NET_PRIORITY priority, NET_CHANNEL_ID channel, NET_CHANNEL_ID senderID, PMG_BUFFER * ppmgBuffer ) { UINT rc = 0; DebugEntry(MGNewRxBuffer); ValidateMGClient(pmgClient); // // First tell flow control we need a buffer. // No back pressure may be applied here, but flow control uses this // notification to control responses to the sender. // // Note that we always use the sizes including the internal packet // header for flow control purposes. // FLO_AllocReceive(pmgClient, priority, channel, senderID); // // Use MGNewDataBuffer to allocate the buffer. bufferSize includes the // size of the network packet header (this comes over the wire), but // not the remainder of the internal packet header. // rc = MGNewDataBuffer(pmgClient, MG_RX_BUFFER, sizeof(NET_SEND_IND_EVENT) + sizeof(MG_INT_PKT_HEADER), ppmgBuffer); // // Add the fields required for a receive buffer // if (rc == 0) { (*ppmgBuffer)->priority = priority; (*ppmgBuffer)->channelId = (ChannelID)channel; (*ppmgBuffer)->senderId = (ChannelID)senderID; } else { WARNING_OUT(("MGNewDataBuffer failed in MGNewRxBuffer")); } DebugExitDWORD(MGNewRxBuffer, rc); return(rc); } // // MGFreeBuffer(...) // void MGFreeBuffer ( PMG_CLIENT pmgClient, PMG_BUFFER * ppmgBuffer ) { PMG_BUFFER pmgBuffer; void * pBuffer; DebugEntry(MGFreeBuffer); pmgBuffer = *ppmgBuffer; ValidateMGBuffer(pmgBuffer); // // If this is a receive buffer then we must first tell flow control // about the space available // This may trigger a pong, if we are waiting for the app to free up // some space // if (pmgBuffer->type == MG_RX_BUFFER) { ASSERT (pmgBuffer->pPktHeader->useCount == 1); TRACE_OUT(("Free RX pmgBuffer 0x%08x", pmgBuffer)); // // Do a sanity check on the client (there is a window where this // may have been freed). // if (!pmgClient->userAttached) { TRACE_OUT(("MGFreeBuffer: client 0x%08x not attached", pmgClient)); } else { FLO_FreeReceive(pmgClient, pmgBuffer->priority, pmgBuffer->channelId, pmgBuffer->senderId); // Free the MCS buffer if ((pmgBuffer->pPktHeader != NULL) && (pmgClient->m_piMCSSap != NULL)) { ASSERT(pmgBuffer->pDataBuffer != NULL); ASSERT(((PNET_SEND_IND_EVENT)pmgBuffer->pDataBuffer)->data_ptr != NULL); pmgClient->m_piMCSSap->FreeBuffer ( (PVoid) (((PNET_SEND_IND_EVENT) pmgBuffer->pDataBuffer) ->data_ptr - sizeof(TSHR_NET_PKT_HEADER))); TRACE_OUT(("MGFreeBuffer: Freed data_ptr for pmgBuffer 0x%08x pDataBuffer 0x%08x", pmgBuffer, pmgBuffer->pDataBuffer)); ((PNET_SEND_IND_EVENT)pmgBuffer->pDataBuffer)->data_ptr = NULL; } } } // // Free the data buffer, if there is one present. Note that this can // be referenced by more than one bufferCB, and so has a use count // which must reach zero before the buffer is freed. // if (pmgBuffer->pPktHeader != NULL) { ASSERT(pmgBuffer->pPktHeader->useCount != 0); pmgBuffer->pPktHeader->useCount--; TRACE_OUT(("Data buffer 0x%08x use count %d", pmgBuffer->pPktHeader, pmgBuffer->pPktHeader->useCount)); if (pmgBuffer->pPktHeader->useCount == 0) { TRACE_OUT(("Freeing MG_BUFFER data 0x%08x; use count is zero", pmgBuffer->pPktHeader)); delete[] pmgBuffer->pPktHeader; pmgBuffer->pPktHeader = NULL; } } // // If the buffer CB is in the pending queue then remove it first! // if (pmgBuffer->pendChain.next != 0) { COM_BasedListRemove(&(pmgBuffer->pendChain)); } // // Now remove the buffer CB itself from the list and free it up: // COM_BasedListRemove(&(pmgBuffer->clientChain)); delete pmgBuffer; *ppmgBuffer = NULL; DebugExitVOID(MGFreeBuffer); } // // MGDetach(...) // void MGDetach ( PMG_CLIENT pmgClient ) { PMG_BUFFER pmgBuffer; PMG_BUFFER pmgT; PIMCSSap pMCSSap; #ifdef _DEBUG UINT rc; #endif // _DEBUG DebugEntry(MGDetach); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); pMCSSap = pmgClient->m_piMCSSap; // // Remove any entries for this user from the channel join pending list. // pmgBuffer = (PMG_BUFFER)COM_BasedListFirst(&(pmgClient->joinChain), FIELD_OFFSET(MG_BUFFER, pendChain)); while (pmgBuffer != NULL) { ValidateMGBuffer(pmgBuffer); // // Get a pointer to the next bufferCB in the list - we have to do // this before we free the current bufferCB (freeing it NULLs it, // so we won't be able to step along to the next entry in the // list). // pmgT = (PMG_BUFFER)COM_BasedListNext(&(pmgClient->joinChain), pmgBuffer, FIELD_OFFSET(MG_BUFFER, pendChain)); MGFreeBuffer(pmgClient, &pmgBuffer); // // We won't get a match on a join request now, so we don't have // a join pending. // pmgClient->joinPending = FALSE; pmgBuffer = pmgT; } // // Remove any unsent receive buffers for this user from the buffer list // pmgBuffer = (PMG_BUFFER)COM_BasedListFirst(&(pmgClient->buffers), FIELD_OFFSET(MG_BUFFER, clientChain)); while (pmgBuffer != NULL) { ValidateMGBuffer(pmgBuffer); // // Get a pointer to the next bufferCB in the list - we have to do // this before we free the current bufferCB (freeing it NULLs it, // so we won't be able to step along to the next entry in the // list). // pmgT = (PMG_BUFFER)COM_BasedListNext(&(pmgClient->buffers), pmgBuffer, FIELD_OFFSET(MG_BUFFER, clientChain)); if (pmgBuffer->type == MG_RX_BUFFER) { if (pmgBuffer->eventPosted) { if ((pmgBuffer->pPktHeader != NULL) && (pMCSSap != NULL)) { ASSERT(pmgBuffer->pDataBuffer != NULL); ASSERT(((PNET_SEND_IND_EVENT)pmgBuffer->pDataBuffer)->data_ptr != NULL); pMCSSap->FreeBuffer ( (PVoid) (((PNET_SEND_IND_EVENT) pmgBuffer->pDataBuffer) ->data_ptr - sizeof(TSHR_NET_PKT_HEADER))); TRACE_OUT(("MGDetach: Freed data_ptr for pmgBuffer 0x%08x pDataBuffer 0x%08x", pmgBuffer, pmgBuffer->pDataBuffer)); ((PNET_SEND_IND_EVENT) pmgBuffer->pDataBuffer)->data_ptr = NULL; } } else { // // The bufferCB's user matches the user we are freeing up, // and we haven't posted the event to the user, so free it. // MGFreeBuffer removes it from the pending list, so we don't // have to do that. // MGFreeBuffer(pmgClient, &pmgBuffer); } } pmgBuffer = pmgT; } // // Clear out the attachment info // pmgClient->userAttached = FALSE; pmgClient->userIDMCS = 0; // // We can safely do an MCS DetachRequest without adding a requestCB // - MCS will not bounce the request due to congestion, domain merging // etc. // if (pMCSSap != NULL) { #ifdef _DEBUG rc = pMCSSap->ReleaseInterface(); if (rc != 0) { // // No quit - we need to do our own cleanup. // // lonchanc: what cleanup needs to be done??? // rc = McsErrToNetErr(rc); switch (rc) { case 0: case NET_RC_MGC_INVALID_USER_HANDLE: case NET_RC_MGC_TOO_MUCH_IN_USE: // These are normal. TRACE_OUT(("MCSDetachUser normal error %d", rc)); break; default: ERROR_OUT(("MCSDetachUser abnormal error %d", rc)); break; } } #else pMCSSap->ReleaseInterface(); #endif //_DEBUG pmgClient->m_piMCSSap = NULL; } --g_mgAttachCount; DebugExitVOID(MGDetach); } // // MGProcessPendingQueue(...) // UINT MGProcessPendingQueue(PMG_CLIENT pmgClient) { PMG_BUFFER pmgBuffer; PMG_BUFFER pNextBuffer; UINT rc = 0; DebugEntry(MGProcessPendingQueue); ValidateMGClient(pmgClient); pNextBuffer = (PMG_BUFFER)COM_BasedListFirst(&(pmgClient->pendChain), FIELD_OFFSET(MG_BUFFER, pendChain)); // // Try and clear all the pending request queue // for ( ; (pmgBuffer = pNextBuffer) != NULL; ) { ValidateMGBuffer(pmgBuffer); pNextBuffer = (PMG_BUFFER)COM_BasedListNext(&(pmgClient->pendChain), pNextBuffer, FIELD_OFFSET(MG_BUFFER, pendChain)); TRACE_OUT(("Got request 0x%08x from queue, type %u", pmgBuffer, pmgBuffer->type)); // // Check that the buffer is still valid. There is a race at // conference termination where we can arrive here, but our user // has actually already detached. In this case, free the buffer // and continue. // if (!pmgClient->userAttached) { TRACE_OUT(("MGProcessPendingQueue: client 0x%08x not attached", pmgClient)); MGFreeBuffer(pmgClient, &pmgBuffer); continue; } switch (pmgBuffer->type) { case MG_RQ_CHANNEL_JOIN: case MG_RQ_CHANNEL_JOIN_BY_KEY: { // // If this client already has a join outstanding, then skip // this request. // if (pmgClient->joinPending) { // // Break out of switch and goto next iteration of for() // continue; } pmgClient->joinPending = TRUE; // // Attempt the join // rc = pmgClient->m_piMCSSap->ChannelJoin( (unsigned short) pmgBuffer->channelId); // // If the join failed then post an error back immediately // if (rc != 0) { if ((rc != MCS_TRANSMIT_BUFFER_FULL) && (rc != MCS_DOMAIN_MERGING)) { // // Something terminal went wrong - post a // NET_EV_JOIN_CONFIRM (failed) to the client // MGPostJoinConfirm(pmgClient, NET_RESULT_USER_REJECTED, pmgBuffer->channelId, (NET_CHANNEL_ID)(pmgBuffer->work)); } pmgClient->joinPending = FALSE; } else { // // If the request worked then we must move it to the // join queue for completion // TRACE_OUT(("Inserting 0x%08x into join queue",pmgBuffer)); COM_BasedListRemove(&(pmgBuffer->pendChain)); COM_BasedListInsertBefore(&(pmgClient->joinChain), &(pmgBuffer->pendChain)); // // Do not free this buffer - continue processing the // pending queue // continue; } } break; case MG_RQ_CHANNEL_LEAVE: { // // Try to leave the channel: // rc = pmgClient->m_piMCSSap->ChannelLeave( (unsigned short) pmgBuffer->channelId); if (rc == 0) { MGProcessEndFlow(pmgClient, pmgBuffer->channelId); } } break; case MG_RQ_TOKEN_GRAB: { rc = pmgClient->m_piMCSSap->TokenGrab(pmgBuffer->channelId); } break; case MG_RQ_TOKEN_INHIBIT: { rc = pmgClient->m_piMCSSap->TokenInhibit(pmgBuffer->channelId); } break; case MG_RQ_TOKEN_RELEASE: { rc = pmgClient->m_piMCSSap->TokenRelease(pmgBuffer->channelId); } break; case MG_TX_BUFFER: { ASSERT(!(pmgBuffer->pPktHeader->header.pktLength & TSHR_PKT_FLOW)); // // Send the data. Remember that we don't send all of the // packet header, only from the length... // ASSERT((pmgBuffer->priority != NET_TOP_PRIORITY)); rc = pmgClient->m_piMCSSap->SendData(NORMAL_SEND_DATA, pmgBuffer->channelId, (Priority)(pmgBuffer->priority), (unsigned char *) &(pmgBuffer->pPktHeader->header), pmgBuffer->pPktHeader->header.pktLength, APP_ALLOCATION); // // Check the return code. // if (rc == 0) { // // Update the allocation. FLO_DecrementAlloc will // check that the stream pointer is not null for us. // (It will be null if flow control has ended on this // channel since this buffer was allocated or if this // is an uncontrolled channel). // // Note that for flow control purposes, we always use // packet sizes including the internal packet header. // FLO_DecrementAlloc(pmgBuffer->pStr, (pmgBuffer->pPktHeader->header.pktLength - sizeof(TSHR_NET_PKT_HEADER) + sizeof(MG_INT_PKT_HEADER))); } } break; case MG_TX_PING: case MG_TX_PONG: case MG_TX_PANG: { // // This is the length of a ping/pong message: // ASSERT(pmgBuffer->priority != NET_TOP_PRIORITY); rc = pmgClient->m_piMCSSap->SendData(NORMAL_SEND_DATA, pmgBuffer->channelId, (Priority)(pmgBuffer->priority), (unsigned char *) &(pmgBuffer->pPktHeader->header), sizeof(TSHR_NET_PKT_HEADER) + sizeof(TSHR_FLO_CONTROL), APP_ALLOCATION); } break; } rc = McsErrToNetErr(rc); // // If the request failed due to back pressure then just get out // now. We will try again later. // if (rc == NET_RC_MGC_TOO_MUCH_IN_USE) { TRACE_OUT(("MCS Back pressure")); break; } // // Only for obman... // if (pmgClient == &g_amgClients[MGTASK_OM]) { ValidateCMP(g_pcmPrimary); // // For any other error or if everything worked so far // then tell the user to keep going // TRACE_OUT(("Posting NET_FEEDBACK")); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_FEEDBACK, 0, g_pcmPrimary->callID); } // // All is OK, or the request failed fatally. In either case we // should free this request and attempt to continue. // MGFreeBuffer(pmgClient, &pmgBuffer); } DebugExitDWORD(MGProcessPendingQueue, rc); return(rc); } // // MGPostJoinConfirm(...) // UINT MGPostJoinConfirm ( PMG_CLIENT pmgClient, NET_RESULT result, NET_CHANNEL_ID channel, NET_CHANNEL_ID correlator ) { PNET_JOIN_CNF_EVENT pNetJoinCnf; PMG_BUFFER pmgBuffer; UINT rc; DebugEntry(MGPostJoinConfirm); ValidateMGClient(pmgClient); // // Allocate a buffer to send the event in - this should only fail if we // really are out of virtual memory. // rc = MGNewDataBuffer(pmgClient, MG_EV_BUFFER, sizeof(MG_INT_PKT_HEADER) + sizeof(NET_JOIN_CNF_EVENT), &pmgBuffer); if (rc != 0) { WARNING_OUT(("Failed to alloc NET_JOIN_CNF_EVENT")); DC_QUIT; } pNetJoinCnf = (PNET_JOIN_CNF_EVENT) pmgBuffer->pDataBuffer; ValidateCMP(g_pcmPrimary); if (!g_pcmPrimary->callID) { WARNING_OUT(("MGPostJoinConfirm failed; not in call")); rc = NET_RC_MGC_NOT_CONNECTED; DC_QUIT; } // // Fill in the fields. // pNetJoinCnf->callID = g_pcmPrimary->callID; pNetJoinCnf->result = result; pNetJoinCnf->channel = channel; pNetJoinCnf->correlator = correlator; // // OK, we've built the event so now post it to our client: // UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_EVENT_CHANNEL_JOIN, 0, (UINT_PTR) pNetJoinCnf); pmgBuffer->eventPosted = TRUE; DC_EXIT_POINT: DebugExitDWORD(MGPostJoinConfirm, rc); return(rc); } // // MCSErrToNetErr() // UINT McsErrToNetErr ( UINT rcMCS ) { UINT rc = NET_RC_MGC_NOT_SUPPORTED; // // We use a static array of values to map the return code: // if (rcMCS < sizeof(c_RetCodeMap1) / sizeof(c_RetCodeMap1[0])) { rc = c_RetCodeMap1[rcMCS]; } else { UINT nNewIndex = rcMCS - MCS_DOMAIN_ALREADY_EXISTS; if (nNewIndex < sizeof(c_RetCodeMap2) / sizeof(c_RetCodeMap2[0])) { rc = c_RetCodeMap2[nNewIndex]; } } #ifdef _DEBUG if (MCS_TRANSMIT_BUFFER_FULL == rcMCS) { ASSERT(NET_RC_MGC_TOO_MUCH_IN_USE == rc); } #endif return rc; } // // TranslateResult(...) // NET_RESULT TranslateResult(WORD resultMCS) { // // We use a static array of values to map the result code: // if (resultMCS >= MG_NUM_OF_MCS_RESULTS) resultMCS = MG_INVALID_MCS_RESULT; return(c_ResultMap[resultMCS]); } // // MGFLOCallback(...) // void MGFLOCallBack ( PMG_CLIENT pmgClient, UINT callbackType, UINT priority, UINT newBufferSize ) { PMG_BUFFER pmgBuffer; DebugEntry(MGFLOCallBack); ASSERT(priority != NET_TOP_PRIORITY); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); // // If this is a buffermod callback then tell the app // if (pmgClient == &g_amgClients[MGTASK_DCS]) { if (callbackType == FLO_BUFFERMOD) { UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_FLOW, priority, newBufferSize); } } else { ASSERT(pmgClient == &g_amgClients[MGTASK_OM]); // // Wake up the app in case we have applied back pressure. // TRACE_OUT(("Posting NET_FEEDBACK")); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_FEEDBACK, 0, g_pcmPrimary->callID); } DebugExitVOID(MGFLOCallback); } // // MGProcessDomainWatchdog() // void MGProcessDomainWatchdog ( PMG_CLIENT pmgClient ) { int task; DebugEntry(MGProcessDomainWatchdog); ValidateMGClient(pmgClient); // // Call FLO to check each user attachment for delinquency // if (g_mgAttachCount > 0) { for (task = MGTASK_FIRST; task < MGTASK_MAX; task++) { if (g_amgClients[task].userAttached) { FLO_CheckUsers(&(g_amgClients[task])); } } // // Continue periodic messages - but only if there are some users. // // TRACE_OUT(("Continue watchdog")); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, MG_TIMER_PERIOD, NET_MG_WATCHDOG, 0, 0); } else { TRACE_OUT(("Don't continue Watchdog timer")); } DebugExitVOID(MGProcessDomainWatchdog); } // // FLO_UserTerm // void FLO_UserTerm(PMG_CLIENT pmgClient) { UINT i; UINT cStreams; DebugEntry(FLO_UserTerm); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); cStreams = pmgClient->flo.numStreams; // // Stop flow control on all channels. We scan the list of streams and // if flow control is active on a stream then we stop it. // for (i = 0; i < cStreams; i++) { // // Check that the stream is flow controlled. // if (pmgClient->flo.pStrData[i] != NULL) { // // End control on this controlled stream. // FLOStreamEndControl(pmgClient, i); } } DebugExitVOID(FLO_UserTerm); } // // FLO_StartControl // void FLO_StartControl ( PMG_CLIENT pmgClient, NET_CHANNEL_ID channel, UINT priority, UINT backlog, UINT maxBytesOutstanding ) { UINT rc = 0; PFLO_STREAM_DATA pStr; UINT i; UINT stream; DebugEntry(FLO_StartControl); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); ASSERT(priority != NET_TOP_PRIORITY); // // Flow control is on by default. // // // Check to see if the channel is already flow controlled. If it is // then we just exit. // stream = FLOGetStream(pmgClient, channel, priority, &pStr); if (stream != FLO_NOT_CONTROLLED) { ValidateFLOStr(pStr); TRACE_OUT(("Stream %u is already controlled (0x%08x:%u)", stream, channel, priority)); DC_QUIT; } // // If we already have hit the stream limit for this app then give up. // for (i = 0; i < FLO_MAX_STREAMS; i++) { if ((pmgClient->flo.pStrData[i]) == NULL) { break; } } if (i == FLO_MAX_STREAMS) { ERROR_OUT(("Too many streams defined already")); DC_QUIT; } TRACE_OUT(("This is stream %u", i)); // // Allocate memory for our stream data. Hang the pointer off floHandle // - this should be returned to us on all subsequent API calls. // pStr = new FLO_STREAM_DATA; if (!pStr) { WARNING_OUT(("FLO_StartControl failed; out of memory")); DC_QUIT; } ZeroMemory(pStr, sizeof(*pStr)); // // Store the channel and priorities for this stream. // SET_STAMP(pStr, FLOSTR); pStr->channel = channel; pStr->priority = priority; pStr->backlog = backlog; if (maxBytesOutstanding == 0) { maxBytesOutstanding = FLO_MAX_STREAMSIZE; } pStr->DC_ABSMaxBytesInPipe = maxBytesOutstanding; pStr->maxBytesInPipe = FLO_INIT_STREAMSIZE; if (pStr->maxBytesInPipe > maxBytesOutstanding) { pStr->maxBytesInPipe = maxBytesOutstanding; } // // Set the initial stream bytesAllocated to 0. // pStr->bytesAllocated = 0; // // Ping needed immediately. // pStr->pingNeeded = TRUE; pStr->pingTime = FLO_INIT_PINGTIME; pStr->nextPingTime = GetTickCount(); // // Initialize the users base pointers. // COM_BasedListInit(&(pStr->users)); // // Hang the stream CB off the base control block. // pmgClient->flo.pStrData[i] = pStr; if (i >= pmgClient->flo.numStreams) { pmgClient->flo.numStreams++; } TRACE_OUT(("Flow control started, stream %u, (0x%08x:%u)", i, channel, priority)); DC_EXIT_POINT: DebugExitVOID(FLO_StartControl); } // // FLO_EndControl // void FLO_EndControl ( PMG_CLIENT pmgClient, NET_CHANNEL_ID channel, UINT priority ) { UINT stream; PFLO_STREAM_DATA pStr; DebugEntry(FLO_EndControl); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); ASSERT(priority != NET_TOP_PRIORITY); // // Convert channel and stream into priority. // stream = FLOGetStream(pmgClient, channel, priority, &pStr); // // The stream is not controlled so we just trace and quit. // if (stream == FLO_NOT_CONTROLLED) { WARNING_OUT(("Uncontrolled stream channel 0x%08x priority %u", channel, priority)); DC_QUIT; } // // Call the internal FLOStreamEndControl to end flow control on a // given stream. // ValidateFLOStr(pStr); FLOStreamEndControl(pmgClient, stream); DC_EXIT_POINT: DebugExitVOID(FLO_EndControl); } // // FLO_AllocSend // UINT FLO_AllocSend ( PMG_CLIENT pmgClient, UINT priority, NET_CHANNEL_ID channel, UINT size, PFLO_STREAM_DATA * ppStr ) { UINT stream; UINT curtime; PFLO_STREAM_DATA pStr; BOOL denyAlloc = FALSE; BOOL doPing = FALSE; UINT rc = 0; DebugEntry(FLO_AllocSend); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); ASSERT(priority != NET_TOP_PRIORITY); // // Convert channel and stream into priority // stream = FLOGetStream(pmgClient, channel, priority, ppStr); pStr = *ppStr; // // For non-controlled streams just send the data // if (stream == FLO_NOT_CONTROLLED) { TRACE_OUT(("Send %u bytes on uncontrolled channel/pri (0x%08x:%u)", size, channel, priority)); DC_QUIT; } // // Get the current tick count. // curtime = GetTickCount(); // // Check whether this request is permitted. We must allow one packet // beyond the specified limit to avoid problems determining when we // have started rejecting requests and also to avoid situations where a // single request exceeds the total pipe size. // // If we have not yet received a pong then we limit the amount of // allocated buffer space to below FLO_MAX_PRE_FC_ALLOC. However this // data can be sent immediately so the overall throughput is still // relatively high. In this way we minimize the amount of data held in // the glue layer to a maximum of FLO_MAX_PRE_FC_ALLOC if there are no // remote users. // ValidateFLOStr(pStr); if (!pStr->gotPong) { // // Flag that a ping is required. // pStr->pingNeeded = TRUE; if (curtime > pStr->nextPingTime) { doPing = TRUE; } // // We haven't got a pong yet (i.e. FC is non-operational) so we // need to limit the maximum amount of data held in flow control to // FLO_MAX_PRE_FC_ALLOC. // if (pStr->bytesAllocated > FLO_MAX_PRE_FC_ALLOC) { denyAlloc = TRUE; TRACE_OUT(("Max allocation of %u bytes exceeded (currently %u)", FLO_MAX_PRE_FC_ALLOC, pStr->bytesAllocated)); DC_QUIT; } pStr->bytesInPipe += size; pStr->bytesAllocated += size; TRACE_OUT(( "Alloc of %u succeeded: bytesAlloc %u, bytesInPipe %u" " (0x%08x:%u)", size, pStr->bytesAllocated, pStr->bytesInPipe, pStr->channel, pStr->priority)); DC_QUIT; } if (pStr->bytesInPipe < pStr->maxBytesInPipe) { // // Check to see if a ping is required and if so send it now. // if ((pStr->pingNeeded) && (curtime > pStr->nextPingTime)) { doPing = TRUE; } pStr->bytesInPipe += size; pStr->bytesAllocated += size; TRACE_OUT(("Stream %u - alloc %u (InPipe:MaxInPipe %u:%u)", stream, size, pStr->bytesInPipe, pStr->maxBytesInPipe)); DC_QUIT; } // // If we get here then we cannot currently allocate any buffers so deny // the allocation. Simulate back pressure with NET_OUT_OF_RESOURCE. // We also flag that a "wake up" event is required to get the app to // send more data. // denyAlloc = TRUE; pStr->eventNeeded = TRUE; pStr->curDenialTime = pStr->lastPingTime; // // We are not allowed to apply back pressure unless we can guarantee // that we will wake up the app later on. This is dependent upon our // receiving a pong later. But if there is no ping outstanding // (because we have allocated all our buffer allowance within the ping // delay time) then we should first send a ping to trigger the wake up. // If this fails then our watchdog will finally wake us up. // if (pStr->pingNeeded) { doPing = TRUE; } DC_EXIT_POINT: // // Check to see if we should deny the buffer allocation. // if (denyAlloc) { rc = NET_RC_MGC_TOO_MUCH_IN_USE; TRACE_OUT(("Denying buffer request on stream %u InPipe %u Alloc %u", stream, pStr->bytesInPipe, pStr->bytesAllocated)); } if (doPing) { // // A ping is required so send it now. // FLOPing(pmgClient, stream, curtime); } DebugExitDWORD(FLO_AllocSend, rc); return(rc); } // // FLO_ReallocSend // void FLO_ReallocSend ( PMG_CLIENT pmgClient, PFLO_STREAM_DATA pStr, UINT size ) { DebugEntry(FLO_ReallocSend); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); // // For non-controlled streams there is nothing to do so just exit. // if (pStr == NULL) { TRACE_OUT(("Realloc data on uncontrolled channel")); DC_QUIT; } // // Perform a quick sanity check. // ValidateFLOStr(pStr); if (size > pStr->bytesInPipe) { ERROR_OUT(("Realloc of %u makes bytesInPipe (%u) neg (0x%08x:%u)", size, pStr->bytesInPipe, pStr->channel, pStr->priority)); DC_QUIT; } // // Add the length not sent back into the pool. // pStr->bytesInPipe -= size; TRACE_OUT(("Realloc %u FC bytes (bytesInPipe is now %u) (0x%08x:%u)", size, pStr->bytesInPipe, pStr->channel, pStr->priority)); DC_EXIT_POINT: // // Every time that we call FLO_ReallocSend we also want to call // FLO_DecrementAlloc (but not vice-versa) so call it now. // FLO_DecrementAlloc(pStr, size); DebugExitVOID(FLO_ReallocSend); } // // FLO_DecrementAlloc // void FLO_DecrementAlloc ( PFLO_STREAM_DATA pStr, UINT size ) { DebugEntry(FLO_DecrementAlloc); // // For non-controlled streams there is nothing to do so just exit. // if (pStr == NULL) { TRACE_OUT(("Decrement bytesAllocated on uncontrolled channel")); DC_QUIT; } // // Perform a quick sanity check. // ValidateFLOStr(pStr); if (size > pStr->bytesAllocated) { ERROR_OUT(("Dec of %u makes bytesAllocated (%u) neg (0x%08x:%u)", size, pStr->bytesAllocated, pStr->channel, pStr->priority)); DC_QUIT; } // // Update the count of the data held in the glue for this stream. // pStr->bytesAllocated -= size; TRACE_OUT(("Clearing %u alloc bytes (bytesAlloc is now %u) (0x%08x:%u)", size, pStr->bytesAllocated, pStr->channel, pStr->priority)); DC_EXIT_POINT: DebugExitVOID(FLO_DecrementAlloc); } // // FLO_CheckUsers // void FLO_CheckUsers(PMG_CLIENT pmgClient) { PFLO_USER pFloUser; PBASEDLIST nextUser; int waited; BYTE stream; UINT curtime; PFLO_STREAM_DATA pStr; DebugEntry(FLO_CheckUsers); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); curtime = GetTickCount(); // // Check users of each stream // for (stream = 0; stream < pmgClient->flo.numStreams; stream++) { if (pmgClient->flo.pStrData[stream] == NULL) { continue; } pStr = pmgClient->flo.pStrData[stream]; ValidateFLOStr(pStr); // // Check whether we have waited long enough and need to reset the // wait counters. We only wait a certain time before resetting all // our counts. What has happened is that someone has left the call // and we have been waiting for their pong. // // We detect the outage by checking against nextPingTime which, as // well as being set to the earliest time we can send a ping is // also updated to the current time as each pong comes in so we can // use it as a measure of the time since the last repsonse from any // user of the stream. // // To avoid false outages caused by new joiners or transient large // buffer situations each user is required to send a pong at the // rate of MAX_WAIT_TIME/2. They do this by just sending a // duplicate pong if they have not yet got the ping they need to // to pong. // if ((pStr->eventNeeded) && (!pStr->pingNeeded)) { TRACE_OUT(("Checking for valid back pressure on stream %u", stream)); // // Note that if there are no remote users then we should reset // the flags regardless. We get into this state when we first // start an app because OBMAN sends data before the app has // joined the channel at the other end. // waited = curtime - pStr->nextPingTime; if (waited > FLO_MAX_WAIT_TIME) { TRACE_OUT(("Stream %u - Waited for %d, resetting counter", stream, waited)); pStr->bytesInPipe = 0; pStr->pingNeeded = TRUE; pStr->nextPingTime = curtime; pStr->gotPong = FALSE; // // Remove outdated records from our user queue // pFloUser = (PFLO_USER)COM_BasedNextListField(&(pStr->users)); while (&(pFloUser->list) != &(pStr->users)) { ValidateFLOUser(pFloUser); // // Address the follow on record before we free the // current // nextUser = COM_BasedNextListField(&(pFloUser->list)); // // Free the current record, if necessary // if (pFloUser->lastPongRcvd != pStr->pingValue) { // // Remove from the list // TRACE_OUT(("Freeing FLO_USER 0x%08x ID 0x%08x", pFloUser, pFloUser->userID)); COM_BasedListRemove(&(pFloUser->list)); delete pFloUser; } else { // // At least one user still out there so keep flow // control active or else we would suddenly send // out a burst of data that might flood them // pStr->gotPong = TRUE; } // // Move on to the next record in the list // pFloUser = (PFLO_USER)nextUser; } // // We have previously rejected an application request so we // had better call back now // if (pmgClient->flo.callBack != NULL) { (*(pmgClient->flo.callBack))(pmgClient, FLO_WAKEUP, pStr->priority, pStr->maxBytesInPipe); } pStr->eventNeeded = FALSE; } } } DebugExitVOID(FLO_CheckUsers); } // // FLO_ReceivedPacket // void FLO_ReceivedPacket ( PMG_CLIENT pmgClient, PTSHR_FLO_CONTROL pPkt ) { BOOL canPing = TRUE; PFLO_USER pFloUser; BOOL userFound = FALSE; UINT stream; UINT curtime; PFLO_STREAM_DATA pStr; UINT callbackType = 0; int latency; UINT throughput; DebugEntry(FLO_ReceivedPacket); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); stream = pPkt->stream; ASSERT(stream < FLO_MAX_STREAMS); pStr = pmgClient->flo.pStrData[stream]; // // If the stream CB has been freed up already then we can ignore any // flow information pertaining to it. // if (pStr == NULL) { TRACE_OUT(("Found a null stream pointer for stream %u", stream)); DC_QUIT; } ValidateFLOStr(pStr); curtime = GetTickCount(); // // First we must locate the user for this ping/pong/pang // Also, while we are doing it we can check to see if it is a pong and // if so whether it is the last pong we need // pFloUser = (PFLO_USER)COM_BasedNextListField(&(pStr->users)); while (&(pFloUser->list) != &(pStr->users)) { ValidateFLOUser(pFloUser); if (pFloUser->userID == pPkt->userID) { userFound = TRUE; // // We have got a match so set up the last pong value // Accumulate pong stats for query // if (pPkt->packetType == PACKET_TYPE_PONG) { pFloUser->lastPongRcvd = pPkt->pingPongID; pFloUser->gotPong = TRUE; pFloUser->numPongs++; pFloUser->pongDelay += curtime - pStr->lastPingTime; } else { break; } } // // So, is it the final pong - are there any users with different // pong required entries? // Note that if the user has never sent us a pong then we don't // reference their lastPongRcvd field at this stage. // if (pPkt->packetType == PACKET_TYPE_PONG) { if (pFloUser->gotPong && (pFloUser->lastPongRcvd != pStr->pingValue)) { TRACE_OUT(("%u,%u - Entry 0x%08x has different ping id %u", stream, pFloUser->userID, pFloUser, pFloUser->lastPongRcvd)); canPing = FALSE; } } pFloUser = (PFLO_USER)COM_BasedNextListField(&(pFloUser->list)); } // // If this is a new User then add them to the list // if (!userFound) { pFloUser = FLOAddUser(pPkt->userID, pStr); // // If this is a pong then we can set up the lastpong as well // if ((pFloUser != NULL) && (pPkt->packetType == PACKET_TYPE_PONG)) { pFloUser->lastPongRcvd = pPkt->pingPongID; } } // // Now perform the actual packet specific processing // switch (pPkt->packetType) { // // PING // // If this is a ping packet then just flag we must send a pong. If // we failed to alloc a user CB then just ignore the ping and they // will continue in blissful ignorance of our presence // case PACKET_TYPE_PING: { TRACE_OUT(("%u,%u - PING %u received", stream, pPkt->userID, pPkt->pingPongID)); ValidateFLOUser(pFloUser); pFloUser->sendPongID = pPkt->pingPongID; if (pFloUser->rxPackets < FLO_MAX_RCV_PACKETS) { FLOPong(pmgClient, stream, pFloUser->userID, pPkt->pingPongID); pFloUser->sentPongTime = curtime; } else { TRACE_OUT(("Receive backlog - just flagging pong needed")); pFloUser->pongNeeded = TRUE; } } break; // // PONG // // Flag we have got a pong from any user so we should start // applying send flow control to this stream now (Within the stream // we achieve per user granularity by ignoring those users that // have never ponged when we inspect the stream byte count.) // case PACKET_TYPE_PONG: { pStr->gotPong = TRUE; // // Keep a note that we are receiving messages on this stream by // moving nextPing on (but only if we have passed it) // if (curtime > pStr->nextPingTime) { pStr->nextPingTime = curtime; } // // Update the user entry and schedule a ping if necessary // TRACE_OUT(("%u,%u - PONG %u received", stream, pPkt->userID, pPkt->pingPongID)); // // Check for readiness to send another ping This may be because // this is the first users pong, in which case we should also send // another ping when ready // if (canPing) { TRACE_OUT(("%u - PING scheduled, pipe was %d", stream, pStr->bytesInPipe)); // // Reset byte count and ping readiness flag // pStr->bytesInPipe = 0; pStr->pingNeeded = TRUE; // // Adjust the buffer size limit based on our current throughput // // If we hit the back pressure point and yet we are ahead of // the target backlog then we should increase the buffer size // to avoid constraining the pipe. If we have already // increased the buffer size to our maximum value then try // decreasing the tick delay. If we are already ticking at the // max rate then we are going as fast as we can. If we make // either of these adjustments then allow the next ping to flow // immediately so that we can ramp up as fast as possible to // LAN bandwidths. // // We dont need to do the decrease buffer checks if we have not // gone into back pressure during the last pong cycle // if (pStr->eventNeeded) { TRACE_OUT(("We were in a back pressure situation")); callbackType = FLO_WAKEUP; TRACE_OUT(("Backlog %u denial delta %d ping delta %d", pStr->backlog, curtime-pStr->lastDenialTime, curtime-pStr->lastPingTime)); // // The next is a little complex. // // If the turnaround of this ping pong is significantly // less than our target then open the pipe up. But we must // adjust to allow for the ping being sent at a quiet // period, which we do by remembering when each ping is // sent and, if we encounter a backlog situation, storing // that ping time for future reference // // So the equation for latency is // // Pongtime-previous backlogged ping time // // The previous ping time is the that we sent prior to the // last back pressure situation so there are two times in // the control block, one for the last Ping time and one // for the last but one ping time. // if ((int)(pStr->backlog/2 - curtime + pStr->lastDenialTime) > 0) { // // We are coping easily so increase the buffer to pump // more data through. Predict the new buffer size // based on the latency for the current backlog so that // we don't artificially constrain the app. We do this // by taking the observed latency, decrementing by a // small factor to allow for the latency we might // observe over the fastest possible link and then // calculating the connection throughput. // // latency = curtime - lastDenialTime - fudge(100mS) // amount sent = maxBytesInPipe (because we we were // backed up) // throughput = amount sent/latency (bytes/millisec) // New buffer = throughput * target latency // if (pStr->maxBytesInPipe < pStr->DC_ABSMaxBytesInPipe) { latency = (curtime - pStr->lastDenialTime - 30); if (latency <= 0) { latency = 1; } throughput = (pStr->maxBytesInPipe*8)/latency; pStr->maxBytesInPipe = (throughput * pStr->backlog)/8; TRACE_OUT(("Potential maxbytes of %d", pStr->maxBytesInPipe)); if (pStr->maxBytesInPipe > pStr->DC_ABSMaxBytesInPipe) { pStr->maxBytesInPipe = pStr->DC_ABSMaxBytesInPipe; } TRACE_OUT(( "Modified buffer maxBytesInPipe up to %u " "(0x%08x:%u)", pStr->maxBytesInPipe, pStr->channel, pStr->priority)); callbackType = FLO_BUFFERMOD; } else { // // We have hit our maximum allowed pipe size but // are still backlogged and yet pings are going // through acceptably. // // Our first action is to try reducing the ping // time thus increasing out throughput. // // If we have already decreased the ping time to // its minimum then we cannot do anything else. It // is possible that the application parameters // should be changed to increase the permissible // throughput so log an alert to suggest this. // however there are situations (input management) // where we want some back pressure in order to // prevent excessive cpu loading at the recipient. // // To increase the throughput either // // - Increase the maximum size of the stream. The // disadvantage of this is that a low badwidth // joiner may suddenly see a lot of high // bandwidth data in the pipe. However this // is the preferred solution in general, as // it avoids having the pipe flooded with pings. // // - Reduce the target latency. This is a little // dangerous because the latency is composed of // the pre-queued data and the network turnaround // time and if the network turnaround time // approaches the target latency then the flow // control will simply close the pipe right down // irrespective of the achievable throughput. // pStr->maxBytesInPipe = pStr->DC_ABSMaxBytesInPipe; pStr->pingTime = pStr->pingTime/2; if (pStr->pingTime < FLO_MIN_PINGTIME) { pStr->pingTime = FLO_MIN_PINGTIME; } TRACE_OUT(( "Hit DC_ABS max - reduce ping time to %u", pStr->pingTime)); } // // Allow the ping just scheduled to flow immediately // pStr->nextPingTime = curtime; } pStr->eventNeeded = FALSE; } // // If we have exceeded our target latency at all then throttle // back // if ((int)(pStr->backlog - curtime + pStr->lastPingTime) < 0) { pStr->maxBytesInPipe /= 2; if (pStr->maxBytesInPipe < FLO_MIN_STREAMSIZE) { pStr->maxBytesInPipe = FLO_MIN_STREAMSIZE; } pStr->pingTime = pStr->pingTime * 2; if (pStr->pingTime > FLO_INIT_PINGTIME) { pStr->pingTime = FLO_INIT_PINGTIME; } TRACE_OUT(( "Mod buffer maxBytesInPipe down to %u, ping to %u " "(0x%08x:%u)", pStr->maxBytesInPipe, pStr->pingTime, pStr->channel, pStr->priority)); callbackType = FLO_BUFFERMOD; } // // Now make athe callback if callbackType has been set // if ((callbackType != 0) && (pmgClient->flo.callBack != NULL)) { (pmgClient->flo.callBack)(pmgClient, callbackType, pStr->priority, pStr->maxBytesInPipe); } } } break; // // PANG // // Remove the user and continue // case PACKET_TYPE_PANG: { TRACE_OUT(("%u,%u - PANG received, removing user", stream, pPkt->userID)); // // Remove from the list // ValidateFLOUser(pFloUser); TRACE_OUT(("Freeing FLO_USER 0x%08x ID 0x%08x", pFloUser, pFloUser->userID)); COM_BasedListRemove(&(pFloUser->list)); delete pFloUser; // // If we are currently waiting then generate an event for the // app to get it moving again // if ((pStr->eventNeeded) && (pmgClient->flo.callBack != NULL)) { TRACE_OUT(("Waking up the app because user has left")); (*(pmgClient->flo.callBack))(pmgClient, FLO_WAKEUP, pStr->priority, pStr->maxBytesInPipe); pStr->eventNeeded = FALSE; } } break; // // UNKNOWN // // Just trace alert and press on // default: { WARNING_OUT(("Invalid packet type 0x%08x", pPkt->packetType)); } break; } DC_EXIT_POINT: DebugExitVOID(FLO_ReceivedPacket); } // // FLO_AllocReceive // void FLO_AllocReceive ( PMG_CLIENT pmgClient, UINT priority, NET_CHANNEL_ID channel, UINT userID ) { UINT stream; PFLO_USER pFloUser; BOOL userFound = FALSE; PFLO_STREAM_DATA pStr; UINT curtime; DebugEntry(FLO_AllocReceive); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); ASSERT(priority != NET_TOP_PRIORITY); // // Convert channel and priority into stream // stream = FLOGetStream(pmgClient, channel, priority, &pStr); // // Only process controlled streams // if (stream == FLO_NOT_CONTROLLED) { DC_QUIT; } // // First we must locate the user // ValidateFLOStr(pStr); COM_BasedListFind(LIST_FIND_FROM_FIRST, &(pStr->users), (void**)&pFloUser, FIELD_OFFSET(FLO_USER, list), FIELD_OFFSET(FLO_USER, userID), (DWORD)userID, FIELD_SIZE(FLO_USER, userID)); // // SFR6101: If this is a new User then add them to the list // if (pFloUser == NULL) { TRACE_OUT(("Message from user 0x%08x who is not flow controlled", userID)); pFloUser = FLOAddUser(userID, pStr); } // // If we failed to allocate a usr CB then just ignore for now // if (pFloUser != NULL) { ValidateFLOUser(pFloUser); // // Add in the new receive packet usage // pFloUser->rxPackets++; TRACE_OUT(("Num outstanding receives on stream %u now %u", stream, pFloUser->rxPackets)); // // Now check that we have not got some kind of creep // if (pFloUser->rxPackets > FLO_MAX_RCV_PKTS_CREEP) { WARNING_OUT(("Creep? Stream %u has %u unacked rcv pkts", stream, pFloUser->rxPackets)); } // // Finally check to see that we are responding OK to this person // curtime = GetTickCount(); if ((pFloUser->pongNeeded) && (curtime - pFloUser->sentPongTime > (FLO_MAX_WAIT_TIME/4))) { TRACE_OUT(("Send keepalive pong")); FLOPong(pmgClient, stream, pFloUser->userID, pFloUser->sendPongID); pFloUser->sentPongTime = curtime; } } DC_EXIT_POINT: DebugExitVOID(FLO_AllocReceive); } // // FLO_FreeReceive // void FLO_FreeReceive ( PMG_CLIENT pmgClient, NET_PRIORITY priority, NET_CHANNEL_ID channel, UINT userID ) { UINT stream; PFLO_USER pFloUser; PFLO_STREAM_DATA pStr; BOOL userFound = FALSE; DebugEntry(FLO_FreeReceive); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); ASSERT(priority != NET_TOP_PRIORITY); // // Convert channel and priority into stream // stream = FLOGetStream(pmgClient, channel, priority, &pStr); // // Only process controlled streams // if (stream != FLO_NOT_CONTROLLED) { ValidateFLOStr(pStr); // // First we must locate the user // pFloUser = (PFLO_USER)COM_BasedNextListField(&(pStr->users)); while (&(pFloUser->list) != &(pStr->users)) { ValidateFLOUser(pFloUser); if (pFloUser->userID == userID) { userFound = TRUE; break; } pFloUser = (PFLO_USER)COM_BasedNextListField(&(pFloUser->list)); } // // If we do not find the user record then two things may have // happened. // - They have joined the channel and immediately sent data // - They were removed as being delinquent and are now sending // data again // - We failed to add them to our user list // Try and allocate the user entry now // (This will start tracking receive buffer space, but this user // will not participate in our send flow control until we receive // a pong from them and set "gotpong" in their FLO_USER CB.) // if (!userFound) { pFloUser = FLOAddUser(userID, pStr); } if (pFloUser != NULL) { ValidateFLOUser(pFloUser); // // Check that we have not got some kind of creep // if (pFloUser->rxPackets == 0) { WARNING_OUT(("Freed too many buffers for user 0x%08x on str %u", userID, stream)); } else { pFloUser->rxPackets--; TRACE_OUT(("Num outstanding receives now %u", pFloUser->rxPackets)); } // // Now we must Pong if there is a pong pending and we have // moved below the high water mark // if ((pFloUser->pongNeeded) && (pFloUser->rxPackets < FLO_MAX_RCV_PACKETS)) { FLOPong(pmgClient, stream, pFloUser->userID, pFloUser->sendPongID); pFloUser->pongNeeded = FALSE; pFloUser->sentPongTime = GetTickCount(); } } } DebugExitVOID(FLO_FreeReceive); } // // FLOPong() // void FLOPong ( PMG_CLIENT pmgClient, UINT stream, UINT userID, UINT pongID ) { PTSHR_FLO_CONTROL pFlo; PMG_BUFFER pmgBuffer; UINT rc; DebugEntry(FLOPong); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); rc = MGNewDataBuffer(pmgClient, MG_TX_PONG, sizeof(TSHR_FLO_CONTROL) + sizeof(MG_INT_PKT_HEADER), &pmgBuffer); if (rc != 0) { WARNING_OUT(("MGNewDataBuffer failed in FLOPong")); DC_QUIT; } pFlo = (PTSHR_FLO_CONTROL)pmgBuffer->pDataBuffer; pmgBuffer->pPktHeader->header.pktLength = TSHR_PKT_FLOW; // // Set up pong contents // pFlo->packetType = PACKET_TYPE_PONG; pFlo->userID = pmgClient->userIDMCS; pFlo->stream = (BYTE)stream; pFlo->pingPongID = (BYTE)pongID; pmgBuffer->channelId = (ChannelID)userID; pmgBuffer->priority = MG_PRIORITY_HIGHEST; // // Now decouple the send request. Note that we must put the pong at // the back of the request queue even though we want it to flow at // high priority because otherwise there are certain circumstances // where we get pong reversal due to receipt of multiple pings // TRACE_OUT(("Inserting pong message 0x%08x at head of pending chain", pmgBuffer)); COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); TRACE_OUT(("%u,0x%08x - PONG %u scheduled", pFlo->stream, pmgBuffer->channelId, pFlo->pingPongID)); DC_EXIT_POINT: DebugExitVOID(FLOPong); } // // FLOPing() // void FLOPing ( PMG_CLIENT pmgClient, UINT stream, UINT curtime ) { PFLO_STREAM_DATA pStr; PMG_BUFFER pmgBuffer; PTSHR_FLO_CONTROL pFlo; UINT rc; DebugEntry(FLOPing); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); ASSERT(stream < FLO_MAX_STREAMS); pStr = pmgClient->flo.pStrData[stream]; ValidateFLOStr(pStr); rc = MGNewDataBuffer(pmgClient, MG_TX_PING, sizeof(TSHR_FLO_CONTROL)+sizeof(MG_INT_PKT_HEADER), &pmgBuffer); if (rc != 0) { WARNING_OUT(("MGNewDataBuffer failed in FLOPing")); DC_QUIT; } // // Flag ping not needed to avoid serialization problems across the // sendmessage! // pStr->pingNeeded = FALSE; pFlo = (PTSHR_FLO_CONTROL)pmgBuffer->pDataBuffer; pmgBuffer->pPktHeader->header.pktLength = TSHR_PKT_FLOW; // // Set up ping contents // pFlo->packetType = PACKET_TYPE_PING; pFlo->userID = pmgClient->userIDMCS; pFlo->stream = (BYTE)stream; pmgBuffer->channelId = (ChannelID)pStr->channel; pmgBuffer->priority = (NET_PRIORITY)pStr->priority; // // Generate the next ping value to be used // pFlo->pingPongID = (BYTE)(pStr->pingValue + 1); // // Now decouple the send request // TRACE_OUT(("Inserting ping message 0x%08x into pending chain", pmgBuffer)); COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); // // Update flow control variables // pStr->pingValue = ((pStr->pingValue + 1) & 0xFF); pStr->lastPingTime = curtime; pStr->nextPingTime = curtime + pStr->pingTime; pStr->lastDenialTime = pStr->curDenialTime; TRACE_OUT(("%u - PING %u sched, next in %u mS (0x%08x:%u)", pFlo->stream, pStr->pingValue, pStr->pingTime, pStr->channel, pStr->priority)); DC_EXIT_POINT: DebugExitVOID(FLOPing); } // // FLOPang() // void FLOPang ( PMG_CLIENT pmgClient, UINT stream, UINT userID ) { PMG_BUFFER pmgBuffer; PTSHR_FLO_CONTROL pFlo; UINT rc; DebugEntry(FLOPang); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); rc = MGNewDataBuffer(pmgClient, MG_TX_PANG, sizeof(TSHR_FLO_CONTROL) + sizeof(MG_INT_PKT_HEADER), &pmgBuffer); if (rc != 0) { WARNING_OUT(("MGNewDataBuffer failed in FLOPang")); DC_QUIT; } pFlo = (PTSHR_FLO_CONTROL)pmgBuffer->pDataBuffer; pmgBuffer->pPktHeader->header.pktLength = TSHR_PKT_FLOW; // // Set up pang contents // pFlo->packetType = PACKET_TYPE_PANG; pFlo->userID = pmgClient->userIDMCS; pFlo->stream = (BYTE)stream; pFlo->pingPongID = 0; pmgBuffer->channelId = (ChannelID)userID; pmgBuffer->priority = MG_PRIORITY_HIGHEST; // // Now decouple the send request // TRACE_OUT(("Inserting pang message 0x%08x into pending chain", pmgBuffer)); COM_BasedListInsertBefore(&(pmgClient->pendChain), &(pmgBuffer->pendChain)); UT_PostEvent(pmgClient->putTask, pmgClient->putTask, NO_DELAY, NET_MG_SCHEDULE, 0, 0); DC_EXIT_POINT: DebugExitVOID(FLOPang); } // // FLOGetStream() // UINT FLOGetStream ( PMG_CLIENT pmgClient, NET_CHANNEL_ID channel, UINT priority, PFLO_STREAM_DATA * ppStr ) { UINT i; UINT cStreams; DebugEntry(FLOGetStream); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); ASSERT(priority != NET_TOP_PRIORITY); cStreams = pmgClient->flo.numStreams; ASSERT(cStreams <= FLO_MAX_STREAMS); // // Scan the list of streams for a match. // for (i = 0; i < cStreams; i++) { // // Check to ensure that this is a valid stream. // if (pmgClient->flo.pStrData[i] == NULL) { continue; } ValidateFLOStr(pmgClient->flo.pStrData[i]); // // If the channel and priority match then we have found the stream. // if ((pmgClient->flo.pStrData[i]->channel == channel) && (pmgClient->flo.pStrData[i]->priority == priority)) { break; } } // // If we hit the end of the list then return FLO_NOT_CONTROLLED. // if (i == cStreams) { i = FLO_NOT_CONTROLLED; *ppStr = NULL; TRACE_OUT(("Uncontrolled stream (0x%08x:%u)", channel, priority)); } else { *ppStr = pmgClient->flo.pStrData[i]; TRACE_OUT(("Controlled stream %u (0x%08x:%u)", i, channel, priority)); } DebugExitDWORD(FLOGetStream, i); return(i); } // // FUNCTION: FLOAddUser // // DESCRIPTION: // // Add a new remote user entry for a stream. // // PARAMETERS: // // userID - ID of the new user (single member channel ID) // pStr - pointer to the stream to receive the new user. // // RETURNS: Nothing // // PFLO_USER FLOAddUser ( UINT userID, PFLO_STREAM_DATA pStr ) { PFLO_USER pFloUser; DebugEntry(FLOAddUser); ValidateFLOStr(pStr); // // Allocate memory for the new user entry // pFloUser = new FLO_USER; if (!pFloUser) { WARNING_OUT(("FLOAddUser failed; out of memory")); } else { ZeroMemory(pFloUser, sizeof(*pFloUser)); SET_STAMP(pFloUser, FLOUSER); // // Set up the new record // TRACE_OUT(("UserID %u - New user, CB = 0x%08x", userID, pFloUser)); pFloUser->userID = (TSHR_UINT16)userID; // // Add the new User to the end of the list // COM_BasedListInsertBefore(&(pStr->users), &(pFloUser->list)); } DebugExitVOID(FLOAddUser); return(pFloUser); } // // FLO_RemoveUser() // void FLO_RemoveUser ( PMG_CLIENT pmgClient, UINT userID ) { PFLO_USER pFloUser; PBASEDLIST nextUser; UINT stream; UINT cStreams; PFLO_STREAM_DATA pStr; DebugEntry(FLO_RemoveUser); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); cStreams = pmgClient->flo.numStreams; ASSERT(cStreams <= FLO_MAX_STREAMS); // // Check each stream // for (stream = 0; stream < cStreams; stream++) { if (pmgClient->flo.pStrData[stream] == NULL) { continue; } pStr = pmgClient->flo.pStrData[stream]; ValidateFLOStr(pStr); // // Remove this user from the queue, if present // pFloUser = (PFLO_USER)COM_BasedNextListField(&(pStr->users)); while (&(pFloUser->list) != &(pStr->users)) { ValidateFLOUser(pFloUser); // // Address the follow on record before we free the current // nextUser = COM_BasedNextListField(&(pFloUser->list)); // // Free the current record, if necessary // if (pFloUser->userID == userID) { // // Remove from the list // TRACE_OUT(("Freeing FLO_USER 0x%08x ID 0x%08x", pFloUser, pFloUser->userID)); COM_BasedListRemove(&(pFloUser->list)); delete pFloUser; TRACE_OUT(("Stream %u - resetting due to user disappearance", stream)); ValidateFLOStr(pStr); pStr->bytesInPipe = 0; pStr->pingNeeded = TRUE; pStr->nextPingTime = GetTickCount(); pStr->gotPong = FALSE; pStr->eventNeeded = FALSE; break; } // // Move on to the next record in the list // pFloUser = (PFLO_USER)nextUser; } // // Now wake the app again for this stream // if (pmgClient->flo.callBack != NULL) { (*(pmgClient->flo.callBack))(pmgClient, FLO_WAKEUP, pStr->priority, pStr->maxBytesInPipe); } } DebugExitVOID(FLO_RemoveUser); } // // FLOStreamEndControl() // void FLOStreamEndControl ( PMG_CLIENT pmgClient, UINT stream ) { PFLO_USER pFloUser; PFLO_STREAM_DATA pStr; PMG_BUFFER pmgBuffer; DebugEntry(FLOStreamEndControl); ValidateMGClient(pmgClient); ASSERT(pmgClient->userAttached); // // Convert the stream id into a stream pointer. // ASSERT(stream < FLO_MAX_STREAMS); pStr = pmgClient->flo.pStrData[stream]; ValidateFLOStr(pStr); // // Trace out that we are about to end flow control. // TRACE_OUT(("Flow control about to end, stream %u, (0x%08x:%u)", stream, pStr->channel, pStr->priority)); // // First check to see if there are any outstanding buffer CBs with // pStr set to this stream and reset pStr to null. We need to do this // as we may then try to dereference pStr when we come to send these // buffers. // pmgBuffer = (PMG_BUFFER)COM_BasedListFirst(&(pmgClient->pendChain), FIELD_OFFSET(MG_BUFFER, pendChain)); while (pmgBuffer != NULL) { ValidateMGBuffer(pmgBuffer); if (pmgBuffer->type == MG_TX_BUFFER) { // // Set the stream pointer to NULL. // pmgBuffer->pStr = NULL; TRACE_OUT(("Nulling stream pointer in bufferCB: (0x%08x:%u)", pStr->channel, pStr->priority)); } pmgBuffer = (PMG_BUFFER)COM_BasedListNext(&(pmgClient->pendChain), pmgBuffer, FIELD_OFFSET(MG_BUFFER, pendChain)); } // // Now free up the list of users. // pFloUser = (PFLO_USER)COM_BasedListFirst(&(pStr->users), FIELD_OFFSET(FLO_USER, list)); while (pFloUser != NULL) { ValidateFLOUser(pFloUser); // // First send the remote user a "pang" to tell them we are not // interested in their data any more. // FLOPang(pmgClient, stream, pFloUser->userID); // // Remove the remote user from the list. // TRACE_OUT(("Freeing FLO_USER 0x%08x ID 0x%08x", pFloUser, pFloUser->userID)); COM_BasedListRemove(&(pFloUser->list)); delete pFloUser; // // Now get the next user in the list. // ValidateFLOStr(pStr); pFloUser = (PFLO_USER)COM_BasedListFirst(&(pStr->users), FIELD_OFFSET(FLO_USER, list)); } // // Free the stream data. // ASSERT(pStr == pmgClient->flo.pStrData[stream]); TRACE_OUT(("Freeing FLO_STREAM_DATA 0x%08x", pStr)); delete pStr; pmgClient->flo.pStrData[stream] = NULL; // // Adjust numStreams (if required) // if (stream == (pmgClient->flo.numStreams - 1)) { while ((pmgClient->flo.numStreams > 0) && (pmgClient->flo.pStrData[pmgClient->flo.numStreams - 1] == NULL)) { pmgClient->flo.numStreams--; } TRACE_OUT(("numStreams %u", pmgClient->flo.numStreams)); } DebugExitVOID(FLOStreamEndControl); } // // MGNewCorrelator() // // Gets a new correlator for events to a particular MGC client // void MGNewCorrelator ( PMG_CLIENT pmgClient, WORD * pCorrelator ) { ValidateMGClient(pmgClient); pmgClient->joinNextCorr++; if (pmgClient->joinNextCorr == 0) { pmgClient->joinNextCorr++; } *pCorrelator = pmgClient->joinNextCorr; }