void PolicyCallback::clear() { clearRequest(); m_navigationFunction = 0; m_newWindowFunction = 0; m_contentFunction = 0; }
void XMLHttpRequest::handleDidFailGeneric() { clearResponse(); clearRequest(); m_error = true; }
void cIntroState::run() { // If key pressed, forward to main menu sf::Event event; while ( rWindow.pollEvent(event) ) { if ( event.type == sf::Event::KeyPressed ) { swapRequest("menu"); clearRequest(); // tmp: just quit return; } } // If enough time passed, proceed to main menu mTimePassed += mClock.restart(); if ( mTimePassed >= mProceedTimer ) { swapRequest("menu"); return; } // If no need to proceed yet, do the fade-in until complete if ( mTimePassed < mFadeInTimer ) mSprite.setColor(sf::Color(255, 255, 255, mTimePassed.asSeconds() / mFadeInTimer.asSeconds() * 255)); }
void DatabaseQuery::clearRequests() { //enableActions(flag); while (!m_requests.isEmpty()) { clearRequest(m_requests.takeFirst()); } emit requestsCleared(); }
void KQOAuthRequest::initRequest(KQOAuthRequest::RequestType type, const QUrl &requestEndpoint) { Q_D(KQOAuthRequest); if (!requestEndpoint.isValid()) { qWarning() << "Endpoint URL is not valid. Ignoring. This request might not work."; return; } if (type < 0 || type > KQOAuthRequest::AuthorizedRequest) { qWarning() << "Invalid request type. Ignoring. This request might not work."; return; } // Clear the request clearRequest(); // Set smart defaults. d->requestType = type; d->oauthRequestEndpoint = requestEndpoint; d->oauthTimestamp_ = d->oauthTimestamp(); d->oauthNonce_ = d->oauthNonce(); this->setSignatureMethod(KQOAuthRequest::HMAC_SHA1); this->setHttpMethod(KQOAuthRequest::POST); d->oauthVersion = "1.0"; // Currently supports only version 1.0 d->contentType = "application/x-www-form-urlencoded"; }
void XMLHttpRequest::genericError() { clearResponse(); clearRequest(); m_error = true; changeState(DONE); }
void XMLHttpRequest::genericError() { clearResponse(); clearRequest(); m_error = true; // The spec says we should "Synchronously switch the state to DONE." and then "Synchronously dispatch a readystatechange event on the object" // but this does not match Firefox. }
void PolicyCallback::cancel() { clearRequest(); if (m_navigationFunction) m_navigationFunction(m_argument, m_request, m_formState.get(), false); if (m_newWindowFunction) m_newWindowFunction(m_argument, m_request, m_formState.get(), m_frameName, m_navigationAction, false); if (m_contentFunction) m_contentFunction(m_argument, PolicyIgnore); }
void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionCode& ec) { internalAbort(); State previousState = m_state; m_state = UNSENT; m_error = false; m_uploadComplete = false; // clear stuff from possible previous load clearResponse(); clearRequest(); ASSERT(m_state == UNSENT); if (!isValidHTTPToken(method)) { ec = SYNTAX_ERR; return; } if (!isAllowedHTTPMethod(method)) { ec = SECURITY_ERR; return; } if (!scriptExecutionContext()->contentSecurityPolicy()->allowConnectFromSource(url)) { // FIXME: Should this be throwing an exception? ec = SECURITY_ERR; return; } // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated // attempt to discourage synchronous XHR use. responseType is one such piece of functionality. // We'll only disable this functionality for HTTP(S) requests since sync requests for local protocols // such as file: and data: still make sense to allow. if (!async && scriptExecutionContext()->isDocument() && url.protocolIsInHTTPFamily() && m_responseTypeCode != ResponseTypeDefault) { logConsoleError(scriptExecutionContext(), "Synchronous HTTP(S) requests made from the window context cannot have XMLHttpRequest.responseType set."); ec = INVALID_ACCESS_ERR; return; } m_method = uppercaseKnownHTTPMethod(method); m_url = url; m_async = async; ASSERT(!m_loader); // Check previous state to avoid dispatching readyState event // when calling open several times in a row. if (previousState != OPENED) changeState(OPENED); else m_state = OPENED; }
// Currenntly ignoring TextCheckingResult::details but should be handled. See Bug 56368. void SpellChecker::didCheck(int sequence, const Vector<TextCheckingResult>& results) { if (!isValid(sequence)) return; if (!m_requestNode->renderer()) { clearRequest(); return; } int startOffset = 0; PositionIterator start = firstPositionInOrBeforeNode(m_requestNode.get()); for (size_t i = 0; i < results.size(); ++i) { if (results[i].type != TextCheckingTypeSpelling && results[i].type != TextCheckingTypeGrammar) continue; // To avoid moving the position backward, we assume the given results are sorted with // startOffset as the ones returned by [NSSpellChecker requestCheckingOfString:]. ASSERT(startOffset <= results[i].location); if (!forwardIterator(start, results[i].location - startOffset)) break; PositionIterator end = start; if (!forwardIterator(end, results[i].length)) break; // Users or JavaScript applications may change text while a spell-checker checks its // spellings in the background. To avoid adding markers to the words modified by users or // JavaScript applications, retrieve the words in the specified region and compare them with // the original ones. RefPtr<Range> range = Range::create(m_requestNode->document(), start, end); // FIXME: Use textContent() compatible string conversion. String destination = range->text(); String source = m_requestText.substring(results[i].location, results[i].length); if (destination == source) m_requestNode->document()->markers()->addMarker(range.get(), toMarkerType(results[i].type)); startOffset = results[i].location; } clearRequest(); }
void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionCode& ec) { internalAbort(); State previousState = m_state; m_state = UNSENT; m_error = false; #if ENABLE(XHR_RESPONSE_BLOB) m_asBlob = false; #endif m_uploadComplete = false; // clear stuff from possible previous load clearResponse(); clearRequest(); ASSERT(m_state == UNSENT); if (!isValidToken(method)) { ec = SYNTAX_ERR; return; } // Method names are case sensitive. But since Firefox uppercases method names it knows, we'll do the same. String methodUpper(method.upper()); if (methodUpper == "TRACE" || methodUpper == "TRACK" || methodUpper == "CONNECT") { ec = SECURITY_ERR; return; } m_url = url; if (methodUpper == "COPY" || methodUpper == "DELETE" || methodUpper == "GET" || methodUpper == "HEAD" || methodUpper == "INDEX" || methodUpper == "LOCK" || methodUpper == "M-POST" || methodUpper == "MKCOL" || methodUpper == "MOVE" || methodUpper == "OPTIONS" || methodUpper == "POST" || methodUpper == "PROPFIND" || methodUpper == "PROPPATCH" || methodUpper == "PUT" || methodUpper == "UNLOCK") m_method = methodUpper; else m_method = method; m_async = async; ASSERT(!m_loader); // Check previous state to avoid dispatching readyState event // when calling open several times in a row. if (previousState != OPENED) changeState(OPENED); else m_state = OPENED; }
void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionCode& ec) { internalAbort(); State previousState = m_state; m_state = UNSENT; m_error = false; m_responseTypeCode = ResponseTypeDefault; m_uploadComplete = false; // clear stuff from possible previous load clearResponse(); clearRequest(); ASSERT(m_state == UNSENT); if (!isValidHTTPToken(method)) { ec = SYNTAX_ERR; return; } if (!isAllowedHTTPMethod(method)) { ec = SECURITY_ERR; return; } if (!scriptExecutionContext()->contentSecurityPolicy()->allowConnectFromSource(url)) { // FIXME: Should this be throwing an exception? ec = SECURITY_ERR; return; } m_method = uppercaseKnownHTTPMethod(method); m_url = url; m_async = async; ASSERT(!m_loader); // Check previous state to avoid dispatching readyState event // when calling open several times in a row. if (previousState != OPENED) changeState(OPENED); else m_state = OPENED; }
EJ_BIND_FUNCTION(EJBindingHttpRequest, open, ctx, argc, argv) { if (argc < 2) { return NULL; } // Cleanup previous request, if any clearConnection(); clearRequest(); method = JSValueToNSString(ctx, argv[0]); method->retain(); url = JSValueToNSString(ctx, argv[1]); url->retain(); async = argc > 2 ? JSValueToBoolean(ctx, argv[2]) : true; if (argc > 4) { user = JSValueToNSString(ctx, argv[3]); user->retain(); password = JSValueToNSString(ctx, argv[4]); password->retain(); } state = kEJHttpRequestStateOpened; return NULL; }
bool ClearSuspect(SuspectIdentifier suspectId) { Ticket ticket = MessageManager::Instance().StartConversation(IPCSocketFD); ControlMessage clearRequest(CONTROL_CLEAR_SUSPECT_REQUEST); clearRequest.m_suspectAddress = suspectId; if(!MessageManager::Instance().WriteMessage(ticket, &clearRequest)) { LOG(ERROR, "Unable to send CONTROL_CLEAR_SUSPECT_REQUEST to NOVAD" ,""); return false; } Message *reply = MessageManager::Instance().ReadMessage(ticket); if(reply->m_messageType == ERROR_MESSAGE && ((ErrorMessage*)reply)->m_errorType == ERROR_TIMEOUT) { LOG(ERROR, "Timeout error when waiting for message reply", ""); reply->DeleteContents(); delete reply; return false; } if(reply->m_messageType != CONTROL_MESSAGE ) { LOG(ERROR, "Received the wrong kind of reply message", ""); reply->DeleteContents(); delete reply; return false; } ControlMessage *clearReply = (ControlMessage*)reply; if( clearReply->m_controlType != CONTROL_CLEAR_SUSPECT_REPLY ) { LOG(ERROR, "Received the wrong kind of control message", ""); reply->DeleteContents(); delete reply; return false; } bool retSuccess = clearReply->m_success; delete clearReply; return retSuccess; }
bool ClearSuspect(in_addr_t suspectAddress) { Lock lock = MessageManager::Instance().UseSocket(IPCSocketFD); ControlMessage clearRequest(CONTROL_CLEAR_SUSPECT_REQUEST, DIRECTION_TO_NOVAD); clearRequest.m_suspectAddress = suspectAddress; if(!Message::WriteMessage(&clearRequest, IPCSocketFD) ) { //There was an error in sending the message //TODO: Log this fact return false; } Message *reply = Message::ReadMessage(IPCSocketFD, DIRECTION_TO_NOVAD); if(reply->m_messageType == ERROR_MESSAGE && ((ErrorMessage*)reply)->m_errorType == ERROR_TIMEOUT) { LOG(ERROR, "Timeout error when waiting for message reply", ""); delete ((ErrorMessage*)reply); return false; } if(reply->m_messageType != CONTROL_MESSAGE ) { //Received the wrong kind of message delete reply; return false; } ControlMessage *clearReply = (ControlMessage*)reply; if( clearReply->m_controlType != CONTROL_CLEAR_SUSPECT_REPLY ) { //Received the wrong kind of control message delete clearReply; return false; } bool retSuccess = clearReply->m_success; delete clearReply; return retSuccess; }
void XMLHttpRequest::open(const AtomicString& method, const KURL& url, bool async, ExceptionState& exceptionState) { WTF_LOG(Network, "XMLHttpRequest %p open('%s', '%s', %d)", this, method.string().utf8().data(), url.elidedString().utf8().data(), async); if (!internalAbort()) return; State previousState = m_state; m_state = UNSENT; m_error = false; m_uploadComplete = false; // clear stuff from possible previous load clearResponse(); clearRequest(); ASSERT(m_state == UNSENT); if (!isValidHTTPToken(method)) { exceptionState.throwDOMException(SyntaxError, "'" + method + "' is not a valid HTTP method."); return; } if (!isAllowedHTTPMethod(method)) { exceptionState.throwSecurityError("'" + method + "' HTTP method is unsupported."); return; } if (!ContentSecurityPolicy::shouldBypassMainWorld(executionContext()) && !executionContext()->contentSecurityPolicy()->allowConnectToSource(url)) { // We can safely expose the URL to JavaScript, as these checks happen synchronously before redirection. JavaScript receives no new information. exceptionState.throwSecurityError("Refused to connect to '" + url.elidedString() + "' because it violates the document's Content Security Policy."); return; } if (!async && executionContext()->isDocument()) { if (document()->settings() && !document()->settings()->syncXHRInDocumentsEnabled()) { exceptionState.throwDOMException(InvalidAccessError, "Synchronous requests are disabled for this page."); return; } // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated // attempt to discourage synchronous XHR use. responseType is one such piece of functionality. // We'll only disable this functionality for HTTP(S) requests since sync requests for local protocols // such as file: and data: still make sense to allow. if (url.protocolIsInHTTPFamily() && m_responseTypeCode != ResponseTypeDefault) { exceptionState.throwDOMException(InvalidAccessError, "Synchronous HTTP requests from a document must not set a response type."); return; } // Similarly, timeouts are disabled for synchronous requests as well. if (m_timeoutMilliseconds > 0) { exceptionState.throwDOMException(InvalidAccessError, "Synchronous requests must not set a timeout."); return; } } m_method = uppercaseKnownHTTPMethod(method); m_url = url; m_async = async; ASSERT(!m_loader); // Check previous state to avoid dispatching readyState event // when calling open several times in a row. if (previousState != OPENED) changeState(OPENED); else m_state = OPENED; }
void cMenuState::processEvents() { if ( mSelected ) { if ( mStillBlinking > sf::Time::Zero ) // if still blinking, then let's blink! { mMainMenu.setDrawHighlight((mStillBlinking.asMilliseconds()/100) % 2); mStillBlinking -= mClock.restart(); } else // blinking time over, let's actually do stuff! { switch (mAction) { case SAID::clear: { clearRequest(); break; } case SAID::push: { pushRequest(mParam); break; } } } return; } sf::Event event; while (mWindow.pollEvent(event)) { // Close window : exit if (event.type == sf::Event::Closed) { clearRequest(); } if ( event.type == sf::Event::JoystickMoved && event.joystickMove.axis == mJ.UpDownAxis && event.joystickMove.joystickId == mJ.ID) { float jPos = event.joystickMove.position; if ( jPos > gJoyThreshold && !mJoyMoved) { mMainMenu.move_down(); mJoyMoved = true; } if ( jPos < -gJoyThreshold && !mJoyMoved) { mMainMenu.move_up(); mJoyMoved = true; } if ( jPos > -gJoyThreshold && jPos < gJoyThreshold) mJoyMoved = false; } if ( event.type == sf::Event::JoystickButtonPressed && event.joystickButton.joystickId == mJ.ID) { if ( event.joystickButton.button == mJ.Fire ) menuChosen(); if ( event.joystickButton.button == mJ.UpButton ) { mMainMenu.move_up(); } if ( event.joystickButton.button == mJ.DownButton ) { mMainMenu.move_down(); } } if (event.type == sf::Event::KeyPressed) switch (event.key.code) { case sf::Keyboard::Up: { mMainMenu.move_up(); break; } case sf::Keyboard::Down: { mMainMenu.move_down(); break; } case sf::Keyboard::Return: { menuChosen(); break; } } } }
void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionCode& ec) { internalAbort(); State previousState = m_state; m_state = UNSENT; m_error = false; m_uploadComplete = false; // clear stuff from possible previous load clearResponse(); clearRequest(); ASSERT(m_state == UNSENT); if (!isValidHTTPToken(method)) { ec = SYNTAX_ERR; return; } if (!isAllowedHTTPMethod(method)) { ec = SECURITY_ERR; return; } // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved. bool shouldBypassMainWorldContentSecurityPolicy = false; if (scriptExecutionContext()->isDocument()) { Document* document = static_cast<Document*>(scriptExecutionContext()); shouldBypassMainWorldContentSecurityPolicy = document->frame()->script()->shouldBypassMainWorldContentSecurityPolicy(); } if (!shouldBypassMainWorldContentSecurityPolicy && !scriptExecutionContext()->contentSecurityPolicy()->allowConnectToSource(url)) { // FIXME: Should this be throwing an exception? ec = SECURITY_ERR; return; } if (!async && scriptExecutionContext()->isDocument()) { if (document()->settings() && !document()->settings()->syncXHRInDocumentsEnabled()) { logConsoleError(scriptExecutionContext(), "Synchronous XMLHttpRequests are disabled for this page."); ec = INVALID_ACCESS_ERR; return; } // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated // attempt to discourage synchronous XHR use. responseType is one such piece of functionality. // We'll only disable this functionality for HTTP(S) requests since sync requests for local protocols // such as file: and data: still make sense to allow. if (url.protocolIsInHTTPFamily() && m_responseTypeCode != ResponseTypeDefault) { logConsoleError(scriptExecutionContext(), "Synchronous HTTP(S) requests made from the window context cannot have XMLHttpRequest.responseType set."); ec = INVALID_ACCESS_ERR; return; } #if ENABLE(XHR_TIMEOUT) // Similarly, timeouts are disabled for synchronous requests as well. if (m_timeoutMilliseconds > 0) { logConsoleError(scriptExecutionContext(), "Synchronous XMLHttpRequests must not have a timeout value set."); ec = INVALID_ACCESS_ERR; return; } #endif } m_method = uppercaseKnownHTTPMethod(method); m_url = url; m_async = async; ASSERT(!m_loader); // Check previous state to avoid dispatching readyState event // when calling open several times in a row. if (previousState != OPENED) changeState(OPENED); else m_state = OPENED; }
void HttpServerRequest::onReadyRead() { if (priv->timeout) priv->timer.start(priv->timeout); priv->buffer += priv->socket.readAll(); priv->parser.set_buffer(asio::buffer(priv->buffer.data(), priv->buffer.size())); Priv::Signals whatEmit(0); bool is_upgrade = false; while(priv->parser.code() != http::token::code::error_insufficient_data) { switch(priv->parser.symbol()) { case http::token::symbol::error: priv->socket.close(); return; case http::token::symbol::skip: break; case http::token::symbol::method: { clearRequest(); priv->responseOptions = 0; auto value = priv->parser.value<http::token::method>(); QByteArray method(value.data(), value.size()); priv->method = std::move(method); } break; case http::token::symbol::request_target: { auto value = priv->parser.value<http::token::request_target>(); QByteArray url(value.data(), value.size()); priv->url = std::move(url); } break; case http::token::symbol::version: { auto value = priv->parser.value<http::token::version>(); if (value == 0) { priv->httpVersion = HttpVersion::HTTP_1_0; priv->responseOptions |= HttpServerResponse::HTTP_1_0; } else { priv->httpVersion = HttpVersion::HTTP_1_1; priv->responseOptions |= HttpServerResponse::HTTP_1_1; } } break; case http::token::symbol::status_code: qFatal("unreachable"); break; case http::token::symbol::reason_phrase: qFatal("unreachable"); break; case http::token::symbol::field_name: case http::token::symbol::trailer_name: { auto value = priv->parser.value<http::token::field_name>(); priv->lastHeader = QByteArray(value.data(), value.size()); } break; case http::token::symbol::field_value: { auto value = priv->parser.value<http::token::field_value>(); QByteArray header(value.data(), value.size()); priv->headers.insert(priv->lastHeader, std::move(header)); priv->lastHeader.clear(); } break; case http::token::symbol::trailer_value: { auto value = priv->parser.value<http::token::trailer_value>(); QByteArray header(value.data(), value.size()); priv->trailers.insert(priv->lastHeader, std::move(header)); priv->lastHeader.clear(); } break; case http::token::symbol::end_of_headers: { auto it = priv->headers.find("connection"); bool close_found = false; bool keep_alive_found = false; for (;it != priv->headers.end();++it) { auto value = boost::string_view(it->data(), it->size()); http::header_value_any_of(value, [&](boost::string_view v) { if (iequals(v, "close")) close_found = true; if (iequals(v, "keep-alive")) keep_alive_found = true; if (iequals(v, "upgrade")) is_upgrade = true; return false; }); if (close_found) break; } if (!close_found && (priv->httpVersion == HttpVersion::HTTP_1_1 || keep_alive_found)) { priv->responseOptions |= HttpServerResponse::KEEP_ALIVE; } whatEmit = Priv::READY; } break; case http::token::symbol::body_chunk: { auto value = priv->parser.value<http::token::body_chunk>(); priv->body.append(asio::buffer_cast<const char*>(value), asio::buffer_size(value)); whatEmit |= Priv::DATA; } break; case http::token::symbol::end_of_body: break; case http::token::symbol::end_of_message: priv->buffer.remove(0, priv->parser.parsed_count()); priv->parser.set_buffer(asio::buffer(priv->buffer.data(), priv->parser.token_size())); whatEmit |= Priv::END; disconnect(&priv->socket, SIGNAL(readyRead()), this, SLOT(onReadyRead())); break; } priv->parser.next(); } priv->buffer.remove(0, priv->parser.parsed_count()); if (is_upgrade) { disconnect(&priv->socket, SIGNAL(readyRead()), this, SLOT(onReadyRead())); disconnect(&priv->socket, SIGNAL(disconnected()), this, SIGNAL(close())); disconnect(&priv->timer, SIGNAL(timeout()), this, SLOT(onTimeout())); priv->body.swap(priv->buffer); emit upgrade(); return; } if (whatEmit.testFlag(Priv::READY)) { whatEmit &= ~Priv::Signals(Priv::READY); this->disconnect(SIGNAL(data())); this->disconnect(SIGNAL(end())); emit ready(); } if (whatEmit.testFlag(Priv::DATA)) { whatEmit &= ~Priv::Signals(Priv::DATA); emit data(); } if (whatEmit.testFlag(Priv::END)) { whatEmit &= ~Priv::Signals(Priv::END); emit end(); return; } }
void XMLHttpRequest::open(const String& method, const URL& url, bool async, ExceptionCode& ec) { if (!internalAbort()) return; State previousState = m_state; m_state = UNSENT; m_error = false; m_sendFlag = false; m_uploadComplete = false; // clear stuff from possible previous load clearResponse(); clearRequest(); ASSERT(m_state == UNSENT); if (!isValidHTTPToken(method)) { ec = SYNTAX_ERR; return; } if (!isAllowedHTTPMethod(method)) { ec = SECURITY_ERR; return; } if (!async && scriptExecutionContext()->isDocument()) { if (document()->settings() && !document()->settings()->syncXHRInDocumentsEnabled()) { logConsoleError(scriptExecutionContext(), "Synchronous XMLHttpRequests are disabled for this page."); ec = INVALID_ACCESS_ERR; return; } // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated // attempt to discourage synchronous XHR use. responseType is one such piece of functionality. // We'll only disable this functionality for HTTP(S) requests since sync requests for local protocols // such as file: and data: still make sense to allow. if (url.protocolIsInHTTPFamily() && m_responseType != ResponseType::EmptyString) { logConsoleError(scriptExecutionContext(), "Synchronous HTTP(S) requests made from the window context cannot have XMLHttpRequest.responseType set."); ec = INVALID_ACCESS_ERR; return; } // Similarly, timeouts are disabled for synchronous requests as well. if (m_timeoutMilliseconds > 0) { logConsoleError(scriptExecutionContext(), "Synchronous XMLHttpRequests must not have a timeout value set."); ec = INVALID_ACCESS_ERR; return; } } m_method = uppercaseKnownHTTPMethod(method); m_url = url; scriptExecutionContext()->contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(m_url, ContentSecurityPolicy::InsecureRequestType::Load); m_async = async; ASSERT(!m_loader); // Check previous state to avoid dispatching readyState event // when calling open several times in a row. if (previousState != OPENED) changeState(OPENED); else m_state = OPENED; }
EJBindingHttpRequest::~EJBindingHttpRequest() { requestHeaders->release(); clearRequest(); clearConnection(); }