const bool RPCRequest::DoRequest(const std::string &data, std::string &result)
{
int rval=-1;
m_writebuff.clear();
m_readbuff.assign(data.begin(),data.end());
std::vector<std::string::value_type> vuserpass;
if(m_curl)
{
struct curl_slist *headers=0;
curl_easy_setopt(m_curl,CURLOPT_URL,m_url.c_str());
curl_easy_setopt(m_curl,CURLOPT_ENCODING,"");
curl_easy_setopt(m_curl,CURLOPT_FAILONERROR,1);
curl_easy_setopt(m_curl,CURLOPT_TCP_NODELAY,1);
curl_easy_setopt(m_curl,CURLOPT_WRITEFUNCTION,RPCRequest::WriteData);
curl_easy_setopt(m_curl,CURLOPT_WRITEDATA,this);
curl_easy_setopt(m_curl,CURLOPT_READFUNCTION,RPCRequest::ReadData);
curl_easy_setopt(m_curl,CURLOPT_READDATA,this);
if(m_user!="" && m_password!="")
{
std::string userpass(m_user+":"+m_password);
// Apparenty, libCURL doesn't copy the string immediately, so scoped variables will not work,
// so we'll use a vector declared previously in the method.
vuserpass.assign(userpass.begin(),userpass.end());
vuserpass.push_back(0);
curl_easy_setopt(m_curl,CURLOPT_USERPWD,&vuserpass[0]);
curl_easy_setopt(m_curl,CURLOPT_HTTPAUTH,CURLAUTH_BASIC);
}
curl_easy_setopt(m_curl,CURLOPT_POST,1);
std::ostringstream istr;
istr << m_readbuff.size();
std::string headersize("Content-Length: "+istr.str());
headers=curl_slist_append(headers,"Content-type: application/json");
headers=curl_slist_append(headers,headersize.c_str());
headers=curl_slist_append(headers,"Expect:");
curl_easy_setopt(m_curl, CURLOPT_HTTPHEADER, headers);
rval=curl_easy_perform(m_curl);
m_lastcurlreturn=rval;
if(m_writebuff.size()>0)
{
result.assign(m_writebuff.begin(),m_writebuff.end());
}
else
{
result="";
}
curl_slist_free_all(headers);
}
return (rval==0);
}
void
FastTcpAgent::output(int seqno, int reason)
{
Packet* p = allocpkt();
hdr_tcp *tcph = hdr_tcp::access(p);
double now = Scheduler::instance().clock();
hdr_flags* hf = hdr_flags::access(p);
hdr_ip *iph = hdr_ip::access(p);
int databytes = hdr_cmn::access(p)->size();
tcph->seqno() = seqno;
tcph->ts() = now;
tcph->reason() = reason;
/* if this is the 1st pkt, setup senttime[] and transmits[]
* I alloc mem here, instrad of in the constructor, to cover
* cases which windows get set by each different tcp flows */
if (seqno==0) {
maxwnd_ = int(wnd_);
if (sendtime_)
delete []sendtime_;
if (transmits_)
delete []transmits_;
if (cwnd_array_)
delete []cwnd_array_;
sendtime_ = new double[maxwnd_];
transmits_ = new int[maxwnd_];
cwnd_array_= new double[maxwnd_];
for(int i=0;i<maxwnd_;i++) {
sendtime_[i] = -1.;
transmits_[i] = 0;
cwnd_array_[i]=-1;
}
}
if (ecn_) {
hf->ect() = 1; // ECN capable transport.
}
/* Check if this is the initial SYN packet. */
if (seqno == 0) {
if (syn_) {
databytes= 0;
curseq_ += 1;
hdr_cmn::access(p)->size() = tcpip_base_hdr_size_;
}
if (ecn_) {
hf->ecnecho() = 1;
// hf->cong_action() = 1;
hf->ect() = 0;
}
}
else if (useHeaders_ == true) {
hdr_cmn::access(p)->size() += headersize();
}
// record a find grained send time and # of transmits
int index = seqno % maxwnd_;
sendtime_[index] = fasttime();
cwnd_array_[index]=avg_cwnd_last_RTT_;
++transmits_[index];
/* support ndatabytes_ in output - Lloyd Wood 14 March 2000 */
int bytes = hdr_cmn::access(p)->size();
ndatabytes_ += bytes;
ndatapack_++; // Added this - Debojyoti 12th Oct 2000
send(p, 0);
if (seqno == curseq_ && seqno > maxseq_)
idle(); // Tell application I have sent everything so far
if (seqno > maxseq_) {
maxseq_ = seqno;
if (!rtt_active_) {
rtt_active_ = 1;
if (seqno > rtt_seq_) {
rtt_seq_ = seqno;
rtt_ts_ = now;
}
}
} else {
++nrexmitpack_;
nrexmitbytes_ += bytes;
}
if (!(rtx_timer_.status() == TIMER_PENDING))
/* No timer pending. Schedule one. */
set_rtx_timer();
}
v8::Handle<v8::Value> QV8Worker::deserialize(const char *&data, QV8Engine *engine)
{
quint32 header = popUint32(data);
Type type = headertype(header);
switch (type) {
case WorkerUndefined:
return v8::Undefined();
case WorkerNull:
return v8::Null();
case WorkerTrue:
return v8::True();
case WorkerFalse:
return v8::False();
case WorkerString:
{
quint32 size = headersize(header);
v8::Local<v8::String> string = v8::String::New((uint16_t*)data, size - 1);
data += ALIGN(size * sizeof(uint16_t));
return string;
}
case WorkerFunction:
Q_ASSERT(!"Unreachable");
break;
case WorkerArray:
{
quint32 size = headersize(header);
v8::Local<v8::Array> array = v8::Array::New(size);
for (quint32 ii = 0; ii < size; ++ii) {
array->Set(ii, deserialize(data, engine));
}
return array;
}
case WorkerObject:
{
quint32 size = headersize(header);
v8::Local<v8::Object> o = v8::Object::New();
for (quint32 ii = 0; ii < size; ++ii) {
v8::Handle<v8::Value> name = deserialize(data, engine);
v8::Handle<v8::Value> value = deserialize(data, engine);
o->Set(name, value);
}
return o;
}
case WorkerInt32:
return v8::Integer::New((qint32)popUint32(data));
case WorkerUint32:
return v8::Integer::NewFromUnsigned(popUint32(data));
case WorkerNumber:
return v8::Number::New(popDouble(data));
case WorkerDate:
return v8::Date::New(popDouble(data));
case WorkerRegexp:
{
quint32 flags = headersize(header);
quint32 length = popUint32(data);
v8::Local<v8::String> source = v8::String::New((uint16_t*)data, length - 1);
data += ALIGN(length * sizeof(uint16_t));
return v8::RegExp::New(source, (v8::RegExp::Flags)flags);
}
case WorkerListModel:
{
void *ptr = popPtr(data);
QDeclarativeListModelWorkerAgent *agent = (QDeclarativeListModelWorkerAgent *)ptr;
v8::Handle<v8::Value> rv = engine->newQObject(agent);
if (rv->IsObject()) {
QDeclarativeListModelWorkerAgent::VariantRef ref(agent);
QVariant var = qVariantFromValue(ref);
rv->ToObject()->SetHiddenValue(v8::String::New("qml::ref"), engine->fromVariant(var));
}
agent->release();
agent->setV8Engine(engine);
return rv;
}
}
Q_ASSERT(!"Unreachable");
return v8::Undefined();
}
