static int doRequest(HttpConn *conn, cchar *url, MprList *files)
{
MprTime mark, remaining;
HttpLimits *limits;
mprAssert(url && *url);
limits = conn->limits;
mprLog(MPR_DEBUG, "fetch: %s %s", app->method, url);
mark = mprGetTime();
if (issueRequest(conn, url, files) < 0) {
return MPR_ERR_CANT_CONNECT;
}
remaining = limits->requestTimeout;
while (!conn->error && conn->state < HTTP_STATE_COMPLETE && remaining > 0) {
remaining = mprGetRemainingTime(mark, limits->requestTimeout);
httpWait(conn, 0, remaining);
readBody(conn);
}
if (conn->state < HTTP_STATE_COMPLETE && !conn->error) {
httpError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TIMEOUT,
"Inactive request timed out, exceeded request timeout %d", app->timeout);
} else {
readBody(conn);
}
reportResponse(conn, url, mprGetTime() - mark);
httpDestroyRx(conn->rx);
httpDestroyTx(conn->tx);
return 0;
}
bool BeaconLoader::sendBeacon(LocalFrame* frame, int allowance, const KURL& beaconURL, PassRefPtrWillBeRawPtr<Blob>& data, int& payloadLength)
{
ASSERT(data);
unsigned long long entitySize = data->size();
if (allowance > 0 && static_cast<unsigned long long>(allowance) < entitySize)
return false;
ResourceRequest request(beaconURL);
prepareRequest(frame, request);
RefPtr<FormData> entityBody = FormData::create();
if (data->hasBackingFile())
entityBody->appendFile(toFile(data.get())->path());
else
entityBody->appendBlob(data->uuid(), data->blobDataHandle());
request.setHTTPBody(entityBody.release());
AtomicString contentType;
const String& blobType = data->type();
if (!blobType.isEmpty() && isValidContentType(blobType))
request.setHTTPContentType(AtomicString(contentType));
issueRequest(frame, request);
payloadLength = entitySize;
return true;
}
static void handleReply(redisAsyncContext *context, void *_reply, void *privdata) {
REDIS_NOTUSED(privdata);
redisReply *reply = (redisReply*)_reply;
client c = (client)context->data;
long long latency = (microseconds() - c->start) / 1000;
if (reply == NULL && context->err) {
fprintf(stderr,"Error: %s\n", context->errstr);
exit(1);
} else {
assert(reply != NULL);
if (reply->type == REDIS_REPLY_ERROR) {
fprintf(stderr,"Error: %s\n", reply->str);
exit(1);
}
}
if (latency > MAX_LATENCY) latency = MAX_LATENCY;
config.latency[latency]++;
if (config.check) checkDataIntegrity(c,reply);
freeReplyObject(reply);
if (config.done || config.ctrlc) {
redisAsyncDisconnect(c->context);
return;
}
if (config.keepalive) {
issueRequest(c);
} else {
/* createMissingClients will be called in the disconnection callback */
redisAsyncDisconnect(c->context);
}
}
void NtpTime::run()
{
wait();
issueRequest();
requestIssued();
updateSystemTime(); //This has to be before response recieved so the timer has a chance to delay.
responseReceived();
}
static int doRequest(HttpConn *conn, cchar *url, MprList *files)
{
MprTicks mark, remaining;
HttpLimits *limits;
MprFile *outFile;
cchar *path;
assert(url && *url);
limits = conn->limits;
mprTrace(4, "fetch: %s %s", app->method, url);
mark = mprGetTicks();
if (issueRequest(conn, url, files) < 0) {
return MPR_ERR_CANT_CONNECT;
}
remaining = limits->requestTimeout;
if (app->outFilename) {
path = app->loadThreads > 1 ? sfmt("%s-%s.tmp", app->outFilename, mprGetCurrentThreadName()): app->outFilename;
if ((outFile = mprOpenFile(path, O_CREAT | O_WRONLY | O_TRUNC | O_TEXT, 0664)) == 0) {
mprError("Cannot open %s", path);
return MPR_ERR_CANT_OPEN;
}
} else {
outFile = mprGetStdout();
}
mprAddRoot(outFile);
while (!conn->tx->finalized && conn->state < HTTP_STATE_COMPLETE && remaining > 0) {
remaining = mprGetRemainingTicks(mark, limits->requestTimeout);
readBody(conn, outFile);
httpWait(conn, 0, remaining);
}
if (conn->state < HTTP_STATE_COMPLETE && !conn->error) {
httpError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TIMEOUT,
"Inactive request timed out, exceeded request timeout %d", app->timeout);
} else {
readBody(conn, outFile);
}
if (app->outFilename) {
mprCloseFile(outFile);
}
mprRemoveRoot(outFile);
reportResponse(conn, url, mprGetTicks() - mark);
httpDestroyRx(conn->rx);
httpDestroyTx(conn->tx);
return 0;
}
static client createClient(void) {
client c = zmalloc(sizeof(struct _client));
c->context = redisAsyncConnect(config.hostip,config.hostport);
c->context->data = c;
redisAsyncSetDisconnectCallback(c->context,clientDisconnected);
if (c->context->err) {
fprintf(stderr,"Connect: %s\n",c->context->errstr);
exit(1);
}
redisAeAttach(config.el,c->context);
listAddNodeTail(config.clients,c);
issueRequest(c);
return c;
}
bool BeaconLoader::sendBeacon(LocalFrame* frame, int allowance, const KURL& beaconURL, const String& data, int& payloadLength)
{
ResourceRequest request(beaconURL);
prepareRequest(frame, request);
RefPtr<FormData> entityBody = FormData::create(data.utf8());
unsigned long long entitySize = entityBody->sizeInBytes();
if (allowance > 0 && static_cast<unsigned>(allowance) < entitySize)
return false;
request.setHTTPBody(entityBody);
request.setHTTPContentType("text/plain;charset=UTF-8");
issueRequest(frame, request);
payloadLength = entitySize;
return true;
}
// !!! recursion is not working - look at this
void
IB_Information::requestInfo ()
{
issueRequest ();
if (*requestedInfo_.buffer() == isc_info_error)
throw new IB_SQLException (IB_SQLException::bugCheck__0__,
10002,
IB_SQLException::bugCheckException__);
// Check if requestedInfo_ buffer is too small for results.
// If it is, then make it bigger and try this call again recursively.
if (*requestedInfo_.buffer() == isc_info_truncated) {
requestedInfo_.expandBy (requestedInfoMemoryAllocationIncrement__);
requestInfo ();
}
}
bool BeaconLoader::sendBeacon(LocalFrame* frame, int allowance, const KURL& beaconURL, PassRefPtrWillBeRawPtr<DOMFormData>& data, int& payloadLength)
{
ASSERT(data);
ResourceRequest request(beaconURL);
prepareRequest(frame, request);
RefPtr<FormData> entityBody = data->createMultiPartFormData();
unsigned long long entitySize = entityBody->sizeInBytes();
if (allowance > 0 && static_cast<unsigned long long>(allowance) < entitySize)
return false;
AtomicString contentType = AtomicString("multipart/form-data; boundary=", AtomicString::ConstructFromLiteral) + entityBody->boundary().data();
request.setHTTPBody(entityBody.release());
request.setHTTPContentType(contentType);
issueRequest(frame, request);
payloadLength = entitySize;
return true;
}
bool BeaconLoader::sendBeacon(LocalFrame* frame, int allowance, const KURL& beaconURL, PassRefPtr<ArrayBufferView>& data, int& payloadLength)
{
ASSERT(data);
unsigned long long entitySize = data->byteLength();
if (allowance > 0 && static_cast<unsigned long long>(allowance) < entitySize)
return false;
ResourceRequest request(beaconURL);
prepareRequest(frame, request);
RefPtr<FormData> entityBody = FormData::create(data->baseAddress(), data->byteLength());
request.setHTTPBody(entityBody.release());
// FIXME: a reasonable choice, but not in the spec; should it give a default?
AtomicString contentType = AtomicString("application/octet-stream");
request.setHTTPContentType(contentType);
issueRequest(frame, request);
payloadLength = entitySize;
return true;
}
static int doRequest(HttpConn *conn, cchar *url, MprList *files)
{
MprFile *outFile;
cchar *path;
assert(url && *url);
if (issueRequest(conn, url, files) < 0) {
if (conn->rx && conn->rx->status) {
reportResponse(conn, url);
}
return MPR_ERR_CANT_CONNECT;
}
if (app->outFilename) {
path = app->loadThreads > 1 ? sfmt("%s-%s.tmp", app->outFilename, mprGetCurrentThreadName()): app->outFilename;
if ((outFile = mprOpenFile(path, O_CREAT | O_WRONLY | O_TRUNC | O_TEXT, 0664)) == 0) {
mprLog("error http", 0, "Cannot open %s", path);
return MPR_ERR_CANT_OPEN;
}
} else {
outFile = mprGetStdout();
}
mprAddRoot(outFile);
readBody(conn, outFile);
while (conn->state < HTTP_STATE_COMPLETE && !httpRequestExpired(conn, -1)) {
readBody(conn, outFile);
httpWait(conn, 0, -1);
}
if (conn->state < HTTP_STATE_COMPLETE && !conn->error) {
httpError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TIMEOUT, "Request timed out");
}
if (app->outFilename) {
mprCloseFile(outFile);
}
mprRemoveRoot(outFile);
reportResponse(conn, url);
httpDestroyRx(conn->rx);
httpDestroyTx(conn->tx);
return 0;
}
// ---------------------------------------------------------------------------
// From CActive.
// ---------------------------------------------------------------------------
//
void IRQNwkInfoObserverPrivate::RunL()
{
if(KErrNone == iStatus.Int())
{
if(iCurrentNetworkType)
{
//if the request was to find the current network changes
//then the value is updated
#ifdef __WINS__
iCurrentNwkMCC = "0";
iCurrentNwkMNC = "0";
#else
iCurrentNwkMCC = QString::fromUtf16( iCurrentNetworkInfo.iCountryCode.Ptr(),
iCurrentNetworkInfo.iCountryCode.Length());
iCurrentNwkMNC = QString::fromUtf16( iCurrentNetworkInfo.iNetworkId.Ptr(),
iCurrentNetworkInfo.iNetworkId.Length());
#endif
//updating mcc+mnc value
if(q_ptr)
{
emit q_ptr->currentNwkChanged(iCurrentNwkMCC,iCurrentNwkMNC);
}
iHomeNetworkType = ETrue;
iCurrentNetworkType = EFalse;
if(iFirstTime && iTelephony)
{
//if first time we have check the current operator is home operator
iTelephony->GetNetworkRegistrationStatus(iStatus,iHomeOperatorInfoPckg);
SetActive();
iFirstTime = EFalse;
}
else
{
//else issue request is called for notifying home operator change
issueRequest();
}
}
else if(iHomeNetworkType)
{
//home operator (or the change in home operator is notified.
#ifdef __WINS__
iHomeNetworkMCC = "0";
iHomeNetworkMNC = "0";
if(q_ptr)
{
emit q_ptr->homeNwkChanged(iHomeNetworkMCC,iHomeNetworkMNC);
}
#else
//if registration status shows that user is registered in home network
//and not in roaming status, the current operator is updated
if(CTelephony::ERegisteredOnHomeNetwork == iHomeOperatorInfo.iRegStatus)
{
iHomeNetworkMCC = iCurrentNwkMCC;
iHomeNetworkMNC = iCurrentNwkMNC;
if(q_ptr)
{
emit q_ptr->homeNwkChanged(iHomeNetworkMCC,iHomeNetworkMNC);
}
}
#endif
//issue request to find the current network change
iHomeNetworkType = EFalse;
iCurrentNetworkType = ETrue;
issueRequest();
}
else
{
return;
}
}
//if any error network is updated to zero
else
{
iCurrentNwkMCC = "0";
iCurrentNwkMNC = "0";
iHomeNetworkMCC = "0";
iHomeNetworkMNC = "0";
if(q_ptr)
{
emit q_ptr->currentNwkChanged(iCurrentNwkMCC,iCurrentNwkMNC);
emit q_ptr->homeNwkChanged(iHomeNetworkMCC,iHomeNetworkMNC);
}
}
}
void MemoryControl::executeCycle () {
// Keep track of time by counting down the busy counters:
for (int bank=0; bank < m_total_banks; bank++) {
if (m_bankBusyCounter[bank] > 0) m_bankBusyCounter[bank]--;
}
if (m_busBusyCounter_Write > 0) m_busBusyCounter_Write--;
if (m_busBusyCounter_ReadNewRank > 0) m_busBusyCounter_ReadNewRank--;
if (m_busBusyCounter_Basic > 0) m_busBusyCounter_Basic--;
// Count down the tFAW shift registers:
for (int rank=0; rank < m_total_ranks; rank++) {
if (m_tfaw_shift[rank] & 1) m_tfaw_count[rank]--;
m_tfaw_shift[rank] >>= 1;
}
// After time period expires, latch an indication that we need a refresh.
// Disable refresh if in memFixedDelay mode.
if (!m_memFixedDelay) m_refresh_count--;
if (m_refresh_count == 0) {
m_refresh_count = m_refresh_period_system;
assert (m_need_refresh < 10); // Are we overrunning our ability to refresh?
m_need_refresh++;
}
// If this batch of requests is all done, make a new batch:
m_ageCounter++;
int anyOld = 0;
for (int bank=0; bank < m_total_banks; bank++) {
anyOld |= m_oldRequest[bank];
}
if (!anyOld) {
for (int bank=0; bank < m_total_banks; bank++) {
if (!m_bankQueues[bank].empty()) m_oldRequest[bank] = 1;
}
m_ageCounter = 0;
}
// If randomness desired, re-randomize round-robin position each cycle
if (m_memRandomArbitrate) {
m_roundRobin = random() % m_total_banks;
}
// For each channel, scan round-robin, and pick an old, ready
// request and issue it. Treat a refresh request as if it
// were at the head of its bank queue. After we issue something,
// keep scanning the queues just to gather statistics about
// how many are waiting. If in memFixedDelay mode, we can issue
// more than one request per cycle.
int queueHeads = 0;
int banksIssued = 0;
for (int i = 0; i < m_total_banks; i++) {
m_roundRobin++;
if (m_roundRobin >= m_total_banks) m_roundRobin = 0;
issueRefresh(m_roundRobin);
int qs = m_bankQueues[m_roundRobin].size();
if (qs > 1) {
g_system_ptr->getProfiler()->profileMemBankQ(qs-1);
}
if (qs > 0) {
m_idleCount = IDLECOUNT_MAX_VALUE; // we're not idle if anything is queued
queueHeads++;
if (queueReady(m_roundRobin)) {
issueRequest(m_roundRobin);
banksIssued++;
if (m_memFixedDelay) {
g_system_ptr->getProfiler()->profileMemWaitCycles(m_memFixedDelay);
}
}
}
}
// memWaitCycles is a redundant catch-all for the specific counters in queueReady
g_system_ptr->getProfiler()->profileMemWaitCycles(queueHeads - banksIssued);
// Check input queue and move anything to bank queues if not full.
// Since this is done here at the end of the cycle, there will always
// be at least one cycle of latency in the bank queue.
// We deliberately move at most one request per cycle (to simulate
// typical hardware). Note that if one bank queue fills up, other
// requests can get stuck behind it here.
if (!m_input_queue.empty()) {
m_idleCount = IDLECOUNT_MAX_VALUE; // we're not idle if anything is pending
MemoryNode req = m_input_queue.front();
int bank = getBank(req.m_addr);
if (m_bankQueues[bank].size() < m_bank_queue_size) {
m_input_queue.pop_front();
m_bankQueues[bank].push_back(req);
}
g_system_ptr->getProfiler()->profileMemInputQ(m_input_queue.size());
}
}
