void BridgeServer::onNewConnection()
{
QLocalSocket *pSocket = m_pLocalServer->nextPendingConnection();
delete m_pBridgeCommunicator;
m_pBridgeCommunicator = new BridgeCommunicator(pSocket, this);
connect(m_pBridgeCommunicator, SIGNAL(requestReceived(QVariant)), this, SIGNAL(requestReceived(QVariant)));
connect(m_pBridgeCommunicator, SIGNAL(responseReceived(QVariant)), this, SIGNAL(responseReceived(QVariant)));
}
LoginWindow::LoginWindow(QWidget * parent, Qt::WindowFlags f):QMainWindow(parent,f)
{
QWidget *widget = new QWidget(this);
m_form.setupUi(widget);
setCentralWidget(widget);
connect(m_form.m_login, SIGNAL(clicked()), SLOT(okPressed()));
connect(&m_query,SIGNAL(responseReceived(QString, QString,QString)),this,SLOT(responseReceived(QString,QString,QString)));
connect(&m_query,SLOT(onManagerSslErrors()),&m_query,SIGNAL(errorReceived()));
connect(&m_query,SLOT(onReplyError(QNetworkReply::NetworkError)),&m_query,SIGNAL(errorReceived()));
connect(&m_query,SIGNAL(errorReceived()),this,SLOT(errorReceived()));
}
void IslInterface::processMessage(const IslMessage &item)
{
qDebug() << QString::fromStdString(item.DebugString());
switch (item.message_type()) {
case IslMessage::ROOM_COMMAND_CONTAINER: {
processRoomCommand(item.room_command(), item.session_id());
break;
}
case IslMessage::GAME_COMMAND_CONTAINER: {
emit gameCommandContainerReceived(item.game_command(), item.player_id(), serverId, item.session_id());
break;
}
case IslMessage::SESSION_EVENT: {
processSessionEvent(item.session_event(), item.session_id());
break;
}
case IslMessage::RESPONSE: {
emit responseReceived(item.response(), item.session_id());
break;
}
case IslMessage::GAME_EVENT_CONTAINER: {
emit gameEventContainerReceived(item.game_event_container(), item.session_id());
break;
}
case IslMessage::ROOM_EVENT: {
processRoomEvent(item.room_event()); break;
break;
}
default: ;
}
}
void StreamingAudioClient::handle_typeconfirm(int type, int preset)
{
m_type = (StreamingAudioType)type;
m_preset = preset;
m_responseReceived = true;
emit responseReceived();
}
void ApplyMarkQuery::onManagerFinished(QNetworkReply *reply)
{
QByteArray jsonResponseByteArray = reply->readAll();
if (jsonResponseByteArray.size() > 0)
{
QString jsonResponse(jsonResponseByteArray);
qDebug() << "Gotten response (json): " << jsonResponse;
QJson::Parser parser;
bool ok;
QVariantMap result = parser.parse(QByteArray(jsonResponse.toAscii()), &ok).toMap();
QString status("");
QString status_description("");
if (!ok)
{
qFatal("An error occured during parsing json with response to apply mark");
}
else
{
status = result["status"].toString();
status_description = result["status_description"].toString();
}
Q_EMIT responseReceived(status,status_description);
}
}
int StreamingAudioClient::setTypeWithPreset(StreamingAudioType type, int preset, unsigned int timeout)
{
if (m_port < 0) return SAC_NOT_REGISTERED; // not yet registered
if (m_type == type && m_preset == preset) return SAC_SUCCESS; // type already set
m_responseReceived = false;
OscMessage msg;
msg.init("/sam/set/type", "iiii", m_port, type, preset, m_replyPort);
if (!OscClient::sendFromSocket(&msg, &m_socket))
{
qWarning("StreamingAudioClient::setType() Couldn't send OSC message");
return SAC_OSC_ERROR;
}
// wait on response from SAM
QEventLoop loop;
connect(this, SIGNAL(responseReceived()), &loop, SLOT(quit()));
QTimer::singleShot(timeout, &loop, SLOT(quit()));
loop.exec();
if (!m_responseReceived)
{
qWarning("StreamingAudioClient::setType() timed out waiting for response to set/type request");
return SAC_TIMEOUT;
}
return ((m_type == type && m_preset == preset) ? SAC_SUCCESS : SAC_REQUEST_DENIED);
}
void StreamingAudioClient::handle_typedeny(int errorCode)
{
qWarning("SAM type change DENIED: error code = %d", errorCode);
// TODO: do something with the error code?
m_responseReceived = true;
emit responseReceived();
}
void NtpTime::run()
{
wait();
issueRequest();
requestIssued();
updateSystemTime(); //This has to be before response recieved so the timer has a chance to delay.
responseReceived();
}
void DocumentLoader::handleSubstituteDataLoadNow(DocumentLoaderTimer*)
{
KURL url = m_substituteData.responseURL();
if (url.isEmpty())
url = m_request.url();
ResourceResponse response(url, m_substituteData.mimeType(), m_substituteData.content()->size(), m_substituteData.textEncoding(), "");
responseReceived(0, response);
}
void StreamingAudioClient::handle_regdeny(int errorCode)
{
qWarning("SAM registration DENIED: error = %d", errorCode);
// check to see if we timed out
// TODO: what if we tried re-registering after a time-out, and then received a regconfirm/regdeny??
// TODO: do something with the error code?
m_responseReceived = true;
emit responseReceived();
}
void UnsubscribeChannelQuery::processReply(QNetworkReply *reply)
{
DefaultResponseJSON response;
response.parseJson(reply->readAll());
if(response.getStatus() == "Ok")
{
m_status="Ok";
Q_EMIT responseReceived();
}
else
{
Q_EMIT errorOccured(response.getStatusMessage());
}
}
void MainResourceLoader::handleSubstituteDataLoadNow(MainResourceLoaderTimer*)
{
RefPtr<MainResourceLoader> protect(this);
KURL url = m_substituteData.responseURL();
if (url.isEmpty())
url = m_initialRequest.url();
// Clear the initial request here so that subsequent entries into the
// loader will not think there's still a deferred load left to do.
m_initialRequest = ResourceRequest();
ResourceResponse response(url, m_substituteData.mimeType(), m_substituteData.content()->size(), m_substituteData.textEncoding(), "");
responseReceived(0, response);
}
void Servatrice::addIslInterface(int serverId, IslInterface *interface)
{
// Only call with islLock locked for writing
islInterfaces.insert(serverId, interface);
connect(interface, SIGNAL(externalUserJoined(ServerInfo_User)), this, SLOT(externalUserJoined(ServerInfo_User)));
connect(interface, SIGNAL(externalUserLeft(QString)), this, SLOT(externalUserLeft(QString)));
connect(interface, SIGNAL(externalRoomUserJoined(int, ServerInfo_User)), this, SLOT(externalRoomUserJoined(int, ServerInfo_User)));
connect(interface, SIGNAL(externalRoomUserLeft(int, QString)), this, SLOT(externalRoomUserLeft(int, QString)));
connect(interface, SIGNAL(externalRoomSay(int, QString, QString)), this, SLOT(externalRoomSay(int, QString, QString)));
connect(interface, SIGNAL(externalRoomGameListChanged(int, ServerInfo_Game)), this, SLOT(externalRoomGameListChanged(int, ServerInfo_Game)));
connect(interface, SIGNAL(joinGameCommandReceived(Command_JoinGame, int, int, int, qint64)), this, SLOT(externalJoinGameCommandReceived(Command_JoinGame, int, int, int, qint64)));
connect(interface, SIGNAL(gameCommandContainerReceived(CommandContainer, int, int, qint64)), this, SLOT(externalGameCommandContainerReceived(CommandContainer, int, int, qint64)));
connect(interface, SIGNAL(responseReceived(Response, qint64)), this, SLOT(externalResponseReceived(Response, qint64)));
connect(interface, SIGNAL(gameEventContainerReceived(GameEventContainer, qint64)), this, SLOT(externalGameEventContainerReceived(GameEventContainer, qint64)));
}
void TcpRpcChannel::dataReceived(const boost::system::error_code& ec,
std::size_t bytes_transferred) {
if (ec) {
GOOGLE_LOG(ERROR) << "fail to receive data from server";
startConnect();
return;
}
GOOGLE_LOG(INFO) << "received " << bytes_transferred << " bytes from server";
receivedMsg_.append(msgBuffer_, bytes_transferred);
startRead();
string msg;
while (extractMessage(msg)) {
responseReceived(msg);
}
}
void UdpRpcChannel::packetReceived(const boost::system::error_code& ec, std::size_t bytes_transferred) {
if (stop_) {
return;
}
if (senderEndpoint_ != remoteEndpoint_) {
GOOGLE_LOG(ERROR) << "received a packet not from server, discard it";
return;
}
string s(msgBuffer_, bytes_transferred);
try {
string resp_msg;
while( RpcMessage::extractNetPacket( s, resp_msg ) ) {
responseReceived( resp_msg );
}
} catch (...) {
}
startRead();
}
void BytestreamParser::
parse(const unsigned char c)
{
switch (_state) {
// there may be either a regular character from a response string, or an
// event starting. We can determine this information by looking at the
// high bit. If it is set, it is an event
case 0:
if ((c & 0x80) == 0) {
if (c == '\n') {
if (!_response)
std::cerr << "EE: BytestreamParser _response is nullptr where it should not be" << std::endl;
else
emit responseReceived(std::move(_response));
_response = new QString();
_response->reserve(64);
}
else
_response->append(c);
}
else {
_ev = new DVSEvent;
_ev->id = _id;
_ev->x = static_cast<uint16_t>(c) & 0x7F;
_ev->y = 0;
_ev->p = 0;
_ev->t = 0;
++_state;
}
break;
case 1:
_ev->p = (static_cast<uint8_t>(c) & 0x80) >> 7;
_ev->y = static_cast<uint16_t>(c) & 0x7F;
if (_timeformat == DVSEvent::TIMEFORMAT_0BYTES) {
emit eventReceived(std::move(_ev));
_ev = nullptr;
_state = 0;
}
else
++_state;
break;
case 2:
if (_timeformat == DVSEvent::TIMEFORMAT_2BYTES)
_ev->t |= static_cast<uint64_t>(c) << 8;
else
_ev->t |= static_cast<uint64_t>(c) << 16;
++_state;
break;
case 3:
if (_timeformat == DVSEvent::TIMEFORMAT_2BYTES) {
_ev->t |= static_cast<uint64_t>(c);
emit eventReceived(std::move(_ev));
_ev = nullptr;
_state = 0;
}
else {
_ev->t |= static_cast<uint64_t>(c) << 8;
++_state;
}
break;
case 4:
_ev->t |= static_cast<uint64_t>(c);
emit eventReceived(std::move(_ev));
_ev = nullptr;
_state = 0;
break;
default:
// TODO: report the error to some other function, don't just
// print it
// found a state that should not be there. exit
std::cerr << "EE: BytestreamParser in unknown state. resetting" << std::endl;
_state = 0;
break;
}
}
void StreamingAudioClient::handle_regconfirm(int port, unsigned int sampleRate, unsigned int bufferSize, quint16 rtpBasePort)
{
printf("StreamingAudioClient registration confirmed: unique id = %d, rtpBasePort = %d", port, rtpBasePort);
m_bufferSize = bufferSize;
m_sampleRate = sampleRate;
// init RTP
quint16 portOffset = port * 4;
m_sender = new RtpSender(m_samIP, portOffset + rtpBasePort, portOffset + rtpBasePort + 3, portOffset + rtpBasePort + 1, REPORT_INTERVAL_MILLIS, sampleRate, m_channels, bufferSize, port, m_payloadType);
if (!m_sender->init())
{
qWarning("StreamingAudioClient::handle_regconfirm couldn't initialize RtpSender: unregistering with SAM");
// unregister with SAM
OscMessage msg;
msg.init("/sam/app/unregister", "i", port);
if (!OscClient::sendFromSocket(&msg, &m_socket))
{
qWarning("Couldn't send OSC message");
}
return;
}
// allocate audio buffer
m_audioOut = new float*[m_channels];
for (unsigned int ch = 0; ch < m_channels; ch++)
{
m_audioOut[ch] = new float[bufferSize];
}
// initialize and start interface if not driving SAC sending externally
if (!m_driveExternally)
{
#ifdef SAC_NO_JACK
m_interface = new VirtualAudioInterface(m_channels, bufferSize, sampleRate);
#else
// write the JACK client name
char clientName[MAX_CLIENT_NAME];
snprintf(clientName, MAX_CLIENT_NAME, "SAC-client%d-%d", rtpBasePort, port);
m_interface = new JackAudioInterface(m_channels, bufferSize, sampleRate, clientName);
#endif
m_interface->setAudioCallback(StreamingAudioClient::interface_callback, this);
// start interface (start sending audio)
if (!m_interface->go())
{
qWarning("StreamingAudioClient::handle_regconfirm ERROR: couldn't start audio interface : unregistering with SAM");
// unregister with SAM
OscMessage msg;
msg.init("/sam/app/unregister", "i", port);
if (!OscClient::sendFromSocket(&msg, &m_socket))
{
qWarning("Couldn't send OSC message");
}
return;
}
}
m_port = port;
m_responseReceived = true;
emit responseReceived();
}
// In this method, we can clear |request| to tell content::WebURLLoaderImpl of
// Chromium not to follow the redirect. This works only when this method is
// called by RawResource::willSendRequest(). If called by
// RawResource::didAddClient(), clearing |request| won't be propagated
// to content::WebURLLoaderImpl. So, this loader must also get detached from
// the resource by calling clearResource().
void DocumentThreadableLoader::redirectReceived(Resource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse)
{
ASSERT(m_client);
ASSERT_UNUSED(resource, resource == this->resource());
ASSERT(m_async);
if (!m_actualRequest.isNull()) {
reportResponseReceived(resource->identifier(), redirectResponse);
handlePreflightFailure(redirectResponse.url().string(), "Response for preflight is invalid (redirect)");
// |this| may be dead here.
request = ResourceRequest();
return;
}
if (m_redirectMode == WebURLRequest::FetchRedirectModeManual) {
// Keep |this| alive even if the client release a reference in
// responseReceived().
RefPtr<DocumentThreadableLoader> protect(this);
// We use |m_redirectMode| to check the original redirect mode.
// |request| is a new request for redirect. So we don't set the redirect
// mode of it in WebURLLoaderImpl::Context::OnReceivedRedirect().
ASSERT(request.useStreamOnResponse());
// There is no need to read the body of redirect response because there
// is no way to read the body of opaque-redirect filtered response's
// internal response.
// TODO(horo): If we support any API which expose the internal body, we
// will have to read the body. And also HTTPCache changes will be needed
// because it doesn't store the body of redirect responses.
responseReceived(resource, redirectResponse, adoptPtr(new EmptyDataHandle()));
if (m_client) {
ASSERT(m_actualRequest.isNull());
notifyFinished(resource);
}
request = ResourceRequest();
return;
}
if (m_redirectMode == WebURLRequest::FetchRedirectModeError || !isAllowedByContentSecurityPolicy(request.url(), ContentSecurityPolicy::DidRedirect)) {
ThreadableLoaderClient* client = m_client;
clear();
client->didFailRedirectCheck();
// |this| may be dead here.
request = ResourceRequest();
return;
}
// Allow same origin requests to continue after allowing clients to audit the redirect.
if (isAllowedRedirect(request.url())) {
if (m_client->isDocumentThreadableLoaderClient())
static_cast<DocumentThreadableLoaderClient*>(m_client)->willFollowRedirect(request, redirectResponse);
return;
}
if (m_corsRedirectLimit <= 0) {
ThreadableLoaderClient* client = m_client;
clear();
client->didFailRedirectCheck();
// |this| may be dead here.
} else if (m_options.crossOriginRequestPolicy == UseAccessControl) {
--m_corsRedirectLimit;
InspectorInstrumentation::didReceiveCORSRedirectResponse(document().frame(), resource->identifier(), document().frame()->loader().documentLoader(), redirectResponse, 0);
bool allowRedirect = false;
String accessControlErrorDescription;
// Non-simple cross origin requests (both preflight and actual one) are
// not allowed to follow redirect.
if (m_crossOriginNonSimpleRequest) {
accessControlErrorDescription = "The request was redirected to '"+ request.url().string() + "', which is disallowed for cross-origin requests that require preflight.";
} else {
// The redirect response must pass the access control check if the
// original request was not same-origin.
allowRedirect = CrossOriginAccessControl::isLegalRedirectLocation(request.url(), accessControlErrorDescription)
&& (m_sameOriginRequest || passesAccessControlCheck(redirectResponse, effectiveAllowCredentials(), securityOrigin(), accessControlErrorDescription, m_requestContext));
}
if (allowRedirect) {
// FIXME: consider combining this with CORS redirect handling performed by
// CrossOriginAccessControl::handleRedirect().
clearResource();
RefPtr<SecurityOrigin> originalOrigin = SecurityOrigin::create(redirectResponse.url());
RefPtr<SecurityOrigin> requestOrigin = SecurityOrigin::create(request.url());
// If the original request wasn't same-origin, then if the request URL origin is not same origin with the original URL origin,
// set the source origin to a globally unique identifier. (If the original request was same-origin, the origin of the new request
// should be the original URL origin.)
if (!m_sameOriginRequest && !originalOrigin->isSameSchemeHostPort(requestOrigin.get()))
m_securityOrigin = SecurityOrigin::createUnique();
// Force any subsequent requests to use these checks.
m_sameOriginRequest = false;
// Since the request is no longer same-origin, if the user didn't request credentials in
// the first place, update our state so we neither request them nor expect they must be allowed.
if (m_resourceLoaderOptions.credentialsRequested == ClientDidNotRequestCredentials)
m_forceDoNotAllowStoredCredentials = true;
// Remove any headers that may have been added by the network layer that cause access control to fail.
request.clearHTTPReferrer();
request.clearHTTPOrigin();
request.clearHTTPUserAgent();
// Add any CORS simple request headers which we previously saved from the original request.
for (const auto& header : m_simpleRequestHeaders)
request.setHTTPHeaderField(header.key, header.value);
makeCrossOriginAccessRequest(request);
// |this| may be dead here.
return;
}
ThreadableLoaderClient* client = m_client;
clear();
client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, redirectResponse.url().string(), accessControlErrorDescription));
// |this| may be dead here.
} else {
ThreadableLoaderClient* client = m_client;
clear();
client->didFailRedirectCheck();
// |this| may be dead here.
}
request = ResourceRequest();
}
int StreamingAudioClient::start(int x, int y, int width, int height, int depth, unsigned int timeout)
{
if (m_port >= 0) return SAC_ERROR; // already registered
if (!m_samIP) return SAC_ERROR; // not initialized yet
printf("\n");
printf("--------------------------------------\n");
printf("Streaming Audio Client version %d.%d.%d\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH);
printf("Built on %s at %s\n", __DATE__, __TIME__);
printf("Copyright UCSD 2011-2013\n");
printf("Connecting to SAM at IP %s, port %d\n", m_samIP, m_samPort);
printf("--------------------------------------\n\n");
// bind to local IP and port (Qt 5+ only)
if (m_replyIP || m_replyPort > 0)
{
#if QT_VERSION >= 0x050000
if (m_replyIP)
{
QString replyIPStr(m_replyIP);
QHostAddress replyIPAddr(replyIPStr);
m_socket.bind(replyIPAddr, m_replyPort);
}
else
{
m_socket.bind(QHostAddress::Any, m_replyPort);
}
#else
qWarning("Couldn't bind to specified local IP and port. Qt version 5.0+ required.");
return SAC_ERROR;
#endif
}
QString samIPStr(m_samIP);
m_socket.connectToHost(samIPStr, m_samPort);
if (!m_socket.waitForConnected(timeout))
{
qWarning("StreamingAudioClient::start() couldn't connect to SAM");
return SAC_TIMEOUT;
}
m_replyPort = m_socket.localPort();
// set up listening for OSC messages
m_oscReader = new OscTcpSocketReader(&m_socket);
connect(&m_socket, SIGNAL(readyRead()), m_oscReader, SLOT(readFromSocket()));
connect(m_oscReader, SIGNAL(messageReady(OscMessage*, const char*, QAbstractSocket*)), this, SLOT(handleOscMessage(OscMessage*, const char*, QAbstractSocket*)));
connect(&m_socket, SIGNAL(disconnected()), this, SLOT(samDisconnected()));
OscMessage msg;
msg.init("/sam/app/register", "siiiiiiiiiiiiii", m_name, m_channels,
x,
y,
width,
height,
depth,
m_type,
m_preset,
0, // placeholder for packet size/samples per packet requested
m_packetQueueSize,
VERSION_MAJOR,
VERSION_MINOR,
VERSION_PATCH,
m_replyPort);
if (!OscClient::sendFromSocket(&msg, &m_socket))
{
qWarning("StreamingAudioClient::start() Couldn't send OSC message");
return SAC_OSC_ERROR;
}
// wait on response from SAM
QEventLoop loop;
connect(this, SIGNAL(responseReceived()), &loop, SLOT(quit()));
QTimer::singleShot(timeout, &loop, SLOT(quit()));
loop.exec();
if (!m_responseReceived)
{
qWarning("StreamingAudioClient::start() timed out waiting for response to register request");
return SAC_TIMEOUT;
}
else if (m_port < 0)
{
return SAC_REQUEST_DENIED;
}
return SAC_SUCCESS;
}
void ProfilerThread::setConnections()
{
connect(this,SIGNAL(doRequest()),this, SLOT(sendRequest()));
connect(m_query,SIGNAL(errorOccured(int)),this, SLOT(responseReceived()));
connect(m_query,SIGNAL(success()),this, SLOT(responseReceived()));
}
void MultiPointCom::run()
{
mutex.lock();
QTime timeout = lastConnectTime.addSecs(30);
if (timeout < QTime::currentTime()) {
qDebug() << "Device connected timeout" << disconnectCount++;
lastConnectTime = QTime::currentTime();
#ifdef __arm__
ioctl(device, SI4432_IOC_RESET, 1);
#endif
}
#ifdef __arm__
si4432_ioc_transfer tr;
char txBuf[64], rxBuf[64];
memcpy(txBuf, request.data(), request.size());
memset(&tr, 0, sizeof(si4432_ioc_transfer));
tr.tx_buf = (__u64)txBuf;
tr.rx_buf = (__u64)rxBuf;
tr.len = request.size();
int len = ioctl(device, SI4432_IOC_MESSAGE(1), &tr);
if (len > 0) {
response.clear();
response.append(rxBuf, len);
quint8 addr = response.at(0);
if (addr == address) {
lastConnectTime = QTime::currentTime();
disconnect = 0;
emit deviceConnected();
emit responseReceived(response.at(1), QByteArray(response.data() + 2, len - 2));
}
} else {
disconnect++;
if (disconnect > 3) {
disconnect = 0;
emit deviceDisconnected();
}
}
#else
QUdpSocket *udp = new QUdpSocket();
udp->writeDatagram(request, QHostAddress::LocalHost, 19999);
if (udp->waitForReadyRead(100) && (udp->pendingDatagramSize() > 0)) {
response.resize(udp->pendingDatagramSize());
udp->readDatagram(response.data(), response.size());
quint8 addr = response.at(0);
if (addr == address) {
lastConnectTime = QTime::currentTime();
disconnect = 0;
emit deviceConnected();
emit responseReceived(response.at(1), response.mid(2));
}
} else {
disconnect++;
if (disconnect > 3) {
disconnect = 0;
emit deviceDisconnected();
}
}
delete udp;
#endif
mutex.unlock();
}
// In this method, we can clear |request| to tell content::WebURLLoaderImpl of
// Chromium not to follow the redirect. This works only when this method is
// called by RawResource::willSendRequest(). If called by
// RawResource::didAddClient(), clearing |request| won't be propagated to
// content::WebURLLoaderImpl. So, this loader must also get detached from the
// resource by calling clearResource().
bool DocumentThreadableLoader::redirectReceived(
Resource* resource,
const ResourceRequest& request,
const ResourceResponse& redirectResponse) {
DCHECK(m_client);
DCHECK_EQ(resource, this->resource());
DCHECK(m_async);
m_checker.redirectReceived();
if (!m_actualRequest.isNull()) {
reportResponseReceived(resource->identifier(), redirectResponse);
handlePreflightFailure(redirectResponse.url().getString(),
"Response for preflight is invalid (redirect)");
return false;
}
if (m_redirectMode == WebURLRequest::FetchRedirectModeManual) {
// We use |m_redirectMode| to check the original redirect mode. |request| is
// a new request for redirect. So we don't set the redirect mode of it in
// WebURLLoaderImpl::Context::OnReceivedRedirect().
DCHECK(request.useStreamOnResponse());
// There is no need to read the body of redirect response because there is
// no way to read the body of opaque-redirect filtered response's internal
// response.
// TODO(horo): If we support any API which expose the internal body, we will
// have to read the body. And also HTTPCache changes will be needed because
// it doesn't store the body of redirect responses.
responseReceived(resource, redirectResponse,
WTF::makeUnique<EmptyDataHandle>());
if (m_client) {
DCHECK(m_actualRequest.isNull());
notifyFinished(resource);
}
return false;
}
if (m_redirectMode == WebURLRequest::FetchRedirectModeError) {
ThreadableLoaderClient* client = m_client;
clear();
client->didFailRedirectCheck();
return false;
}
// Allow same origin requests to continue after allowing clients to audit the
// redirect.
if (isAllowedRedirect(request.url())) {
m_client->didReceiveRedirectTo(request.url());
if (m_client->isDocumentThreadableLoaderClient()) {
return static_cast<DocumentThreadableLoaderClient*>(m_client)
->willFollowRedirect(request, redirectResponse);
}
return true;
}
if (m_corsRedirectLimit <= 0) {
ThreadableLoaderClient* client = m_client;
clear();
client->didFailRedirectCheck();
return false;
}
--m_corsRedirectLimit;
InspectorInstrumentation::didReceiveCORSRedirectResponse(
document().frame(), resource->identifier(),
document().frame()->loader().documentLoader(), redirectResponse,
resource);
bool allowRedirect = false;
String accessControlErrorDescription;
if (!CrossOriginAccessControl::isLegalRedirectLocation(
request.url(), accessControlErrorDescription)) {
accessControlErrorDescription =
"Redirect from '" + redirectResponse.url().getString() +
"' has been blocked by CORS policy: " + accessControlErrorDescription;
} else if (!m_sameOriginRequest &&
!passesAccessControlCheck(
redirectResponse, effectiveAllowCredentials(),
getSecurityOrigin(), accessControlErrorDescription,
m_requestContext)) {
// The redirect response must pass the access control check if the original
// request was not same-origin.
accessControlErrorDescription =
"Redirect from '" + redirectResponse.url().getString() + "' to '" +
request.url().getString() + "' has been blocked by CORS policy: " +
accessControlErrorDescription;
} else {
allowRedirect = true;
}
if (!allowRedirect) {
ThreadableLoaderClient* client = m_client;
clear();
client->didFailAccessControlCheck(ResourceError(
errorDomainBlinkInternal, 0, redirectResponse.url().getString(),
accessControlErrorDescription));
return false;
}
m_client->didReceiveRedirectTo(request.url());
// FIXME: consider combining this with CORS redirect handling performed by
// CrossOriginAccessControl::handleRedirect().
clearResource();
// If the original request wasn't same-origin, then if the request URL origin
// is not same origin with the original URL origin, set the source origin to a
// globally unique identifier. (If the original request was same-origin, the
// origin of the new request should be the original URL origin.)
if (!m_sameOriginRequest) {
RefPtr<SecurityOrigin> originalOrigin =
SecurityOrigin::create(redirectResponse.url());
RefPtr<SecurityOrigin> requestOrigin =
SecurityOrigin::create(request.url());
if (!originalOrigin->isSameSchemeHostPort(requestOrigin.get()))
m_securityOrigin = SecurityOrigin::createUnique();
}
// Force any subsequent requests to use these checks.
m_sameOriginRequest = false;
// Since the request is no longer same-origin, if the user didn't request
// credentials in the first place, update our state so we neither request them
// nor expect they must be allowed.
if (m_resourceLoaderOptions.credentialsRequested ==
ClientDidNotRequestCredentials)
m_forceDoNotAllowStoredCredentials = true;
// Save the referrer to use when following the redirect.
m_overrideReferrer = true;
m_referrerAfterRedirect =
Referrer(request.httpReferrer(), request.getReferrerPolicy());
ResourceRequest crossOriginRequest(request);
// Remove any headers that may have been added by the network layer that cause
// access control to fail.
crossOriginRequest.clearHTTPReferrer();
crossOriginRequest.clearHTTPOrigin();
crossOriginRequest.clearHTTPUserAgent();
// Add any request headers which we previously saved from the
// original request.
for (const auto& header : m_requestHeaders)
crossOriginRequest.setHTTPHeaderField(header.key, header.value);
makeCrossOriginAccessRequest(crossOriginRequest);
return false;
}
void JsonRpc::processJson(const QString& json)
{
QList<QVariantMap> objects;
try
{
objects = JsonToVariant::multiParse(json);
}
catch(ParseException)
{
sendError(QVariant(), InvalidJson, "Parse error.");
return;
}
Q_FOREACH(const QVariantMap& object, objects)
{
if(object.value("jsonrpc").toString() != "2.0")
{
sendError(object.value("id"), InvalidJsonRpc, "JSON-RPC version not specified or not supported.", object);
continue;
}
// Notification or request
if(object.contains("method"))
{
if(object.value("method").type() != QVariant::String)
{
sendError(object.value("id"), InvalidJsonRpc, "'method' member of request must be a string.", object);
continue;
}
QString method = object.value("method").toString();
QVariant parameters = object.value("params");
if(parameters.isNull()) parameters = QVariantList();
if(parameters.type() != QVariant::List && parameters.type() != QVariant::Map)
{
sendError(object.value("id"), InvalidJsonRpc, "'parameters' member of request must be omitted, a list, or an object.", object);
continue;
}
// Request or notification
if(object.contains("id"))
{
emit requestReceived(object.value("id"), method, parameters);
}
else
{
emit notificationReceived(method, parameters);
}
continue;
}
// Request successful
if(object.contains("result"))
{
if(!object.contains("id"))
{
sendError(QVariant(), InvalidJsonRpc, "ID not specified in response.", object);
continue;
}
emit responseReceived(object.value("id"), object.value("result"));
continue;
}
// Request failed
if(object.contains("error"))
{
if(!object.contains("id"))
{
sendError(QVariant(), InvalidJsonRpc, "ID not specified in response.", object);
continue;
}
if(object.value("error").type() != QVariant::Map)
{
sendError(object.value("id"), InvalidJsonRpc, "'error' member is not an Error object.", object);
continue;
}
QVariantMap error = object.value("error").toMap();
if(error.value("code").type() != QVariant::Int)
{
sendError(object.value("id"), InvalidJsonRpc, "'code' member of error object is not an integer.", object);
continue;
}
if(error.value("message").type() != QVariant::String)
{
sendError(object.value("id"), InvalidJsonRpc, "'message' member of error object is not a string.", object);
continue;
}
emit errorReceived(object.value("id"), error.value("code").toInt(), error.value("message").toString(), error.value("data"));
continue;
}
// Not a notification, request, or response
sendError(object.value("id"), InvalidJsonRpc, "JSON object doesn't appear to be a JSON-RPC request, notification, or response.", object);
}
}
