void TdsDatabaseLayer::SetError(int nCode, const wxString& strMessage) { SetErrorCode(TranslateErrorCode(nCode)); SetErrorMessage(strMessage); // We really don't want to throw the exception here since it removes // the ability of the calling code to cleanup any memory usage //wxPrintf(_("TdsDatabaseLayer SetError() throwing exception\n")); //ThrowDatabaseException(); }
/***************************************************************************** ** Procedure: CJTPhone::OnSetHookswitch ** ** Arguments: 'pReq' - Request object representing this phone request ** 'lpBuff' - Our CEventBlock* pointer ** ** Returns: void ** ** Description: This function manages the TSPI_phoneSetHookSwitch processing ** for this service provider. ** *****************************************************************************/ bool CJTPhone::OnSetHookswitch(RTSetHookswitch* pRequest, LPCVOID lpBuff) { // Cast our pointer back to an event block const CEventBlock* pBlock = static_cast<const CEventBlock*>(lpBuff); // If we are in the initial state (i.e. this request has not been processed // before by any other thread). Then move the packet to the waiting state so // other threads will not interfere with other events or timers. This is // guarenteed to be thread-safe and atomic. if (pRequest->EnterState(STATE_INITIAL, STATE_WAITING)) { // Validate the state passed if (pRequest->GetHookswitchState() == PHONEHOOKSWITCHMODE_ONHOOK || pRequest->GetHookswitchState() == PHONEHOOKSWITCHMODE_MIC) CompleteRequest(pRequest, PHONEERR_INVALHOOKSWITCHMODE); // Send the command to the switch else GetDeviceInfo()->DRV_SetHookswitch(this, (pRequest->GetHookswitchState() == PHONEHOOKSWITCHMODE_MICSPEAKER) ? 1 : 0); } // If we are in the waiting stage (2) then see if we received an event from the // switch (vs. an interval timer) and if that event was an ACK/NAK in response // to the command we issued. else if (pRequest->GetState() == STATE_WAITING && pBlock != NULL) { // If this is a command response for our SETGAIN, then manage it. const CPECommand* peCommand = dynamic_cast<const CPECommand*>(pBlock->GetElement(CPBXElement::Command)); const CPEErrorCode* pidError = dynamic_cast<const CPEErrorCode*>(pBlock->GetElement(CPBXElement::ErrorCode)); if (pBlock->GetEventType() == CEventBlock::CommandResponse && peCommand->GetCommand() == CPECommand::SetHookSwitch && pidError != NULL) { // Complete the request with the appropriate error code. TranslateErrorCode(pRequest, pidError->GetError()); return true; } } // Check to see if our request has exceeded the limit for processing. If // so, tell TAPI that the request failed and delete the request. if (pRequest->GetState() == STATE_WAITING && (pRequest->GetStateTime()+REQUEST_TIMEOUT) < GetTickCount()) CompleteRequest(pRequest, PHONEERR_OPERATIONFAILED); // Let the request fall through to the unsolicited handler where we // set all the options concerning the newly found call. return false; }// CJTPhone::OnSetHookswitch
void FEditorAnalytics::ReportEvent(FString EventName, FString PlatformName, bool bHasCode, int32 ErrorCode, TArray<FAnalyticsEventAttribute>& ExtraParams) { if( FEngineAnalytics::IsAvailable() ) { const UGeneralProjectSettings& ProjectSettings = *GetDefault<UGeneralProjectSettings>(); TArray<FAnalyticsEventAttribute> ParamArray; ParamArray.Add(FAnalyticsEventAttribute(TEXT("ProjectID"), ProjectSettings.ProjectID.ToString())); ParamArray.Add(FAnalyticsEventAttribute(TEXT("Platform"), PlatformName)); ParamArray.Add(FAnalyticsEventAttribute(TEXT("ProjectType"), bHasCode ? TEXT("C++ Code") : TEXT("Content Only"))); ParamArray.Add(FAnalyticsEventAttribute(TEXT("ErrorCode"), ErrorCode)); const FString ErrorMessage = TranslateErrorCode(ErrorCode); ParamArray.Add(FAnalyticsEventAttribute(TEXT("ErrorName"), ErrorMessage)); ParamArray.Append(ExtraParams); FEngineAnalytics::GetProvider().RecordEvent( EventName, ParamArray ); } }
// Don't use string! (see https://github.com/dolphin-emu/dolphin/pull/3143) s32 WiiSockMan::GetNetErrorCode(s32 ret, const char* caller, bool isRW) { #ifdef _WIN32 s32 errorCode = WSAGetLastError(); #else s32 errorCode = errno; #endif if (ret >= 0) { WiiSockMan::GetInstance().SetLastNetError(ret); return ret; } INFO_LOG(WII_IPC_NET, "%s failed with error %d: %s, ret= %d", caller, errorCode, DecodeError(errorCode), ret); s32 ReturnValue = TranslateErrorCode(errorCode, isRW); WiiSockMan::GetInstance().SetLastNetError(ReturnValue); return ReturnValue; }
/***************************************************************************** ** Procedure: CJTLine::OnSetAgentState ** ** Arguments: 'pReq' - Request object representing this SetAgentState event ** 'lpBuff' - Our CEventBlock* pointer ** ** Returns: void ** ** Description: This function manages the lineSetAgentState processing ** for this service provider. ** *****************************************************************************/ bool CJTLine::OnSetAgentState(RTSetAgentState* pRequest, LPCVOID lpBuff) { // Cast our pointer back to an event block const CEventBlock* pBlock = static_cast<const CEventBlock*>(lpBuff); CTSPIAddressInfo* pAddress = GetAddress(0); // If we are in the initial state (i.e. this request has not been processed // before by any other thread). Then move the packet to the waiting state so // other threads will not interfere with other events or timers. This is // guarenteed to be thread-safe and atomic. if (pRequest->EnterState(STATE_INITIAL, STATE_WAITING)) { // Fail if there is not an agent logged on at this address. if (pAddress->GetCurrentAgentGroupCount() == 0) { CompleteRequest(pRequest, LINEERR_INVALAGENTID); return true; } // Determine whether we are setting the current state or the next // state based on the current status of the address in question. If we // have active calls running on the line then we cannot adjust the current // state - it is done by the ACD. DWORD dwState = (pAddress->GetAddressStatus()->dwNumActiveCalls > 0) ? pRequest->GetNextAgentState() : pRequest->GetAgentState(); // Convert the state to the proper ACD status character TCHAR chState = _T('U'); switch (dwState) { case LINEAGENTSTATE_READY: chState = _T('R'); break; case LINEAGENTSTATE_WORKINGAFTERCALL: chState = _T('W'); break; case LINEAGENTSTATE_NOTREADY: chState = _T('N'); break; case LINEAGENTSTATE_LOGGEDOFF: chState = _T('S'); break; } // If we have a valid state then send it to the switch. if (chState != _T('U')) { const TAgentGroup* pGroup = pAddress->GetCurrentAgentGroup(0); _TSP_ASSERTE(pGroup != NULL); GetDeviceInfo()->DRV_SetAgentState(this, pGroup->strName, chState); } else CompleteRequest(pRequest, LINEERR_INVALAGENTSTATE); } // If we are in the waiting stage (2) then see if we received an event from the // switch (vs. an interval timer) and if that event was an ACK/NAK in response // to the command we issued. else if (pRequest->GetState() == STATE_WAITING && pBlock != NULL) { // If this is a command response for our RELEASECALL, then manage it. const CPECommand* peCommand = dynamic_cast<const CPECommand*>(pBlock->GetElement(CPBXElement::Command)); const CPEErrorCode* pidError = dynamic_cast<const CPEErrorCode*>(pBlock->GetElement(CPBXElement::ErrorCode)); if (pBlock->GetEventType() == CEventBlock::CommandResponse && peCommand->GetCommand() == CPECommand::AgentState && pidError != NULL) { // Complete the request with the appropriate error code. TranslateErrorCode(pRequest, pidError->GetError()); return true; } } // Check to see if our request has exceeded the limit for processing. If // so, tell TAPI that the request failed and delete the request. if (pRequest->GetState() == STATE_WAITING && (pRequest->GetStateTime()+REQUEST_TIMEOUT) < GetTickCount()) CompleteRequest(pRequest, LINEERR_OPERATIONFAILED); // Let the request fall through to the unsolicited handler. return false; }// CJTLine::OnSetAgentState
/***************************************************************************** ** Procedure: CJTLine::OnSetAgentGroup ** ** Arguments: 'pReq' - Request object representing this SetAgentGroup event ** 'lpBuff' - Our CEventBlock* pointer ** ** Returns: void ** ** Description: This function manages the lineSetAgentGroup processing ** for this service provider. ** *****************************************************************************/ bool CJTLine::OnSetAgentGroup(RTSetAgentGroup* pRequest, LPCVOID lpBuff) { // Cast our pointer back to an event block const CEventBlock* pBlock = static_cast<const CEventBlock*>(lpBuff); CTSPIAddressInfo* pAddress = GetAddress(0); // If we are in the initial state (i.e. this request has not been processed // before by any other thread). Then move the packet to the waiting state so // other threads will not interfere with other events or timers. This is // guarenteed to be thread-safe and atomic. if (pRequest->EnterState(STATE_INITIAL, STATE_WAITING)) { // Collect the parameters. The agent-id is in the first // group entry position, the password is in the second and any groups // the agent wants access to are in subsequent entries. // // Note this is a deviation from the TAPI specification since it has no // facility for providing a userid/password for logon which our switch // requires. This coded "standard" has been used as a workaround in many // commercial TSPs currently in use. TString strName = (pRequest->GetCount() > 0) ? pRequest->GetGroup(0)->strName : _T(""); TString strPassword = (pRequest->GetCount() > 1) ? pRequest->GetGroup(1)->strName : _T(""); // Gather the group entries TDWordArray arrGroups; for (unsigned int i = 2; i < pRequest->GetCount(); i++) arrGroups.push_back(pRequest->GetGroup(i)->GroupID.dwGroupID1); // If this is a logoff request then handle it seperately from the // other requests since it is an agent state change to the switch. if (pRequest->GetCount() == 0) { // Fail if there is no agent logged on at this address. if (pAddress->GetCurrentAgentGroupCount() == 0) { CompleteRequest(pRequest, LINEERR_INVALAGENTGROUP); return false; } GetDeviceInfo()->DRV_SetAgentState(this, strName, _T('S')); } else { // Validate the parameters - if there is no agent id then fail this // request since we cannot log on or change our agent groups without it. if (strName.empty()) { const TAgentGroup* pGroup = pAddress->GetCurrentAgentGroup(0); if (pGroup != NULL) strName = pGroup->strName; else CompleteRequest(pRequest, LINEERR_INVALAGENTID); } // Or if too many agent groups are passed (max is 2) else if (arrGroups.size() > 2) CompleteRequest(pRequest, LINEERR_INVALPARAM); // Perform the logon if we haven't failed with an error yet if (!pRequest->HaveSentResponse()) { DWORD dwGroup1 = (arrGroups.size() > 0) ? arrGroups[0] : 0; DWORD dwGroup2 = (arrGroups.size() > 1) ? arrGroups[1] : 0; if ((dwGroup1 > 0 && !GetDeviceInfo()->DoesAgentGroupExist(dwGroup1)) || (dwGroup2 > 0 && !GetDeviceInfo()->DoesAgentGroupExist(dwGroup2))) CompleteRequest(pRequest, LINEERR_INVALAGENTGROUP); else GetDeviceInfo()->DRV_Logon(this, strName, strPassword, dwGroup1, dwGroup2); } } } // If we are in the waiting stage (2) then see if we received an event from the // switch (vs. an interval timer) and if that event was an ACK/NAK in response // to the command we issued. else if (pRequest->GetState() == STATE_WAITING && pBlock != NULL) { // If this is a command response for our RELEASECALL, then manage it. const CPECommand* peCommand = dynamic_cast<const CPECommand*>(pBlock->GetElement(CPBXElement::Command)); const CPEErrorCode* pidError = dynamic_cast<const CPEErrorCode*>(pBlock->GetElement(CPBXElement::ErrorCode)); if (pBlock->GetEventType() == CEventBlock::CommandResponse && (peCommand->GetCommand() == CPECommand::AgentLogon || peCommand->GetCommand() == CPECommand::AgentState) && pidError != NULL) { // Complete the request with the appropriate error code. TranslateErrorCode(pRequest, pidError->GetError()); return true; } } // Check to see if our request has exceeded the limit for processing. If // so, tell TAPI that the request failed and delete the request. if (pRequest->GetState() == STATE_WAITING && (pRequest->GetStateTime()+REQUEST_TIMEOUT) < GetTickCount()) CompleteRequest(pRequest, LINEERR_OPERATIONFAILED); // Let the request fall through to the unsolicited handler. return false; }// CJTLine::OnSetAgentGroup
ESocketErrors FSocketSubsystemHTML5::GetLastErrorCode() { return TranslateErrorCode(0); }
ESocketErrors FSocketSubsystemBSD::GetLastErrorCode() { return TranslateErrorCode(errno); }
/***************************************************************************** ** Procedure: CJTLine::OnSwapHold ** ** Arguments: 'pReq' - Request object representing this SWAPHOLD event ** 'lpBuff' - Our CEventBlock* pointer ** ** Returns: void ** ** Description: This function manages the TSPI_lineSwapHold processing ** for this service provider. ** *****************************************************************************/ bool CJTLine::OnSwapHold(RTSwapHold* pRequest, LPCVOID lpBuff) { // Cast our pointer back to an event block const CEventBlock* pBlock = static_cast<const CEventBlock*>(lpBuff); CTSPICallAppearance* pActiveCall = pRequest->GetActiveCall(); CTSPICallAppearance* pHeldCall = pRequest->GetHoldingCall(); // If the holding call is a conference call then we are currently building // a conference call and want to swap over to the other party in the conference. // Use the first call in the conference itself. if (pHeldCall->GetCallType() == CTSPICallAppearance::Conference) pHeldCall = dynamic_cast<CTSPIConferenceCall*>(pHeldCall)->GetConferenceCall(0); _TSP_ASSERTE(pHeldCall != NULL); // If we are in the initial state (i.e. this request has not been processed // before by any other thread). Then move the packet to the waiting state so // other threads will not interfere with other events or timers. This is // guarenteed to be thread-safe and atomic. if (pRequest->EnterState(STATE_INITIAL, STATE_WAITING)) GetDeviceInfo()->DRV_HoldCall(this, pActiveCall); // If we are in the waiting stage (2) then see if we received an event from the // switch (vs. an interval timer) and if that event was an ACK/NAK in response // to the command we issued. else if (pRequest->GetState() == STATE_WAITING && pBlock != NULL) { const CPECommand* peCommand = dynamic_cast<const CPECommand*>(pBlock->GetElement(CPBXElement::Command)); const CPEErrorCode* pidError = dynamic_cast<const CPEErrorCode*>(pBlock->GetElement(CPBXElement::ErrorCode)); // Watch for ACK/NAK responses to either a HOLD or RETRIEVE call command if (pBlock->GetEventType() == CEventBlock::CommandResponse && pidError != NULL && (peCommand->GetCommand() == CPECommand::HoldCall || peCommand->GetCommand() == CPECommand::RetrieveCall)) { // If this is an ACK for our HOLDCALL request then retrieve the other call // so that it is now active. if (peCommand->GetCommand() == CPECommand::HoldCall && pidError->GetError() == 0) { // If our held call has a conference owner, then swap it for this new call. DWORD dwCallState = pHeldCall->GetCallState(); if (pHeldCall->GetConferenceOwner()) { // Get the conference owner CTSPIConferenceCall* pConfCall = pHeldCall->GetConferenceOwner(); // Remove the only party from the conference - don't // let the conference break down. pConfCall->RemoveConferenceCall(pHeldCall, false); // Add our new onHold party to the conference. It is still connected // so it is not yet added to the conference array, only setup with // a conference owner. pConfCall->AddToConference(pActiveCall); // Detach the consultation call since it is now attached // through the conference. pActiveCall->DetachCall(); pConfCall->DetachCall(); // Change the state of the original call within the // conference (which should be CONFERENCED) to // onHold so we transition it correctly. pHeldCall->SetCallState(LINECALLSTATE_ONHOLD); } // Change the state of the now holding call to be the state of the // original onHold call itself. We want to preserve the // transfer/conference state. pActiveCall->SetCallState(dwCallState); // Retrieve the held call GetDeviceInfo()->DRV_RetrieveCall(this, pHeldCall); } // If this is an ACK response to our RetrieveCall command then complete // the request and finish connecting up the calls else if (peCommand->GetCommand() == CPECommand::RetrieveCall && pidError->GetError() == 0) { // Re-attach the newly connected call as our consultation call for the conference // so that we will properly monitor it for IDLE. if (pActiveCall->GetConferenceOwner()) { pActiveCall->GetConferenceOwner()->AttachCall(pHeldCall); pHeldCall->AttachCall(pActiveCall->GetConferenceOwner()); pHeldCall->SetCallType(CTSPICallAppearance::Consultant); } CompleteRequest(pRequest, 0); } // Complete the request with the appropriate error code. else TranslateErrorCode(pRequest, pidError->GetError()); return true; } } // Check to see if our request has exceeded the limit for processing. If // so, tell TAPI that the request failed and delete the request. if (pRequest->GetState() == STATE_WAITING && (pRequest->GetStateTime()+REQUEST_TIMEOUT) < GetTickCount()) CompleteRequest(pRequest, LINEERR_OPERATIONFAILED); // Let the request fall through to the unsolicited handler where we // set all the options concerning the newly found call. return false; }// CJTLine::OnSwapHold