bool IocpTransmitStrategy::PostSend() { auto& socketBuffer = m_transmitSocket.TheSocketBuffer(); const auto sendLength = socketBuffer.PrepareSendPlan(); if (sendLength < 1) { m_sendOperation.SetBusy(false); return true; } const auto count = socketBuffer.SetupSendIov(m_sendOperation.m_iov); DWORD bytesSent = 0; const auto& transmitSockId = m_transmitSocket.GetSockId(); const auto ret = WSASend(transmitSockId , m_sendOperation.m_iov , count , &bytesSent , 0 , &m_sendOperation.m_overlapped , NULL); if (ret != 0) { const auto error = WSAGetLastError(); if (error != ERROR_IO_PENDING) { HandleFailure(&m_sendOperation, 0, error); return false; } } return true; }
bool IocpTransmitStrategy::PostRecv() { auto& socketBuffer = m_transmitSocket.TheSocketBuffer(); const auto recvLength = socketBuffer.PrepareRecvPlan(); const auto count = socketBuffer.SetupRecvIov(m_recvOperation.m_iov); DWORD bytesRecvd = 0; DWORD flags = 0; const auto& transmitSockId = m_transmitSocket.GetSockId(); const auto ret = WSARecv(transmitSockId , m_recvOperation.m_iov , count , &bytesRecvd , &flags , &m_recvOperation.m_overlapped , NULL); if (ret != 0) { const auto error = WSAGetLastError(); if (error != ERROR_IO_PENDING) { HandleFailure(&m_recvOperation, 0, error); return false; } } return true; }
void mcurlconn::HandleError(CURL *easy, long httpcode, CURLcode res, std::unique_ptr<mcurlconn> &&this_owner) { errorcount++; MCC_HTTPERRTYPE err = MCC_RETRY; if (res == CURLE_OK) { //http error, not socket error err = CheckHTTPErrType(httpcode); } if (errorcount >= 3 && err < MCC_FAILED) { err = MCC_FAILED; } if (err == MCC_RETRY && mcflags & MCF::NORETRY) { err = MCC_FAILED; } LogSocketErrorMessage(this, easy, httpcode, res, err); switch (err) { case MCC_RETRY: sm.RetryConn(std::move(this_owner)); break; case MCC_FAILED: HandleFailure(httpcode, res, std::move(this_owner)); break; } }
void Process() { #ifndef USING_GLES2 if (g_Config.iRewindFlipFrequency != 0 && gpuStats.numFlips != 0) CheckRewindState(); #endif if (!needsProcess) return; needsProcess = false; if (!__KernelIsRunning()) { ERROR_LOG(COMMON, "Savestate failure: Unable to load without kernel, this should never happen."); return; } std::vector<Operation> operations = Flush(); SaveStart state; for (size_t i = 0, n = operations.size(); i < n; ++i) { Operation &op = operations[i]; CChunkFileReader::Error result; bool callbackResult; std::string reason; I18NCategory *s = GetI18NCategory("Screen"); // I couldn't stand the inconsistency. But trying not to break old lang files. const char *i18nLoadFailure = s->T("Load savestate failed", ""); const char *i18nSaveFailure = s->T("Save State Failed", ""); if (strlen(i18nLoadFailure) == 0) i18nLoadFailure = s->T("Failed to load state"); if (strlen(i18nSaveFailure) == 0) i18nSaveFailure = s->T("Failed to save state"); switch (op.type) { case SAVESTATE_LOAD: INFO_LOG(COMMON, "Loading state from %s", op.filename.c_str()); result = CChunkFileReader::Load(op.filename, REVISION, PPSSPP_GIT_VERSION, state, &reason); if (result == CChunkFileReader::ERROR_NONE) { osm.Show(s->T("Loaded State"), 2.0); callbackResult = true; } else if (result == CChunkFileReader::ERROR_BROKEN_STATE) { HandleFailure(); osm.Show(i18nLoadFailure, 2.0); ERROR_LOG(COMMON, "Load state failure: %s", reason.c_str()); callbackResult = false; } else { osm.Show(s->T(reason.c_str(), i18nLoadFailure), 2.0); callbackResult = false; } break; case SAVESTATE_SAVE: INFO_LOG(COMMON, "Saving state to %s", op.filename.c_str()); result = CChunkFileReader::Save(op.filename, REVISION, PPSSPP_GIT_VERSION, state); if (result == CChunkFileReader::ERROR_NONE) { osm.Show(s->T("Saved State"), 2.0); callbackResult = true; } else if (result == CChunkFileReader::ERROR_BROKEN_STATE) { HandleFailure(); osm.Show(i18nSaveFailure, 2.0); ERROR_LOG(COMMON, "Save state failure: %s", reason.c_str()); callbackResult = false; } else { osm.Show(i18nSaveFailure, 2.0); callbackResult = false; } break; case SAVESTATE_VERIFY: INFO_LOG(COMMON, "Verifying save state system"); callbackResult = CChunkFileReader::Verify(state) == CChunkFileReader::ERROR_NONE; break; case SAVESTATE_REWIND: INFO_LOG(COMMON, "Rewinding to recent savestate snapshot"); result = rewindStates.Restore(); if (result == CChunkFileReader::ERROR_NONE) { osm.Show(s->T("Loaded State"), 2.0); callbackResult = true; } else if (result == CChunkFileReader::ERROR_BROKEN_STATE) { // Cripes. Good news is, we might have more. Let's try those too, better than a reset. if (HandleFailure()) { // Well, we did rewind, even if too much... osm.Show(s->T("Loaded State"), 2.0); callbackResult = true; } else { osm.Show(i18nLoadFailure, 2.0); callbackResult = false; } } else { osm.Show(i18nLoadFailure, 2.0); callbackResult = false; } break; default: ERROR_LOG(COMMON, "Savestate failure: unknown operation type %d", op.type); callbackResult = false; break; } if (op.callback) op.callback(callbackResult, op.cbUserData); } }
MojErr SmtpSendMailCommand::HandleResponse(const std::string& line) { try { switch (m_write_state) { case State_SendMailFrom: { MojLogInfo(m_log, "MAIL FROM command response"); if (m_status == Status_Ok) { MojLogInfo(m_log, "MAIL FROM command +OK"); m_toIdx = 0; if(m_toIdx < m_toAddress.size()) { m_write_state = State_SendRcptTo; } else { m_error.errorCode = MailError::BAD_RECIPIENTS; // Error out if for some reason there is no recipient. m_error.errorOnEmail = true; m_error.errorOnAccount = false; m_error.internalError = "Error setting forward address"; m_write_state = State_SendErrorRset; } WriteEmail(); } else { MojLogInfo(m_log, "MAIL FROM command -ERR"); m_error = GetStandardError(); m_error.internalError = "Error setting reverse address"; m_write_state = State_SendErrorRset; WriteEmail(); } break; } case State_SendRcptTo: { MojLogInfo(m_log, "RCPT TO command response"); if (m_status == Status_Ok) { m_toIdx++; if (m_toIdx < m_toAddress.size()) { MojLogInfo(m_log, "RCPT TO command +OK, more to come"); m_write_state = State_SendRcptTo; } else { MojLogInfo(m_log, "RCPT TO command +OK, done"); m_write_state = State_SendData; } WriteEmail(); } else { MojLogInfo(m_log, "RCPT TO command -ERR"); m_error = GetStandardError(); if (m_status == 550) { // general failure means bad recipient m_error.errorCode = MailError::BAD_RECIPIENTS; m_error.errorOnEmail = true; m_error.errorOnAccount = false; } // 452 is technically a non-fatal error that says no more recipients can be // added, on the expectation we'll go and send our mail, and then send a // copy to the next batch of recipients. Instead, we'll treat this as a // permanent error, and not send it to anyone (by sending RSET, and not DATA). // 552 is (as the spec says) an old and occasionally seen typo of 452. if (m_status == 452 || m_status == 552) { m_error.errorCode = MailError::BAD_RECIPIENTS; // too many, actually m_error.errorOnEmail = true; m_error.errorOnAccount = false; } m_error.internalError = "Error setting forward address"; m_write_state = State_SendErrorRset; WriteEmail(); } break; } case State_SendData: { MojLogInfo(m_log, "DATA command response"); if (m_status == Status_Ok) { MojLogInfo(m_log, "DATA command +OK"); m_write_state = State_SendBody; WriteEmail(); } else { MojLogInfo(m_log, "DATA command -ERR"); m_error = GetStandardError(); m_error.internalError = "Error starting mail body"; m_write_state = State_SendErrorRset; WriteEmail(); } break; } case State_SendBody: { MojLogInfo(m_log, "BODY command response"); if (m_status == Status_Ok) { MojLogInfo(m_log, "BODY command +OK"); m_write_state = State_SendRset; WriteEmail(); } else { MojLogInfo(m_log, "BODY command -ERR"); m_error = GetStandardError(); m_error.internalError = "Error completing send"; m_write_state = State_SendErrorRset; WriteEmail(); } break; } case State_SendRset: { MojLogInfo(m_log, "RSET command response"); if (m_status == Status_Ok) { MojLogInfo(m_log, "RSET command +OK"); SendDone(); } else { MojLogInfo(m_log, "RSET command -ERR"); m_error = GetStandardError(); m_error.internalError = "Error resetting"; HandleSmtpError(m_error); } break; } case State_SendErrorRset: { // Handle an error response after clearing an error: if we had one bad e-mail, we want to // be sure we are in a good state before going to the next e-mail. HandleSmtpError(m_error); break; } default: { MojLogInfo(m_log, "Unknown write mail state %d in SmtpSendMailCommand::HandleResponse", m_write_state); HandleFailure("bad HandleResponse state"); break; } } } catch(const std::exception& e) { HandleException(e, __func__, __FILE__, __LINE__); } catch(...) { HandleUnknownException(); } return MojErrNone; }
void SmtpSendMailCommand::WriteEmail() { try { switch (m_write_state) { case State_SendMailFrom: { MojLogInfo(m_log, "Sending MAIL FROM command"); //MojLogInfo(m_log, "From address is %s\n", m_email.GetFrom()->GetAddress().c_str()); std::string userCommand = std::string(FROM_COMMAND_STRING) + " <" + m_email.GetFrom()->GetAddress() + ">"; // If SIZE extension is present, place message size on FROM line so that the server // can potentially reject it now, instead of after we transmit the data. if (m_session.GetSizeMax()) { char buf[64]; memset(buf, '\0', sizeof(buf)); snprintf(buf, sizeof(buf)-1, " SIZE=%d", m_bytesLeft); userCommand += buf; MojLogInfo(m_log, "...with SIZE"); } SendCommand(userCommand, SmtpSession::TIMEOUT_MAIL_FROM); break; } case State_SendRcptTo: { MojLogInfo(m_log, "Sending RCPT TO command"); //MojLogInfo(m_log, "To address is %s\n", m_toAddress[m_toIdx].c_str()); std::string userCommand = std::string(TO_COMMAND_STRING) + " <" + m_toAddress[m_toIdx] + ">"; SendCommand(userCommand, SmtpSession::TIMEOUT_RCPT_TO); break; } case State_SendData: { MojLogInfo(m_log, "Sending DATA command"); std::string userCommand = DATA_COMMAND_STRING; SendCommand(userCommand, SmtpSession::TIMEOUT_DATA_INITIATION); break; } case State_SendBody: { MojLogInfo(m_log, "Sending BODY"); assert(m_emailWriter.get()); OutputStreamPtr outputStream = m_session.GetConnection()->GetOutputStream(); // Wrap the mail writer in a CRLF fixer stream, which ensures that the stream ends with // CRLF, so we can safely write out a DOT to end the body, without the risk that it'll end // up on the end of a body line. m_crlfTerminator.reset( new CRLFTerminatedOutputStream(outputStream) ); // connect mail writer m_emailWriter->SetOutputStream(m_crlfTerminator); // FIXME: set up timeout on writing email body blocks //m_emailWriter->SetDataTimeout(SmtpSession::TIMEOUT_DATA_BLOCK); // Set up flow control AsyncOutputStream* asyncOs = dynamic_cast<AsyncOutputStream*>(outputStream.get()); if(asyncOs) { m_flowControl.reset(new AsyncFlowControl(m_emailWriter, asyncOs)); } // Send the DOT after the body is written. m_emailWriter->WriteEmail(m_writeDoneSlot); break; } case State_SendRset: { MojLogInfo(m_log, "Sending RSET"); std::string userCommand = RESET_COMMAND_STRING; SendCommand(userCommand); break; } case State_SendErrorRset: { MojLogInfo(m_log, "Sending RSET after error"); std::string userCommand = RESET_COMMAND_STRING; SendCommand(userCommand); break; } default: { MojLogInfo(m_log, "Unknown SmtpSendMailCommand::WriteEmail write mail state %d", m_write_state); HandleFailure("bad WriteEmail state"); break; } } } catch(const std::exception& e) { HandleException(e, __func__, __FILE__, __LINE__); } catch(...) { HandleUnknownException(); } }
void CMArray2DCommand::HandleFailure() { HandleFailure(1, ""); itsDirector->UpdateNext(); }
/// Called to do non-default actions when assertion fails. void operator ()() { HandleFailure(); }
void Process() { #ifndef MOBILE_DEVICE if (g_Config.iRewindFlipFrequency != 0 && gpuStats.numFlips != 0) CheckRewindState(); #endif if (!needsProcess) return; needsProcess = false; if (!__KernelIsRunning()) { ERROR_LOG(COMMON, "Savestate failure: Unable to load without kernel, this should never happen."); return; } std::vector<Operation> operations = Flush(); SaveStart state; for (size_t i = 0, n = operations.size(); i < n; ++i) { Operation &op = operations[i]; CChunkFileReader::Error result; bool callbackResult; std::string callbackMessage; std::string reason; I18NCategory *sc = GetI18NCategory("Screen"); const char *i18nLoadFailure = sc->T("Load savestate failed", ""); const char *i18nSaveFailure = sc->T("Save State Failed", ""); if (strlen(i18nLoadFailure) == 0) i18nLoadFailure = sc->T("Failed to load state"); if (strlen(i18nSaveFailure) == 0) i18nSaveFailure = sc->T("Failed to save state"); switch (op.type) { case SAVESTATE_LOAD: INFO_LOG(COMMON, "Loading state from %s", op.filename.c_str()); result = CChunkFileReader::Load(op.filename, PPSSPP_GIT_VERSION, state, &reason); if (result == CChunkFileReader::ERROR_NONE) { callbackMessage = sc->T("Loaded State"); callbackResult = true; hasLoadedState = true; } else if (result == CChunkFileReader::ERROR_BROKEN_STATE) { HandleFailure(); callbackMessage = i18nLoadFailure; ERROR_LOG(COMMON, "Load state failure: %s", reason.c_str()); callbackResult = false; } else { callbackMessage = sc->T(reason.c_str(), i18nLoadFailure); callbackResult = false; } break; case SAVESTATE_SAVE: INFO_LOG(COMMON, "Saving state to %s", op.filename.c_str()); result = CChunkFileReader::Save(op.filename, g_paramSFO.GetValueString("TITLE"), PPSSPP_GIT_VERSION, state); if (result == CChunkFileReader::ERROR_NONE) { callbackMessage = sc->T("Saved State"); callbackResult = true; } else if (result == CChunkFileReader::ERROR_BROKEN_STATE) { HandleFailure(); callbackMessage = i18nSaveFailure; ERROR_LOG(COMMON, "Save state failure: %s", reason.c_str()); callbackResult = false; } else { callbackMessage = i18nSaveFailure; callbackResult = false; } break; case SAVESTATE_VERIFY: callbackResult = CChunkFileReader::Verify(state) == CChunkFileReader::ERROR_NONE; if (callbackResult) { INFO_LOG(COMMON, "Verified save state system"); } else { ERROR_LOG(COMMON, "Save state system verification failed"); } break; case SAVESTATE_REWIND: INFO_LOG(COMMON, "Rewinding to recent savestate snapshot"); result = rewindStates.Restore(); if (result == CChunkFileReader::ERROR_NONE) { callbackMessage = sc->T("Loaded State"); callbackResult = true; hasLoadedState = true; } else if (result == CChunkFileReader::ERROR_BROKEN_STATE) { // Cripes. Good news is, we might have more. Let's try those too, better than a reset. if (HandleFailure()) { // Well, we did rewind, even if too much... callbackMessage = sc->T("Loaded State"); callbackResult = true; hasLoadedState = true; } else { callbackMessage = i18nLoadFailure; callbackResult = false; } } else { callbackMessage = i18nLoadFailure; callbackResult = false; } break; case SAVESTATE_SAVE_SCREENSHOT: callbackResult = TakeGameScreenshot(op.filename.c_str(), SCREENSHOT_JPG, SCREENSHOT_RENDER); if (!callbackResult) { ERROR_LOG(COMMON, "Failed to take a screenshot for the savestate! %s", op.filename.c_str()); } break; default: ERROR_LOG(COMMON, "Savestate failure: unknown operation type %d", op.type); callbackResult = false; break; } if (op.callback) op.callback(callbackResult, callbackMessage, op.cbUserData); } if (operations.size()) { // Avoid triggering frame skipping due to slowdown __DisplaySetWasPaused(); } }