void AudioManager::play_stream_playlist(StreamPlaylist *playlist, float volume)
{
OggVorbisStream *stream;
if (!playlist->started){
stream = request_stream(&playlist->stream_idx);
if (stream){
playlist->it = playlist->files.begin();
stream->open((*playlist->it).c_str());
stream->set_volume(volume);
stream->set_playback_volume(volume);
stream->play(AUDIO_PLAYMODE_ONCE);
playlist->it++;
playlist->started = true;
}
}
else {
stream = get_audio_stream(playlist->stream_idx);
if (stream && !stream->is_playing()){
if (!(playlist->it == playlist->files.end())){
stream->close();
stream->open((*playlist->it).c_str());
stream->set_volume(volume);
stream->set_playback_volume(volume);
stream->play(AUDIO_PLAYMODE_ONCE);
playlist->it++;
}
}
}
if (playlist->loop && playlist->it == playlist->files.end())
playlist->it = playlist->files.begin();
}
void stratum_client::handle_connect(const boost::system::error_code& err)
{
if (!inited_)
return;
if (!err)
{
{
std::cout << "Try to login..." << std::endl;
std::ostream request_stream(&request_);
request_stream << "{\"id\": 1, \"method\": \"login\", "
"\"params\": { "
"\"login\":\"" << login_ << "\","
"\"pass\" : \"" << pwd_ << "\", "
"\"agent\" : \"embedded_miner/1.0\""
"}"
"}\n";
}
boost::asio::async_write(socket_, request_,
boost::bind(&stratum_client::handle_write_completed, this,
boost::asio::placeholders::error));
}
else
{
ec_(err.value(), err.message(), this);
}
}
/* Read the request from the socket, returning in a nice binary format.
* The return value should be subject to NRVO, so it will be fast
*/
static Request read_request(int fd)
{
Request retval;
std::unique_ptr<char[]> client_request(new char[client_request_size+1]);
int amount_read;
/* Get the request from the socket. */
if ((amount_read = read(fd,client_request.get(),client_request_size))==-1) {
server_error(fd,500);
throw; // TODO: choose a good exception to throw
} else {
client_request[amount_read]=0; // Make sure we have a valid C string
}
main_log << DEBUG << "Read Client Request:" << client_request.get();
/* Parse the request header */
std::stringstream request_stream(client_request.get());;
request_stream >> retval.method;
request_stream >> retval.URI;
request_stream >> retval.http_version;
if (request_stream.fail()) {
main_log << WARNING << "Received a bad request:\n" << client_request.get();
server_error(fd,400);
throw; // TODO: throw a proper exception
} else {
main_log << DEBUG << "Method: " << retval.method << '\n';
main_log << "Request URI: " << retval.URI << '\n';
main_log << "HTTP Version: " << retval.http_version << '\n';
}
std::swap(retval.raw,client_request);
return retval;
}
bool Simloid::load_snapshot () throw ()
{
if (!_initialized) return false;
#ifdef FOUND_boost
std::ostream request_stream(&_request);
request_stream << "(load)\n(done)\n";
boost::asio::write(*_socket, _request);
#endif
return true;
}
void AudioManager::play_stream(const char *fname, float volume, AUDIO_PLAYMODE mode, int *stream_idx)
{
OggVorbisStream *stream = request_stream(stream_idx);
if (stream){
stream->open(fname);
stream->set_volume(volume);
stream->set_playback_volume(volume);
stream->play(mode);
}
}
void Detection::CheckIP()
{
std::ofstream fout("text.txt", std::ofstream::ate|std::ofstream::app);
fout << "\n**********************************************************************\n";
fout << "2. Checkip" << std::endl;
boost::asio::io_service io_service;
boost::asio::ip::tcp::resolver resolver(io_service);
boost::asio::ip::tcp::resolver::query query("jump.g1d.net", "http");
boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
boost::asio::ip::tcp::resolver::iterator end;
// Try each endpoint until we successfully establish a connection.
boost::asio::ip::tcp::socket socket(io_service);
boost::system::error_code error = boost::asio::error::host_not_found;
while (error && endpoint_iterator != end)
{
socket.close();
socket.connect(*endpoint_iterator++, error);
}
if (error)
{
fout << "域名解析失败!" << std::endl;
}
// Form the request. We specify the "Connection: close" header so that the
// server will close the socket after transmitting the response. This will
// allow us to treat all data up until the EOF as the content.
boost::asio::streambuf request;
std::ostream request_stream(&request);
request_stream << "GET " << "/checkip.jsp" << " HTTP/1.0\r\n";
request_stream << "Host: " << "jump.g1d.net" << "\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Connection: close\r\n\r\n";
// Send the request.
boost::asio::write(socket, request);
// Read the response status line.
boost::asio::streambuf response;
boost::asio::read(socket, response, boost::asio::transfer_all(), error);
std::istream response_stream(&response);
std::string response_string;
while (std::getline(response_stream, response_string))
{
if (response_string.find("用户来源IP") != std::string::npos || response_string.find("来源IP服务的ID:") != std::string::npos)
{
fout << response_string.substr(0, response_string.find('<')) << std::endl;
}
}
fout.close();
++m_progress_pos_;
}
void CLineServer::MessageHandler( const boost::system::error_code & p_error )
{
if( !p_error )
{
boost::asio::streambuf request;
std::istream request_stream( &request );
std::string request_code, device, key, value;
boost::asio::streambuf response;
std::ostream response_stream( &response );
bool quit = false;
size_t bytes;
try
{
while( !quit )
{
// receive the request stream and get the request type
bytes = boost::asio::read_until( m_socket, request, "\r\n" );
request_stream >> request_code;
// handle different message types
if( request_code == "GET" )
{
// split the request stream
request_stream >> device >> key;
std::cerr << "GET " << device << " " << key;
value = m_get(device,key);
std::cerr << " " << value << std::endl;
// format the response stream
if( value.empty() )
{
response_stream << "404 ERROR NOTFOUND\r\n";
}
else
{
response_stream << "200 OK " << value << "\r\n";
}
}
else if( request_code == "SET" )
{
// split the request stream
request_stream >> device >> key >> value;
std::cerr << "SET " << device << " " << key << " " << value << std::endl;
m_set(device,key,value);
// format the response stream
response_stream << "200 OK\r\n";
}
void IrcClient::send_data(const char* data,const size_t len)
{
std::string msg;
msg.append(data,len);
std::ostream request_stream(&request_);
request_stream << msg;
boost::asio::async_write(socket_, request_,
boost::bind(&IrcClient::handle_write_request, this,
boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
void kithleighSerial::compose_request(const std::string &buf)
{
// std::cout<<"composed_"<<std::endl;
// boost::asio::streambuf buff;
// std::ostream request_stream(&buff);
std::ostream request_stream(&request_);
request_stream <<buf.c_str()<< "\r";
std::cout<<"composed_"<<&request_<<std::endl;
return;
}
void connection<tcpContext>::compose_request_stream(const std::string &buf)
{
std::ostream request_stream(&request_);
std::string port_name = this->server;
std::string host_path = "/scpi_response.html?cmd=";
request_stream << "GET " << host_path.c_str()<<buf.c_str()<< " HTTP/1.0\r\n";
request_stream << "Host: " << this->server<< "\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Connection: close\r\n\r\n";
}
gcm_request& gcm_request::operator= (const gcm_request& other)
{
if (this != &other)
{
// TODO: dirty.. find a better way to copy data
std::ostream request_stream(&request_);
boost::asio::streambuf::const_buffers_type bufs = other.request_.data();
std::string s(boost::asio::buffers_begin(bufs), boost::asio::buffers_begin(bufs) + other.request_.size());
request_stream << s;
ident_ = other.ident_;
}
return *this;
}
xreturn::r<std::string> ActionImplement::Telnet(const std::string& host,int port,const std::string& wait,const std::string& send,const std::string& recv)
{
//ASIO作成
boost::asio::io_service io_service;
//名前解決
boost::asio::ip::tcp::resolver resolver(io_service);
boost::asio::ip::tcp::resolver::query query(host , num2str( port ));
boost::asio::ip::tcp::endpoint endpoint(*resolver.resolve(query));
boost::asio::ip::tcp::socket socket(io_service);
//接続
boost::system::error_code error ;
socket.connect(endpoint,error);
if (error)
{
return xreturn::error("ホストに接続できません host:" + host + " port:" + num2str(port) );
}
//まずは相手の言い分を聞きます.
if (!wait.empty())
{
boost::asio::streambuf wait_body;
boost::asio::read_until(socket, wait_body,wait ,error );
}
//送信
if (!send.empty() )
{
boost::asio::streambuf request;
std::ostream request_stream(&request);
request_stream << send << std::flush;
boost::asio::write(socket, request);
}
std::string ret;
//最後に会いての言い分を聞いてから通信を切ります。
if (!recv.empty())
{
//貴方の意見は？
boost::asio::streambuf respons_body;
boost::asio::read_until(socket, respons_body,recv ,error );
ret = boost::asio::buffer_cast<const char*>(respons_body.data());
}
return ret;
}
bool Simloid::reset () throw ()
{
if (!_initialized) return false;
_initialized = false;
#ifdef FOUND_boost
std::ostream request_stream(&_request);
request_stream << "(reset)\n";
for (int i=1; i<20; i++) request_stream << "(pid " << i << " 512)\n";
request_stream << "(done)\n";
boost::asio::write(*_socket, _request);
#endif
for (int i=0; i<19; i++) _target[i] = _hold ? 512 : -1;
step();
step();
_initialized = true;
return true;
}
gcm_request::gcm_request(const device& /*dev*/,
const std::string& api_key,
const std::string& payload,
const uint32_t& ident)
: ident_(ident)
{
std::ostream request_stream(&request_);
request_stream << "POST /gcm/send HTTP/1.1\r\n";
request_stream << "User-Agent: push_service\r\n";
request_stream << "Host: android.googleapis.com\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Content-Type: application/json\r\n";
request_stream << "Authorization: key=" << api_key << "\r\n";
request_stream << "Connection: Keep-Alive\r\n";
request_stream << "Content-Length:" << payload.size() << "\r\n\r\n";
request_stream << payload;
}
void stratum_client::handle_job_succeeded(const std::string& job_id,
uint32_t nonce, const binary& hash)
{
std::cout << "job [" << job_id << "] succeeded, " <<
nonce << std::endl;
{
std::ostringstream oss;
oss << "{\"method\": \"submit\", \"params\": "
"{\"id\": \"" << rpc_id_ << "\", \"job_id\": \"" << job_id <<
"\", \"nonce\": \"" << std::string(hex_string(nonce)) <<
"\", \"result\": \"" << std::string(hex_string(hash)) <<
"\"}, \"id\":1}\n";
std::ostream request_stream(&request_);
request_stream << oss.str();
}
boost::asio::async_write(socket_, request_,
boost::bind(&stratum_client::handle_write_completed, this,
boost::asio::placeholders::error));
}
bool Simloid::init () throw ()
{
#ifdef FOUND_boost
_initialized = true;
_io = new boost::asio::io_service();
_socket = new tcp::socket(*_io);
tcp::resolver resolver(*_io);
tcp::resolver::query query("localhost", "7777");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::resolver::iterator end;
boost::system::error_code error = boost::asio::error::host_not_found;
while (error && endpoint_iterator != end) {
_socket->close();
_socket->connect(*endpoint_iterator++, error);
}
if (error) return false;
for (int i=0; i<19; i++) _target[i] = _hold ? 512 : -1;
std::ostream request_stream(&_request);
for (int i=1; i<20; i++) request_stream << "(pid " << i << " 512)\n";
request_stream << "(done)\n";
boost::asio::write(*_socket, _request);
step();
return true;
#else
_initialized = false;
std::cout << "Error: cannot initialize Simloid interface without boost libraries." << std::endl;
return false;
#endif
}
HttpClient::HttpClient(boost::asio::io_service& io_service,
const std::string& server, const std::string& path, HttpResponseHandler responseHandler)
: resolver_(io_service),
socket_(io_service),
responseStream(new std::stringstream)
{
// Form the request. We specify the "Connection: close" header so that the
// server will close the socket after transmitting the response. This will
// allow us to treat all data up until the EOF as the content.
this->responseHandler = responseHandler;
std::ostream request_stream(&request_);
request_stream << "GET " << path << " HTTP/1.0\r\n";
request_stream << "Host: " << server << "\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Connection: close\r\n\r\n";
// Start an asynchronous resolve to translate the server and service names
// into a list of endpoints.
tcp::resolver::query query(server, "http");
resolver_.async_resolve(query,
boost::bind(&HttpClient::handle_resolve, this,
boost::asio::placeholders::error,
boost::asio::placeholders::iterator));
}
void Detection::Test9KAPPPAC()
{
std::ofstream fout("text.txt", std::ofstream::ate|std::ofstream::app);
fout << "\n**********************************************************************\n";
fout << "6. Test 9000 Port" << std::endl;
boost::asio::io_service io_service;
boost::asio::ip::tcp::resolver resolver(io_service);
boost::asio::ip::tcp::resolver::query query("localhost", "9000");
boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
boost::asio::ip::tcp::resolver::iterator end;
// Try each endpoint until we successfully establish a connection.
boost::asio::ip::tcp::socket socket(io_service);
boost::system::error_code error = boost::asio::error::host_not_found;
while (error && endpoint_iterator != end)
{
socket.close();
socket.connect(*endpoint_iterator++, error);
}
if (error)
{
fout << "域名解析失败!" << std::endl;
return;
}
// Form the request. We specify the "Connection: close" header so that the
// server will close the socket after transmitting the response. This will
// allow us to treat all data up until the EOF as the content.
boost::asio::streambuf request;
std::ostream request_stream(&request);
request_stream << "GET " << "/application.pac" << " HTTP/1.1\r\n";
request_stream << "Host: " << "localhost:9000" << "\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Connection: close\r\n\r\n";
// Send the request.
boost::asio::write(socket, request);
// Read the response status line.
boost::asio::streambuf response;
boost::asio::read(socket, response, boost::asio::transfer_all(), error);
std::istream response_stream(&response);
std::string response_string;
bool successful = false;
while (std::getline(response_stream, response_string))
{
if (response_string.find("FindProxyForURL") != std::string::npos)
{
successful = true;
break;
}
}
if (successful)
{
fout << "peer在监听9000端口" << std::endl;
}
else
{
fout << "peer没有监听9000端口" << std::endl;
}
++m_progress_pos_;
}
bool Simloid::step () throw ()
{
if (!_initialized) return false;
for (unsigned int i=0; i<20; i++)
_velocity[i] = _position[i] = -1;
#ifdef FOUND_boost
std::string line;
std::vector< std::string > vec;
boost::regex angle_expr(".*\\(angle ([\\d\\s]*)\\).*");
boost::regex orient_expr(".*\\(imu ([\\d\\s\\.\\-]*)\\).*");
boost::regex rate_expr(".*\\(rate ([\\d\\s\\.\\-]*)\\).*");
boost::smatch match;
std::ostream request_stream(&_request);
for (int i=0; i<19; i++)
if (_target[i] > -1)
request_stream << "(pid " << (unsigned int)i+1 << " " << 1024-_target[i] << ")\n";
boost::asio::write(*_socket, _request);
for (int i=0; i<10; i++) {
std::ostream request_stream(&_request);
request_stream << "(done)\n";
boost::asio::write(*_socket, _request);
boost::asio::streambuf b;
boost::asio::read_until(*_socket, b, angle_expr);
std::istream is(&b);
std::getline(is, line);
}
// get positions and calculate speed in case getting it fails
if ((_got_pos = boost::regex_search(line, match, angle_expr))) {
std::string test(match[1].str());
boost::split(vec, test, boost::is_space(), boost::token_compress_on);
for (unsigned int i=0; i<vec.size(); ++i) {
_velocity[i+1] = -1 * _position[i+1];
_position[i+1] = boost::lexical_cast<int>(vec[i]);
_velocity[i+1] += _position[i+1];
}
}
// get speed
if (boost::regex_search(line, match, rate_expr)) {
std::string test(match[1].str());
boost::split(vec, test, boost::is_space(), boost::token_compress_on);
for (unsigned int i=0; i<vec.size(); ++i)
_velocity[i+1] = boost::lexical_cast<int>(vec[i]);
}
// get imu data
if ((_got_imu = boost::regex_search(line, match, orient_expr))) {
std::string test(match[1].str());
boost::split(vec, test, boost::is_space(), boost::token_compress_on);
for (unsigned int i=0; i<vec.size(); ++i)
_imu[i] = boost::lexical_cast<float>(vec[i]);
}
#endif
return true;
}
RESULT cConnection::_PostRequest(const std::string& sRelativeURI, const std::map<std::string, std::string>& mValues)
{
boost::asio::io_service io_service;
// Get a list of endpoints corresponding to the server name.
boost::asio::ip::tcp::resolver resolver(io_service);
boost::asio::ip::tcp::resolver::query query(HOST_NAME, "http");
boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
boost::asio::ip::tcp::resolver::iterator end;
// Try each endpoint until we successfully establish a connection.
boost::asio::ip::tcp::socket socket(io_service);
boost::system::error_code error = boost::asio::error::host_not_found;
while (error && (endpoint_iterator != end)) {
socket.close();
socket.connect(*endpoint_iterator++, error);
}
if (error) {
return RESULT::ERROR_SERVER_COULD_NOT_BE_CONTACTED;
}
// Form the request. We specify the "Connection: close" header so that the
// server will close the socket after transmitting the response. This will
// allow us to treat all data up until the EOF as the content.
boost::asio::streambuf request;
std::ostream request_stream(&request);
//std::ostringstream request_stream;
std::string sRelativeURIWithAnyVariables = sRelativeURI;
if (!mValues.empty()) {
std::ostringstream oVariables;
std::map<std::string, std::string>::const_iterator iter = mValues.begin();
const std::map<std::string, std::string>::const_iterator iterEnd = mValues.end();
// Write the first item so that we can safely add "&" between every other item
if (iter != iterEnd) {
oVariables<<Encode(iter->first)<<"="<<Encode(iter->second);
iter++;
}
while (iter != iterEnd) {
oVariables<<"&"<<Encode(iter->first)<<"="<<Encode(iter->second);
iter++;
}
sRelativeURIWithAnyVariables += "?" + oVariables.str();
}
request_stream<<"GET "<<HOST_FINALTV_ROOT<<sRelativeURIWithAnyVariables<<" HTTP/1.1"<<STR_END;
request_stream<<"Host: "<<HOST_NAME<<""<<STR_END;
request_stream<<"User-Agent: Mozilla/4.0 (compatible; libfinaltv 1.0; Linux)"<<STR_END;
request_stream<<"Accept: */*"<<STR_END;
request_stream<<"Connection: close"<<STR_END;
request_stream<<STR_END;
//std::cout<<"Sending request: "<<std::endl;
//std::cout<<request_stream.str()<<std::endl;
// Send the request.
boost::asio::write(socket, request);
// Read the response status line.
boost::asio::streambuf response;
boost::asio::read_until(socket, response, "\r\n");
// Check that response is OK.
std::istream response_stream(&response);
std::string http_version;
response_stream >> http_version;
unsigned int status_code;
response_stream >> status_code;
std::string status_message;
std::getline(response_stream, status_message);
if (!response_stream || (http_version.substr(0, 5) != "HTTP/")) {
std::cout<<"Invalid response"<<std::endl;
return RESULT::ERROR_SERVER_INVALID_RESPONSE;
}
if (status_code != 200) {
std::cout<<"Response returned with status code "<<status_code<<std::endl;
return RESULT::ERROR_SERVER_INVALID_RESPONSE;
}
// Read the response headers, which are terminated by a blank line.
boost::asio::read_until(socket, response, "\r\n\r\n");
// Process the response headers.
std::string header;
while (std::getline(response_stream, header) && (header != "\r")) {
//std::cout<<header<<"\n";
}
//std::cout<<"\n";
std::ostringstream o;
// Process the content in this response if there is any
if (response.size() > 0) {
// Valid response
o<<&response;
}
// Read until EOF, writing data to output as we go.
while (boost::asio::read(socket, response, boost::asio::transfer_at_least(1), error)) {
o<<&response;
}
if (error != boost::asio::error::eof) {
std::cout<<"Error not at the end of the file "<<status_code<<std::endl;
}
std::istringstream buffer(o.str());
std::string sLine;
while (std::getline(buffer, sLine)) {
if (sLine == "success") return RESULT::SUCCESS;
else if (sLine == "error_wrong_version") return RESULT::ERROR_WRONG_VERSION;
else if (sLine == "error_no_action") return RESULT::ERROR_NO_ACTION;
else if (sLine == "error_username_or_password_incorrect") return RESULT::ERROR_USERNAME_OR_PASSWORD_INCORRECT;
else if (sLine == "error_username_banned_24_hours") return RESULT::ERROR_USERNAME_BANNED_24_HOURS;
else if (sLine == "error_username_banned_6_months") return RESULT::ERROR_USERNAME_BANNED_6_MONTHS;
else if (sLine == "error_ip_banned_24_hours") return RESULT::ERROR_IP_BANNED_24_HOURS;
else if (sLine == "error_ip_banned_6_months") return RESULT::ERROR_IP_BANNED_6_MONTHS;
else if (sLine == "error_requests_too_frequent") return RESULT::ERROR_REQUESTS_TOO_FREQUENT;
}
return RESULT::ERROR_SERVER_INVALID_RESPONSE;
}
Request::Request(int client, struct sockaddr_storage client_addr) : handle(client), addr(client_addr) {
std::string line;
bool is_header = true;
char buffer[BUFFER_SIZE];
// receive data from client
recv(client, buffer, BUFFER_SIZE, 0);
// parse each line
std::istringstream request_stream(buffer);
while (std::getline(request_stream, line)) {
// if method is undefined, assumie its first line
if (method == Method::UNDEFINED) {
// so parse header
parse_header(line);
continue;
}
// next lines are headers, strip them
line.erase(line.find_last_not_of(" \n\r\t")+1);
// if line is empty, then content should follow
if (line.size() == 0) {
is_header = false;
break;
}
// extract name and value from header
size_t colon;
std::string name = line.substr(0, colon = line.find(":"));
std::string value = line.substr(colon+1);
value.erase(0, value.find_first_not_of(" \n\r\t"));
headers.insert(std::make_pair(name, value));
}
// if has content
if (!is_header) {
// assume proper content length
size_t content_length = header("Content-Length", 0);
if (content_length == 0)
content_length = header("Content-length", 0);
raw.reserve(content_length);
content.reserve(content_length);
if (content_length > 0) {
// read whats left in header
length = std::min(content_length, (size_t)(BUFFER_SIZE - request_stream.tellg()));
raw = std::string(buffer, BUFFER_SIZE).substr(request_stream.tellg(), length);
content = "";
// receive some more
while (length < content_length) {
memset(buffer, 0, BUFFER_SIZE);
size_t buffer_length = recv(client, buffer, BUFFER_SIZE, 0);
raw += std::string(buffer, buffer_length);
content += std::string(buffer, buffer_length);
length += buffer_length;
}
}
//std::cout << "content o "<<content_length<<" == "<<length<<" == " <<raw.size()<<"\n";
}
// delete [] buffer;
time = std::chrono::high_resolution_clock::now();
// if has some content
if (!raw.empty()) {
// try to parse it
auto ct = headers.find("Content-Type");
if (ct == headers.end())
ct = headers.find("Content-type");
if (ct != headers.end()) {
if (ct->second == "application/x-www-form-urlencoded") {
parse_query_string(raw);
} else
if (ct->second == "application/json" || ct->second == "text/json") {
Json::Reader json_reader;
// data = std::make_shared<Json::Value>();
json_reader.parse(raw, data, false);
}
}
}
}
auto print_url(boost::asio::io_service &io, std::string host, std::string url,
Finished f) {
// Holds values that must be across calls to the lambdas
struct coroutine_variables_t {
boost::asio::ip::tcp::resolver resolver;
boost::asio::ip::tcp::socket socket;
boost::asio::streambuf request;
std::string current;
explicit coroutine_variables_t(boost::asio::io_service &io)
: resolver{io}, socket{io} {}
};
// Create the block for the coroutine
static auto block = stackless_coroutine::make_block(
// For the first lamda of the block, in addition to context, and
// variables,
// can take other parameters
[](auto &context, auto &variables, const std::string &host,
const std::string &path) {
std::ostream request_stream(&variables.request);
request_stream << "GET " << path << " HTTP/1.0\r\n";
request_stream << "Host: " << host << "\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Connection: close\r\n\r\n";
boost::asio::ip::tcp::resolver::query query{host, "http"};
// Pass context in to any function that requires a callback
variables.resolver.async_resolve(query, context);
// Return do_async to signal that we have made an async call, and that
// we should not go on the next
// lamda upon return
return context.do_async();
},
// In the next lambda after a do_async, in addition to context, and
// variables,
// also take the parameters
// of the callback, in this case the error_code ec, and iterator
[](auto &context, auto &variables, auto ec, auto iterator) {
// We can throw exceptions, and the exception will exit the entire block
if (ec) {
throw boost::system::system_error{ec};
} else {
// Pass context as the callback
boost::asio::async_connect(variables.socket, iterator, context);
return context.do_async();
}
},
// Take the parameters for the async_connect callback
[](auto &context, auto &variables, auto &ec, auto iterator) {
if (ec) {
throw boost::system::system_error{ec};
}
// Send the request.
boost::asio::async_write(variables.socket, variables.request, context);
return context.do_async();
},
[](auto &context, auto &variables, auto &ec, auto n) {
if (ec) {
throw boost::system::system_error{ec};
}
},
// make_while_true creates a loop, that always repeats, unless
// context.do_break is called
stackless_coroutine::make_while_true(
[](auto &context, auto &variables) {
variables.current.resize(20);
variables.socket.async_read_some(
boost::asio::buffer(&variables.current[0],
variables.current.size()),
context);
return context.do_async();
},
[](auto &context, auto &variables, auto &ec, auto n) {
if (ec) {
if (ec != boost::asio::error::eof)
std::cerr << ec.message();
// context.do_break breaks out of the loop
return context.do_break();
} else {
variables.current.resize(n);
std::cout << variables.current;
// context.do_continue continues the loop out of the loop
// We could also return do_next() which will continue to the next
// lamda
// which in this case would result in re-entering the loop at the
// top
return context.do_continue();
}
}
));
// pass the block, and the callback, along with any arguments for our
// cororoutine_variables_t
// constructor,
// which in this case is io to make_coroutine
auto co = stackless_coroutine::make_coroutine<coroutine_variables_t>(
block, std::move(f), io);
// call co with arguments corresponding to the parameters of the first lambda
// after context and variables
// which in this case is host, and url
return co(host, url);
}
void Detection::TestTinydrag()
{
std::ofstream fout("text.txt", std::ofstream::ate|std::ofstream::app);
fout << "\n**********************************************************************\n";
fout << "3. Open Tinydrag Test Url" << std::endl;
boost::asio::io_service io_service;
boost::asio::ip::tcp::resolver resolver(io_service);
boost::asio::ip::tcp::resolver::query query("tinydrag.synacast.com", "http");
boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
boost::asio::ip::tcp::resolver::iterator end;
// Try each endpoint until we successfully establish a connection.
boost::asio::ip::tcp::socket socket(io_service);
boost::system::error_code error = boost::asio::error::host_not_found;
while (error && endpoint_iterator != end)
{
socket.close();
socket.connect(*endpoint_iterator++, error);
}
if (error)
{
fout << "域名解析失败!" << std::endl;
}
// Form the request. We specify the "Connection: close" header so that the
// server will close the socket after transmitting the response. This will
// allow us to treat all data up until the EOF as the content.
boost::asio::streambuf request;
std::ostream request_stream(&request);
request_stream << "GET " << "/0/B%2B%D5%EC%CC%BD%28%B8%DF%C7%E5%29_V1.mp40drag" << " HTTP/1.0\r\n";
request_stream << "Host: " << "tinydrag.synacast.com" << "\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Connection: close\r\n\r\n";
// Send the request.
boost::asio::write(socket, request);
// Read the response status line.
boost::asio::streambuf response;
boost::asio::read(socket, response, boost::asio::transfer_all(), error);
std::istream response_stream(&response);
std::string response_string;
bool successful = false;
while (std::getline(response_stream, response_string))
{
if (response_string.find("tinydrag") != std::string::npos)
{
successful = true;
break;
}
}
if (successful)
{
fout << "成功取得tinydrag" << std::endl;
}
else
{
fout << "取不到tinydrag" << std::endl;
}
fout.close();
++m_progress_pos_;
}
bool HttpHelperImpl::PostDataToUrl(std::string host, std::string path, std::string data) {
try
{
boost::asio::io_service io_service;
// Get a list of endpoints corresponding to the server name.
tcp::resolver resolver(io_service);
// this needs to be the port string instead of "http" for Android
// the http service isn't registered?
tcp::resolver::query query(host, "80");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
// Try each endpoint until we successfully establish a connection.
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
// Form the request. We specify the "Connection: close" header so that the
// server will close the socket after transmitting the response. This will
// allow us to treat all data up until the EOF as the content.
boost::asio::streambuf request;
std::ostream request_stream(&request);
request_stream << "POST " << path << " HTTP/1.1\r\n";
request_stream << "Host: " << host << "\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Connection: close\r\n";
request_stream << "Content-Length: " << data.length() << "\r\n";
request_stream << "\r\n"; // end of header
request_stream << data;
// Send the request.
boost::asio::write(socket, request);
// Don't read the response for the time being.
/*
// Read the response status line. The response streambuf will automatically
// grow to accommodate the entire line. The growth may be limited by passing
// a maximum size to the streambuf constructor.
boost::asio::streambuf response;
boost::asio::read_until(socket, response, "\r\n");
// Check that response is OK.
std::istream response_stream(&response);
std::string http_version;
response_stream >> http_version;
unsigned int status_code;
response_stream >> status_code;
std::string status_message;
std::getline(response_stream, status_message);
if (!response_stream || http_version.substr(0, 5) != "HTTP/")
{
//std::cout << "Invalid response\n";
}
if (status_code != 200)
{
//std::cout << "Response returned with status code " << status_code << "\n";
}
// Read the response headers, which are terminated by a blank line.
boost::asio::read_until(socket, response, "\r\n\r\n");
// Process the response headers.
std::string header;
while (std::getline(response_stream, header) && header != "\r") {
//std::cout << header << "\n";
}
//std::cout << "\n";
// Write whatever content we already have to output.
if (response.size() > 0){
//std::cout << &response;
}
// Read until EOF, writing data to output as we go.
boost::system::error_code error;
while (boost::asio::read(socket, response,
boost::asio::transfer_at_least(1), error)) {
//std::cout << &response;
}
if (error != boost::asio::error::eof) {
//throw boost::system::system_error(error);
}
*/
}
catch (std::exception& e)
{
//std::cout << "Exception: " << e.what() << "\n";
return false;
}
return true;
}
//Functionality
static Response perform( const string& method, const Request& request )
{
asio::io_service io_service;
asio::ip::tcp::resolver resolver( io_service );
asio::ip::tcp::resolver::query query( request.host, ::to_string( request.port ) );
asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve( query );
asio::ip::tcp::resolver::iterator end;
asio::ip::tcp::socket socket( io_service );
asio::error_code error = asio::error::host_not_found;
while ( error and endpoint_iterator not_eq end )
{
socket.close( );
socket.connect( *endpoint_iterator++, error );
}
if ( error )
{
throw asio::system_error( error );
}
asio::streambuf request_buffer;
ostream request_stream( &request_buffer );
request_stream << String::uppercase( method ) << " " << request.path << " HTTP/1.1\r\n";
request_stream << "Host: " << request.host << "\r\n";
request_stream << "Connection: close\r\n";
for ( auto header : request.headers )
{
request_stream << header.first << ": " << header.second << "\r\n";
}
request_stream << "\r\n";
if ( not request.body.empty( ) )
{
request_stream << request.body.data( );
}
asio::write( socket, request_buffer );
asio::streambuf response_buffer;
asio::read_until( socket, response_buffer, "\r\n", error );
istream response_stream( &response_buffer );
string status;
getline( response_stream, status );
auto status_line = String::split( status, ' ' );
string http_version = status_line[ 0 ].substr( status_line[ 0 ].find_first_of( '/' ) + 1 );
Response response;
response.version = stod( http_version );
response.status_code = stoi( status_line[ 1 ] );
response.status_message = status_line[ 2 ].substr( 0, status_line[ 2 ].length( ) - 1 );
asio::read_until( socket, response_buffer, "\r\n\r\n", error );
string header = "";
while ( getline( response_stream, header ) and header not_eq "\r" )
{
auto name_value = String::split( header, ':' );
auto name = name_value[ 0 ];
auto value = name_value[ 1 ].substr( 1, name_value[ 1 ].find_last_not_of( "\r\n" ) );
response.headers.insert( make_pair( name, value ) );
}
while ( not error )
{
auto body = Bytes( istreambuf_iterator< char >( &response_buffer ), istreambuf_iterator< char >( ) );
response_buffer.consume( body.size( ) );
response.body.insert( response.body.end( ), body.begin( ), body.end( ) );
asio::read( socket, response_buffer, asio::transfer_all( ), error );
}
if ( error not_eq asio::error::eof )
{
throw runtime_error( "failed to read response." );
}
return response;
}
