void UpdateApplication::processReply()
// ----------------------------------------------------------------------------
// Called as we receive new headers
// ----------------------------------------------------------------------------
{
// Hande redirections
code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (code >= 300 && code < 400)
{
// Get redirect URL
url = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
if (!url.isValid())
{
// Not yet received
return;
}
// In case URL is relative
url = reply->url().resolved(url);
IFTRACE(update)
debug() << "Redirected to: '" << +url.toString() << "'\n";
request.setUrl(url);
reply->deleteLater();
reply = manager->get(request);
connect(reply, SIGNAL(metaDataChanged()), this, SLOT(processReply()));
connect(reply, SIGNAL(finished()), this, SLOT(downloadFinished()));
connect(reply, SIGNAL(downloadProgress(qint64,qint64)),
this, SLOT(downloadProgress(qint64,qint64)));
}
else if (code == 200 && state == Downloading)
{
if (!createFile())
{
progress->hide();
cancel();
}
}
}
void PageDownloader::onReplyFinished(QNetworkReply* reply)
{
int statusCode = reply->attribute(
QNetworkRequest::HttpStatusCodeAttribute).toInt();
qDebug() << QString("Reply from %1 finished with status code: %2.")
.arg(mUrlString).arg(statusCode);
if (statusCode == kOkStatusCode) {
processReply(reply);
}
else if (statusCode == kMovedPermanentlyStatusCode
|| statusCode == kMovedTemporarilyStatusCode) {
processRedirection(reply);
}
else {
QString reasonPhrase = reply->attribute(
QNetworkRequest::HttpReasonPhraseAttribute).toString();
qDebug() << QString("Error: %1").arg(reasonPhrase);
emit errorOccuredAtUrl(mUrlString, reasonPhrase);
emit downloadCompleted(QByteArray());
onDownloadCompleted();
}
reply->deleteLater();
}
static void
ipckDriverHandleInterrupt(InterruptType type,
virt_ptr<Context> interruptedContext)
{
auto driver = ipckDriverGetInstance();
auto responses = std::vector<phys_ptr<ios::IpcRequest>> { };
// Get the pending replies
sIpcMutex.lock();
sPendingResponses[driver->coreId].swap(responses);
sIpcMutex.unlock();
// Process replies into process queue
for (auto response : responses) {
processReply(driver, response);
}
// Dispatch any pending user replies for the current process
auto pidx = static_cast<uint32_t>(getCurrentRamPartitionId());
if (driver->perProcessUserReply[pidx].count) {
dispatchUserRepliesCallback(driver, interruptedContext, pidx);
}
}
void Client::processCommand(const QString &cmd){
processReply(cmd.toAscii().data());
}
int SSL_accept(SSL* ssl)
{
if (ssl->GetError() == YasslError(SSL_ERROR_WANT_READ))
ssl->SetError(no_error);
if (ssl->GetError() == YasslError(SSL_ERROR_WANT_WRITE)) {
ssl->SetError(no_error);
ssl->SendWriteBuffered();
if (!ssl->GetError())
ssl->useStates().UseAccept() =
AcceptState(ssl->getStates().GetAccept() + 1);
}
switch (ssl->getStates().GetAccept()) {
case ACCEPT_BEGIN :
processReply(*ssl);
if (!ssl->GetError())
ssl->useStates().UseAccept() = ACCEPT_FIRST_REPLY_DONE;
case ACCEPT_FIRST_REPLY_DONE :
sendServerHello(*ssl);
if (!ssl->getSecurity().get_resuming()) {
sendCertificate(*ssl);
if (ssl->getSecurity().get_connection().send_server_key_)
sendServerKeyExchange(*ssl);
if(ssl->getCrypto().get_certManager().verifyPeer())
sendCertificateRequest(*ssl);
sendServerHelloDone(*ssl);
ssl->flushBuffer();
}
if (!ssl->GetError())
ssl->useStates().UseAccept() = SERVER_HELLO_DONE;
case SERVER_HELLO_DONE :
if (!ssl->getSecurity().get_resuming()) {
while (ssl->getStates().getServer() < clientFinishedComplete) {
if (ssl->GetError()) break;
processReply(*ssl);
}
}
if (!ssl->GetError())
ssl->useStates().UseAccept() = ACCEPT_SECOND_REPLY_DONE;
case ACCEPT_SECOND_REPLY_DONE :
sendChangeCipher(*ssl);
sendFinished(*ssl, server_end);
ssl->flushBuffer();
if (!ssl->GetError())
ssl->useStates().UseAccept() = ACCEPT_FINISHED_DONE;
case ACCEPT_FINISHED_DONE :
if (ssl->getSecurity().get_resuming()) {
while (ssl->getStates().getServer() < clientFinishedComplete) {
if (ssl->GetError()) break;
processReply(*ssl);
}
}
if (!ssl->GetError())
ssl->useStates().UseAccept() = ACCEPT_THIRD_REPLY_DONE;
case ACCEPT_THIRD_REPLY_DONE :
ssl->useLog().ShowTCP(ssl->getSocket().get_fd());
if (ssl->GetError()) {
GetErrors().Add(ssl->GetError());
return SSL_FATAL_ERROR;
}
return SSL_SUCCESS;
default:
return SSL_FATAL_ERROR; // unknown state
}
}
// if you get an error from connect see note at top of README
int SSL_connect(SSL* ssl)
{
if (ssl->GetError() == YasslError(SSL_ERROR_WANT_READ))
ssl->SetError(no_error);
if (ssl->GetError() == YasslError(SSL_ERROR_WANT_WRITE)) {
ssl->SetError(no_error);
ssl->SendWriteBuffered();
if (!ssl->GetError())
ssl->useStates().UseConnect() =
ConnectState(ssl->getStates().GetConnect() + 1);
}
ClientState neededState;
switch (ssl->getStates().GetConnect()) {
case CONNECT_BEGIN :
sendClientHello(*ssl);
if (!ssl->GetError())
ssl->useStates().UseConnect() = CLIENT_HELLO_SENT;
case CLIENT_HELLO_SENT :
neededState = ssl->getSecurity().get_resuming() ?
serverFinishedComplete : serverHelloDoneComplete;
while (ssl->getStates().getClient() < neededState) {
if (ssl->GetError()) break;
processReply(*ssl);
// if resumption failed, reset needed state
if (neededState == serverFinishedComplete)
if (!ssl->getSecurity().get_resuming())
neededState = serverHelloDoneComplete;
}
if (!ssl->GetError())
ssl->useStates().UseConnect() = FIRST_REPLY_DONE;
case FIRST_REPLY_DONE :
if(ssl->getCrypto().get_certManager().sendVerify())
sendCertificate(*ssl);
if (!ssl->getSecurity().get_resuming())
sendClientKeyExchange(*ssl);
if(ssl->getCrypto().get_certManager().sendVerify())
sendCertificateVerify(*ssl);
sendChangeCipher(*ssl);
sendFinished(*ssl, client_end);
ssl->flushBuffer();
if (!ssl->GetError())
ssl->useStates().UseConnect() = FINISHED_DONE;
case FINISHED_DONE :
if (!ssl->getSecurity().get_resuming())
while (ssl->getStates().getClient() < serverFinishedComplete) {
if (ssl->GetError()) break;
processReply(*ssl);
}
if (!ssl->GetError())
ssl->useStates().UseConnect() = SECOND_REPLY_DONE;
case SECOND_REPLY_DONE :
ssl->verifyState(serverFinishedComplete);
ssl->useLog().ShowTCP(ssl->getSocket().get_fd());
if (ssl->GetError()) {
GetErrors().Add(ssl->GetError());
return SSL_FATAL_ERROR;
}
return SSL_SUCCESS;
default :
return SSL_FATAL_ERROR; // unkown state
}
}
void TestServerOnRequest::onRequest(
McServerRequestContext&& ctx,
McRequestWithMcOp<mc_op_set>&& req) {
processReply(std::move(ctx), McReply(mc_res_stored));
}
// come here after receiving ANY reply from the gigablast server
static void gotReplyWrapper ( void *state , TcpSocket *sock ) {
processReply ( sock->m_readBuf , sock->m_readOffset );
s_callback ();
}
void DefaultQuery::process(QNetworkReply *reply)
{
processReply(reply);
}
static void *
clientThread (void *arg)
{
client_t *c = (client_t *) arg;
fd_set rfds, wfds;
int ret;
c->querybuf = sdsMakeRoomFor (sdsempty (), DEFAULT_QUERY_BUF_SIZE);
c->replybuf = sdsMakeRoomFor (sdsempty (), DEFAULT_QUERY_BUF_SIZE);
c->argc = 0;
c->argv = NULL;
c->argvlen = NULL;
c->reqtype = 0;
c->multibulklen = 0;
c->bulklen = -1;
c->rqst = arc_create_request ();
c->flags = 0;
c->total_append_command = 0;
FD_ZERO (&rfds);
FD_ZERO (&wfds);
while (1)
{
struct timeval timeout;
FD_CLR (c->fd, &rfds);
FD_CLR (c->fd, &wfds);
if (!(c->flags & REDIS_CLOSE_AFTER_REPLY))
FD_SET (c->fd, &rfds);
if (sdslen (c->replybuf) > 0)
FD_SET (c->fd, &wfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
ret = select (c->fd + 1, &rfds, &wfds, NULL, &timeout);
if (ret == -1)
{
perror ("select");
freeClient (c);
}
if (server.shutdown_signal)
{
c->flags |= REDIS_CLOSE_AFTER_REPLY;
}
/* readable */
if (FD_ISSET (c->fd, &rfds))
{
int pos = sdslen (c->querybuf);
int avail = sdsavail (c->querybuf);
ssize_t nread;
if (avail == 0)
{
c->querybuf =
sdsMakeRoomFor (c->querybuf, sdslen (c->querybuf));
avail = sdsavail (c->querybuf);
}
nread = read (c->fd, c->querybuf + pos, avail);
if (nread > 0)
{
sdsIncrLen (c->querybuf, nread);
processInputBuffer (c);
if (c->total_append_command)
{
int arc_errno, arc_be_errno, be_errno;
arc_ref_t *arc_ref;
arc_ref = acquire_arc_ref ();
ret =
arc_do_request (arc_ref->arc, c->rqst,
server.query_timeout_millis, &be_errno);
if (ret == -1)
{
arc_errno = errno;
arc_be_errno = be_errno;
}
else
{
ret = processReply (c, &be_errno);
if (ret == -1)
{
arc_errno = errno;
arc_be_errno = be_errno;
}
}
arc_free_request (c->rqst);
release_arc_ref (arc_ref);
c->rqst = arc_create_request ();
if (ret == -1)
{
if (arc_errno == ARC_ERR_TIMEOUT
|| (arc_errno == ARC_ERR_BACKEND
&& arc_be_errno == ARC_ERR_TIMEOUT))
{
addReplyStr (c, "-ERR Redis Timeout\r\n");
}
else
{
addReplyStr (c, "-ERR Internal Error\r\n");
}
c->flags |= REDIS_CLOSE_AFTER_REPLY;
}
}
}
else
{
if (nread == -1 && errno == EAGAIN)
{
/* Skip */
}
else
{
freeClient (c);
}
}
}
/* writable */
if (FD_ISSET (c->fd, &wfds))
{
int pos = 0;
int avail = sdslen (c->replybuf);
ssize_t nwritten;
nwritten = write (c->fd, c->replybuf + pos, avail);
if (nwritten > 0)
{
avail -= nwritten;
pos += nwritten;
sdsrange (c->replybuf, pos, -1);
}
else
{
if (nwritten == -1 && errno == EAGAIN)
{
/* Skip */
}
else
{
freeClient (c);
}
}
}
if (sdslen (c->replybuf) == 0 && (c->flags & REDIS_CLOSE_AFTER_REPLY))
{
freeClient (c);
}
}
return NULL;
}
