Esempio n. 1
0
void HttpClient::onRequest(Http::Client& client)
{
    try
    {
        Pt::Http::MessageProgress progress = client.endSend();
        if( ! progress.finished() )
        {
            client.beginSend(false);
            return;
        }

        while( ! advanceMessage() )
        {
            if(client.request().buffer().size() > 8192)
            {
                client.beginSend(false);
                return;
            }
        }
        
        finishMessage();

        client.beginReceive();
    }
    catch(const System::IOError&) // HttpError is also an IOError
    {
        // setError() makes finishResult() call onError() where we throw
        setError();
        finishResult();
    }
}
Esempio n. 2
0
  virtual void getIdentity(const OAuthAccessToken& token)
  {
    Http::Client *client = new Http::Client(this);
    client->setTimeout(15);
    client->setMaximumResponseSize(10*1024);

    client->done().connect
      (boost::bind(&FacebookProcess::handleMe, this, _1, _2));
    client->get("https://graph.facebook.com/me?fields=name,id,email&access_token=" + token.value());

#ifndef WT_TARGET_JAVA
    WApplication::instance()->deferRendering();
#endif
  }
Esempio n. 3
0
std::size_t HttpClientImpl::onReplyBody(http::Client& client)
{
    std::size_t count = 0;
    char ch;
    std::istream& is = client.in();
    while (is.rdbuf()->in_avail() && is.get(ch))
    {
        ++count;
        if (_scanner.advance(ch))
        {
            log_debug("scanner finished");
            try
            {
                _scanner.finalizeReply();
            }
            catch (const RemoteException& e)
            {
                _proc->setFault(e.rc(), e.text());
            }
            catch (const std::exception&)
            {
                log_warn("exception occured in finalizeReply");
                _exceptionPending = true;
                _proc->onFinished();
            }

            break;
        }
    }

    log_debug("no more data - " << count << " bytes consumed");

    return count;
}
Esempio n. 4
0
void HttpClient::onReply(Http::Client& client)
{
    try
    {
        Http::MessageProgress progress = client.endReceive();

        if( progress.header() )
        {
            //_impl->verifyHeader( client.reply() );
            
            beginResult( client.reply().body() );
        }

        if( progress.body() )
        {
            // reads until error or XML was consumed
            parseResult();

            // discard remaining data
            client.reply().discard();
        }
        
        if( ! progress.finished() )
        { 
            client.beginReceive();
            return;
        }
    }
    catch(const System::IOError&) // HttpError is also an IOError
    {
        // finished signal will call onError()
        setError();
        finishResult();
        return;
    }

    // send finished signal
    finishResult();
}
Esempio n. 5
0
    // This call retrieves information about LinkedIn user: basic profile info and email address (as defined by the scope member variable):
    virtual void getIdentity(const OAuthAccessToken& token)
    {
      // Create Http REST client object:
      Http::Client *client = new Http::Client(this);
      client->setTimeout(15);
      client->setMaximumResponseSize(10*1024);

      // Tell how to handle the response:
      client->done().connect(boost::bind(&LinkedInProcess::handleMe, this, _1, _2));

      // Initialize request headers:
      std::vector<Http::Message::Header> headers;
      headers.push_back(Http::Message::Header("Authorization",
        "Bearer " + token.value()));

      const char *UserInfoUrl = "https://api.linkedin.com/v1/people/~:(id,num-connections,first-name,last-name,headline,location,email-address,positions,public-profile-url)?format=json";
      client->get(UserInfoUrl, headers);

#ifndef WT_TARGET_JAVA
      WApplication::instance()->deferRendering();
#endif
    }
Esempio n. 6
0
    void request(Settings settings, http::Headers headers, std::string body,
                 http::RequestCallback &&callback) {

        http_client.request(
            settings, headers,
            body, [=](Error error, http::Response &&response) {

                YAML::Node rr;
                rr["request"]["headers"] =
                    std::map<std::string, std::string>(headers);
                rr["request"]["body"] = body;
                rr["request"]["url"] = settings.at("url");
                rr["request"]["http_version"] = settings.at("http_version");
                rr["request"]["method"] = settings.at("method");

                // XXX we should probably update the OONI data format to remove
                // this.
                rr["method"] = settings.at("method");

                if (error == 0) {
                    rr["response"]["headers"] =
                        std::map<std::string, std::string>(response.headers);
                    rr["response"]["body"] = response.body;
                    rr["response"]["response_line"] = response.response_line;
                    rr["response"]["code"] = response.status_code;
                } else {
                    rr["failure"] = "unknown_failure measurement_kit_error";
                    rr["error_code"] = (int)error;
                }

                entry["requests"].push_back(rr);
                entry["agent"] = "agent";
                entry["socksproxy"] = "";
                callback(error, std::move(response));
            }, &logger);
    };
Esempio n. 7
0
size_t HTTPFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data) {
	s64 absoluteEnd = std::min(absolutePos + (s64)bytes, filesize_);
	if (absolutePos >= filesize_ || bytes == 0) {
		// Read outside of the file or no read at all, just fail immediately.
		return 0;
	}

	Connect();

	char requestHeaders[4096];
	// Note that the Range header is *inclusive*.
	snprintf(requestHeaders, sizeof(requestHeaders),
		"Range: bytes=%lld-%lld\r\n", absolutePos, absoluteEnd - 1);

	int err = client_.SendRequest("GET", url_.Resource().c_str(), requestHeaders, nullptr);
	if (err < 0) {
		Disconnect();
		return 0;
	}

	Buffer readbuf;
	std::vector<std::string> responseHeaders;
	int code = client_.ReadResponseHeaders(&readbuf, responseHeaders);
	if (code != 206) {
		ERROR_LOG(LOADER, "HTTP server did not respond with range, received code=%03d", code);
		Disconnect();
		return 0;
	}

	// TODO: Expire cache via ETag, etc.
	// We don't support multipart/byteranges responses.
	bool supportedResponse = false;
	for (std::string header : responseHeaders) {
		if (startsWithNoCase(header, "Content-Range:")) {
			// TODO: More correctness.  Whitespace can be missing or different.
			s64 first = -1, last = -1, total = -1;
			std::string lowerHeader = header;
			std::transform(lowerHeader.begin(), lowerHeader.end(), lowerHeader.begin(), tolower);
			if (sscanf(lowerHeader.c_str(), "content-range: bytes %lld-%lld/%lld", &first, &last, &total) >= 2) {
				if (first == absolutePos && last == absoluteEnd - 1) {
					supportedResponse = true;
				} else {
					ERROR_LOG(LOADER, "Unexpected HTTP range: got %lld-%lld, wanted %lld-%lld.", first, last, absolutePos, absoluteEnd - 1);
				}
			} else {
				ERROR_LOG(LOADER, "Unexpected HTTP range response: %s", header.c_str());
			}
		}
	}

	// TODO: Would be nice to read directly.
	Buffer output;
	int res = client_.ReadResponseEntity(&readbuf, responseHeaders, &output);
	if (res != 0) {
		ERROR_LOG(LOADER, "Unable to read HTTP response entity: %d", res);
		// Let's take anything we got anyway.  Not worse than returning nothing?
	}

	// TODO: Keepalive instead.
	Disconnect();

	if (!supportedResponse) {
		ERROR_LOG(LOADER, "HTTP server did not respond with the range we wanted.");
		return 0;
	}

	size_t readBytes = output.size();
	output.Take(readBytes, (char *)data);
	filepos_ = absolutePos + readBytes;
	return readBytes;
}
Esempio n. 8
0
void HttpClientImpl::onReplyHeader(http::Client& client)
{
    verifyHeader(client.header());
}