const pair<unsigned int, string> UUID2Address::processResponse() {
boost::asio::streambuf response;
std::istream responseStream(&response);
boost::asio::read_until(mSocket, response, "\r\n");
std::string httpVersion;
responseStream >> httpVersion;
unsigned int statusCode;
responseStream >> statusCode;
std::string statusMessage;
getline(responseStream, statusMessage);
if (!responseStream || httpVersion.substr(0, 5) != "HTTP/") {
throw ValueError(
"UUID2Address::processResponse: "
"Invalid response from the remote service");
}
switch (statusCode) {
case 200: {
boost::asio::read_until(mSocket, response, "\r\n\r\n");
string header;
while (getline(responseStream, header) && header != "\r") {}
if (response.size() > 0) {
string data(
(istreambuf_iterator<char>(&response)),
istreambuf_iterator<char>()
);
return make_pair(
statusCode,
data
);
} else {
throw ValueError("UUID2Address::processResponse: "
"Empty response body from the remote service");
}
}
case 400:
case 404:
case 500: {
return make_pair(
statusCode,
string()
);
}
default: {
throw IOError("UUID2Address::processResponse: "
"Unexpected response code");
}
}
}
void SMTPClientSession::loginUsingLogin(const std::string& username, const std::string& password)
{
std::string response;
int status = sendCommand("AUTH LOGIN", response);
if (!isPositiveIntermediate(status)) throw SMTPException("Cannot authenticate using LOGIN", response, status);
std::ostringstream usernameBase64;
Base64Encoder usernameEncoder(usernameBase64);
usernameEncoder.rdbuf()->setLineLength(0);
usernameEncoder << username;
usernameEncoder.close();
std::ostringstream passwordBase64;
Base64Encoder passwordEncoder(passwordBase64);
passwordEncoder.rdbuf()->setLineLength(0);
passwordEncoder << password;
passwordEncoder.close();
//Server request for username/password not defined could be either
//S: login:
//C: user_login
//S: password:
//C: user_password
//or
//S: password:
//C: user_password
//S: login:
//C: user_login
std::string decodedResponse;
std::istringstream responseStream(response.substr(4));
Base64Decoder responseDecoder(responseStream);
StreamCopier::copyToString(responseDecoder, decodedResponse);
if (Poco::icompare(decodedResponse, 0, 8, "username") == 0) // username first (md5("Username:"******"Login using LOGIN username failed", response, status);
status = sendCommand(passwordBase64.str(), response);
if (!isPositiveCompletion(status)) throw SMTPException("Login using LOGIN password failed", response, status);
}
else if (Poco::icompare(decodedResponse, 0, 8, "password") == 0) // password first (md5("Password:"******"Login using LOGIN password failed", response, status);
status = sendCommand(usernameBase64.str(), response);
if (!isPositiveCompletion(status)) throw SMTPException("Login using LOGIN username failed", response, status);
}
}
void GPUdb::submitRequestRaw(const std::string& endpoint, const std::vector<uint8_t>& request, GpudbResponse& response, const bool enableCompression) const
{
try
{
boost::asio::io_service ioService;
boost::asio::ip::tcp::resolver resolver(ioService);
boost::asio::ip::tcp::resolver::query query(host, service);
boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
boost::asio::ip::tcp::socket socket(ioService);
boost::asio::connect(socket, iterator);
boost::asio::streambuf requestStreamBuffer;
std::ostream requestStream(&requestStreamBuffer);
requestStream << "POST " << path << endpoint << " HTTP/1.0\r\n";
if (!authorization.empty())
{
requestStream << "Authorization: Basic " << authorization << "\r\n";
}
if (enableCompression && useSnappy)
{
std::string compressedRequest;
snappy::Compress((char*)&request[0], request.size(), &compressedRequest);
requestStream << "Content-Type: application/x-snappy\r\n";
requestStream << "Content-Length: " << compressedRequest.size() << "\r\n";
requestStream << "\r\n";
boost::asio::write(socket, requestStreamBuffer);
boost::asio::write(socket, boost::asio::buffer(compressedRequest));
}
else
{
requestStream << "Content-Type: application/octet-stream\r\n";
requestStream << "Content-Length: " << request.size() << "\r\n";
requestStream << "\r\n";
boost::asio::write(socket, requestStreamBuffer);
boost::asio::write(socket, boost::asio::buffer(request));
}
boost::asio::streambuf responseStreamBuffer;
boost::asio::read_until(socket, responseStreamBuffer, "\r\n\r\n");
std::istream responseStream(&responseStreamBuffer);
std::string header;
std::getline(responseStream, header);
if (!responseStream || header.substr(0, 5) != "HTTP/")
{
throw GPUdbException("Invalid response from server.");
}
do
{
std::getline(responseStream, header);
}
while (header != "\r");
std::vector<uint8_t> responseBytes;
boost::system::error_code error;
do
{
boost::asio::streambuf::const_buffers_type data = responseStreamBuffer.data();
size_t totalRead = 0;
for (boost::asio::streambuf::const_buffers_type::const_iterator it = data.begin(); it != data.end(); ++it)
{
const uint8_t* buffer = boost::asio::buffer_cast<const uint8_t*>(*it);
size_t read = boost::asio::buffer_size(*it);
responseBytes.insert(responseBytes.end(), buffer, buffer + read);
totalRead += read;
}
responseStreamBuffer.consume(totalRead);
}
while (boost::asio::read(socket, responseStreamBuffer, boost::asio::transfer_at_least(1), error));
if (error != boost::asio::error::eof)
{
throw boost::system::system_error(error);
}
avro::decode(response, responseBytes);
if (response.status == "ERROR")
{
throw GPUdbException(response.message);
}
}
catch (const boost::system::system_error& ex)
{
throw GPUdbException(std::string(ex.what()));
}
}
int main( int argc, char * argv[] )
{
if( argc != 6 ){
std::cerr << "Usage: " << argv[0] << " host file proxy_host proxt_port authorization" << std::endl;
return 1;
}
std::string const host = argv[1];
std::string const file = argv[2];
std::string const proxyHost = argv[3];
std::string const proxyPort = argv[4];
std::string const authorization = argv[5];
asio::io_service io_service;
asio::ip::tcp::resolver resolver( io_service );
asio::ip::tcp::resolver::query const query( proxyHost, proxyPort );
asio::ip::tcp::resolver::iterator endpointIterator = resolver.resolve( query );
asio::ip::tcp::socket socket( io_service );
asio::connect( socket, endpointIterator );
asio::streambuf requestBuffer;
std::ostream requestStream( & requestBuffer );
requestStream << "GET " << host << "/" << file << " HTTP/1.0\r\n";
requestStream << "Host: " << host << "\r\n";
requestStream << "Accept: */*\r\n";
if( authorization != "" ){
requestStream << "Proxy-Authorization: Basic " << authorization << "\n\r";
}
requestStream << "Connection: close\r\n\r\n";
asio::write( socket, requestBuffer );
asio::streambuf response_buffer;
std::istream responseStream( & response_buffer );
asio::read_until( socket, response_buffer, "\r\n");
std::string httpVersion;
responseStream >> httpVersion;
unsigned status_code;
responseStream >> status_code;
std::string status_message;
std::getline( responseStream, status_message );
if( ! responseStream || httpVersion.substr( 0, 5 ) != "HTTP/" )
{
std::cerr << "Invalid response\n";
return 2;
}
if( status_code != 200 )
{
std::cerr << "Response returned with status code " << status_code << "\n";
return 3;
}
asio::read_until( socket, response_buffer, "\r\n\r\n" );
std::string header;
while( std::getline( responseStream, header ) && header != "\r" ){
std::cout << "> " << header << "\n";
}
std::cout << std::endl;
boost::system::error_code error;
while( asio::read( socket, response_buffer, asio::transfer_at_least( 1 ), error ) ){
std::cout << & response_buffer;
}
if( error != asio::error::eof ){
std::cerr << boost::system::system_error( error ).what() << "\n";
return 4;
}
return 0;
}
