HttpJobRequest * HttpFileRequestHandler::handleHttpRequest(HttpRequest * request, const HttpServerTask *task) { FileUtils::paloifstream file(filename.c_str()); if (!file) { HttpResponse * response = new HttpResponse(HttpResponse::NOT_FOUND); response->getBody().appendText("file not found"); return new DirectHttpResponse(request->getRequestPath(), response); } HttpResponse * response = new HttpResponse(HttpResponse::OK); response->setContentType(contentType); int max = 1000; char* c = new char[max]; while (!file.eof()) { file.read(c, max); response->getBody().appendText(c, (size_t)file.gcount()); } delete[] c; return new DirectHttpResponse(request->getRequestPath(), response); }
bool RPCTestNode::submitBlock(const std::string& block) { HttpRequest httpReq; httpReq.setUrl("/json_rpc"); httpReq.addHeader("Host", "127.0.0.1:" + boost::lexical_cast<std::string>(m_rpcPort)); httpReq.addHeader("Content-Type", "application/json-rpc"); JsonValue request(cryptonote::JsonValue::OBJECT); JsonValue jsonRpc; jsonRpc = "2.0"; request.insert("jsonrpc", jsonRpc); JsonValue methodString; methodString = "submitblock"; request.insert("method", methodString); JsonValue id; id = "sync"; request.insert("id", id); JsonValue params(JsonValue::ARRAY); JsonValue blockstr; blockstr = block.c_str(); params.pushBack(blockstr); request.insert("params", params); std::stringstream jsonOutputStream; jsonOutputStream << request; httpReq.setBody(jsonOutputStream.str()); TcpConnector connector(m_dispatcher, "127.0.0.1", m_rpcPort); TcpConnection connection = connector.connect(); TcpStreambuf streambuf(connection); std::iostream connectionStream(&streambuf); LOG_DEBUG("invoke json-rpc: " + httpReq.getBody()); connectionStream << httpReq; connectionStream.flush(); HttpResponse httpResp; HttpParser parser; parser.receiveResponse(connectionStream, httpResp); connectionStream.flush(); if (httpResp.getStatus() != HttpResponse::STATUS_200) return false; epee::serialization::portable_storage ps; if (!ps.load_from_json(httpResp.getBody())) { LOG_ERROR("cannot parse response from daemon: " + httpResp.getBody()); return false; } epee::json_rpc::response<COMMAND_RPC_SUBMITBLOCK::response, epee::json_rpc::error> jsonRpcResponse; jsonRpcResponse.load(ps); if (jsonRpcResponse.error.code || jsonRpcResponse.error.message.size()) { LOG_ERROR("RPC call of submit_block returned error: " + TO_STRING(jsonRpcResponse.error.code) + ", message: " + jsonRpcResponse.error.message); return false; } if (jsonRpcResponse.result.status != CORE_RPC_STATUS_OK) return false; return true; }
bool RPCTestNode::startMining(size_t threadsCount, const std::string& address) { LOG_DEBUG("startMining()"); using namespace cryptonote; COMMAND_RPC_START_MINING::request req; COMMAND_RPC_START_MINING::response resp; req.miner_address = address; req.threads_count = threadsCount; std::stringstream requestStream; JsonOutputStreamSerializer enumerator; enumerator(req, ""); requestStream << enumerator; HttpRequest httpReq; prepareRequest(httpReq, "/start_mining", requestStream.str()); HttpResponse httpResp; sendRequest(httpReq, httpResp); if (httpResp.getStatus() != HttpResponse::STATUS_200) return false; std::stringstream responseStream(httpResp.getBody()); JsonInputStreamSerializer en(responseStream); en(resp, ""); if (resp.status != CORE_RPC_STATUS_OK) { std::cout << "startMining() RPC call fail: " << resp.status; return false; } return true; }
void WebClientApp::onReadComplete() { mText.push_back( "Read complete" ); console() << "HTTP version: "; switch ( mHttpResponse.getHttpVersion() ) { case HttpVersion::HTTP_0_9: console() << "0.9"; break; case HttpVersion::HTTP_1_0: console() << "1.0"; break; case HttpVersion::HTTP_1_1: console() << "1.1"; break; case HttpVersion::HTTP_2_0: console() << "2.0"; break; } console() << endl; console() << "Status code: " << mHttpResponse.getStatusCode() << endl; console() << "Reason: " << mHttpResponse.getReason() << endl; console() << "Header fields: " << endl; for ( const KeyValuePair& kvp : mHttpResponse.getHeaders() ) { console() << ">> " << kvp.first << ": " << kvp.second << endl; } console() << endl; console() << "Body:" << endl; console() << HttpResponse::bufferToString( mHttpResponse.getBody() ) << endl; mSession->close(); }
void HttpServerTask::handleDone() { // get response from job request HttpResponse* response = httpJobRequest->getResponse(); if (response == 0) { response = new HttpResponse(HttpResponse::NO_RESPONSE); } // trace #ifdef ENABLE_TRACE_OPTION { string requestString = ""; if (httpRequest != 0) { requestString = httpRequest->getHeaderString(); const string bs = httpRequest->getBodyString(); if (!bs.empty()) { if (requestString.find("?") == string::npos) { requestString += "?"; } requestString += bs; } } server->traceRequest(requestString + response->getBody().c_str()); } #endif // add response to output buffer addResponse(response); // we can now free the response delete response; // and the jobe request delete httpJobRequest; httpJobRequest = 0; // and the http request if (httpRequest != 0) { httpRequest->releaseBuffers(); delete httpRequest; httpRequest = 0; } httpRequestPending = false; // remove body from read buffer and reset read position readBuffer.erase_front(bodyPosition + bodyLength); readPosition = 0; bodyPosition = 0; bodyLength = 0; }
void invokeJsonRpcCommand(HttpClient& httpClient, JsonRpcRequest& jsReq, JsonRpcResponse& jsRes) { HttpRequest httpReq; HttpResponse httpRes; httpReq.setUrl("/json_rpc"); httpReq.setBody(jsReq.getBody()); httpClient.request(httpReq, httpRes); if (httpRes.getStatus() != HttpResponse::STATUS_200) { throw std::runtime_error("JSON-RPC call failed, HTTP status = " + std::to_string(httpRes.getStatus())); } jsRes.parse(httpRes.getBody()); JsonRpcError err; if (jsRes.getError(err)) { throw err; } }
int VersionChecker::retrieveRemoteVersion(const std::string& urlToVersion) { Http http(urlToVersion, 0.5); HttpResponse response; if (this->quiet) { http.enableQuiet(); } else { http.disableQuiet(); } if (!this->quiet) { fprintf(stderr, "retrieve remote version from [ %s ]\n", urlToVersion.c_str()); } // 2: the remote version file has two lines int ret = http.read(&response, 2); if (ret < 0) { if (!this->quiet) { fprintf( stderr, "Failed to retrieve remote version, probably due to wrong http\n"); } return -1; } this->remoteInformation = response.getBody(); if (this->remoteInformation.size() < 1) { if (!this->quiet) { fprintf(stderr, "Failed to retrieve remote version due to empty version " "information\n"); } return -1; } this->remoteVersion = this->remoteInformation[0]; if (!this->quiet) { fprintf(stderr, "Retrieved remote version [ %s ]\n", this->remoteVersion.c_str()); } return 0; }
bool RPCTestNode::stopDaemon() { LOG_DEBUG("stopDaemon()"); using namespace cryptonote; COMMAND_RPC_STOP_DAEMON::request req; COMMAND_RPC_STOP_DAEMON::response resp; std::stringstream requestStream; JsonOutputStreamSerializer enumerator; enumerator(req, ""); requestStream << enumerator; HttpRequest httpReq; prepareRequest(httpReq, "/stop_daemon", requestStream.str()); HttpResponse httpResp; sendRequest(httpReq, httpResp); if (httpResp.getStatus() != HttpResponse::STATUS_200) return false; std::stringstream responseStream(httpResp.getBody()); JsonInputStreamSerializer en(responseStream); en(resp, ""); if (resp.status != CORE_RPC_STATUS_OK) { std::cout << "stopDaemon() RPC call fail: " << resp.status; return false; } return true; }
void HttpClientApp::onRead( ci::BufferRef buffer ) { size_t sz = buffer->getSize(); mBytesRead += sz; mText.push_back( toString( sz ) + " bytes read" ); if ( !mHttpResponse.hasHeader() ) { // Parse header mHttpResponse.parseHeader( HttpResponse::bufferToString( buffer ) ); buffer = HttpResponse::removeHeader( buffer ); // Get content-length for ( const KeyValuePair& kvp : mHttpResponse.getHeaders() ) { if ( kvp.first == "Content-Length" ) { mContentLength = fromString<size_t>( kvp.second ); break; } } } // Append buffer to body mHttpResponse.append( buffer ); if ( mBytesRead < mContentLength ) { // Keep reading until we hit the content length mSession->read(); } else { mText.push_back( "Read complete" ); mText.push_back( toString( mHttpResponse.getStatusCode() ) + " " + mHttpResponse.getReason() ); if ( mHttpResponse.getStatusCode() == 200 ) { for ( const KeyValuePair& kvp : mHttpResponse.getHeaders() ) { // Choose file extension based on MIME type if ( kvp.first == "Content-Type" ) { string mime = kvp.second; if ( mime == "audio/mp3" ) { mFilename += ".mp3"; } else if ( mime == "image/jpeg" ) { mFilename += ".jpg"; } else if ( mime == "image/png" ) { mFilename += ".png"; } } else if ( kvp.first == "Connection" ) { // Close connection if requested by server if ( kvp.second == "close" ) { mSession->close(); } } } // Save the file fs::path path = getAppPath(); #if !defined ( CINDER_MSW ) path = path.parent_path(); #endif path = path / mFilename; OStreamFileRef file = writeFileStream( path ); file->write( mHttpResponse.getBody() ); mText.push_back( mFilename + " downloaded" ); } else { // Write error mText.push_back( "Response: " + HttpResponse::bufferToString( mHttpResponse.getBody() ) ); mSession->close(); } } }