TEST_F(ProxygenTransportTest, push) {
// Push a resource
Array headers;
uint8_t pri = 1;
headers.append("hello: world"); // vec serialization path
auto id = pushResource(headers, pri);
// And some body bytes
std::string body("12345");
m_transport->pushResourceBody(id, body.data(), body.length(), false);
EXPECT_EQ(m_server.m_messageQueue.size(), 3);
// Creates a new transaction and sends headers/body
MockHTTPTransaction pushTxn(TransportDirection::DOWNSTREAM,
HTTPCodec::StreamID(1), 1, m_egressQueue,
WheelTimerInstance(m_timeouts.get()));
HTTPPushTransactionHandler* pushHandler = nullptr;
expectPushPromiseAndHeaders(pushTxn, pri, &pushHandler);
EXPECT_CALL(pushTxn, sendBody(_));
m_server.deliverMessages();
// Send Push EOM
m_transport->pushResourceBody(id, nullptr, 0, true);
EXPECT_EQ(m_server.m_messageQueue.size(), 1);
EXPECT_CALL(pushTxn, sendEOM());
m_server.deliverMessages();
pushHandler->detachTransaction();
// Send response
sendResponse("12345");
}
void QgsHttpRequestHandler::sendResponse()
{
QgsMessageLog::logMessage( QString( "Sending HTTP response" ) );
if ( ! responseReady() )
{
QgsMessageLog::logMessage( QString( "Trying to send out an invalid response" ) );
return;
}
#ifdef HAVE_SERVER_PYTHON_PLUGINS
// Plugin hook
// Iterate filters and call their sendResponse() method
QgsServerFiltersMap::const_iterator filtersIterator;
for ( filtersIterator = mPluginFilters.constBegin(); filtersIterator != mPluginFilters.constEnd(); ++filtersIterator )
{
filtersIterator.value()->sendResponse();
}
#endif
if ( ! headersSent() )
{
sendHeaders();
}
sendBody();
//Clear the body to allow for streaming content to stdout
clearBody();
}
// Client Interface
uint32_t HTTPClientChannel::sendOnewayRequest(
RpcOptions& rpcOptions,
std::unique_ptr<RequestCallback> cb,
std::unique_ptr<apache::thrift::ContextStack> ctx,
unique_ptr<IOBuf> buf,
std::shared_ptr<THeader> header) {
DestructorGuard dg(this);
cb->context_ = RequestContext::saveContext();
HTTPTransactionOnewayCallback* owcb = nullptr;
if (cb) {
owcb = new HTTPTransactionOnewayCallback(
std::move(cb), std::move(ctx), isSecurityActive());
}
if (!httpSession_) {
if (owcb) {
TTransportException ex(TTransportException::NOT_OPEN,
"HTTPSession is not open");
owcb->messageSendError(
folly::make_exception_wrapper<TTransportException>(std::move(ex)));
delete owcb;
}
return -1;
}
auto txn = httpSession_->newTransaction(owcb);
if (!txn) {
if (owcb) {
TTransportException ex(TTransportException::NOT_OPEN,
"Too many active requests on connection");
owcb->messageSendError(
folly::make_exception_wrapper<TTransportException>(std::move(ex)));
delete owcb;
}
return -1;
}
setRequestHeaderOptions(header.get());
addRpcOptionHeaders(header.get(), rpcOptions);
auto msg = buildHTTPMessage(header.get());
txn->sendHeaders(msg);
txn->sendBody(std::move(buf));
txn->sendEOM();
if (owcb) {
owcb->sendQueued();
}
return ResponseChannel::ONEWAY_REQUEST_ID;
}
void sendResponse(const std::string& body) {
m_transport->sendImpl(body.data(), body.length(), 200, false, true);
EXPECT_EQ(m_server.m_messageQueue.size(), 1);
EXPECT_CALL(m_txn, sendHeaders(_));
EXPECT_CALL(m_txn, sendBody(_));
EXPECT_CALL(m_txn, sendEOM());
m_server.deliverMessages();
}
static void
sendFileAsResponse(TSession *const sessionP,
TFile *const fileP,
const char *const fileName,
time_t const fileModTime,
MIMEType *const mimeTypeP) {
uint64_t const filesize = FileSize(fileP);
const char *const mediatype = MIMETypeGuessFromFile2(mimeTypeP, fileName);
uint64_t start; /* Defined only if session has one range */
uint64_t end; /* Defined only if session has one range */
switch (sessionP->ranges.size) {
case 0:
ResponseStatus(sessionP, 200);
break;
case 1: {
bool decoded;
decoded = RangeDecode((char *) (sessionP->ranges.item[0]), filesize,
&start, &end);
if (!decoded) {
ListFree(&sessionP->ranges);
ResponseStatus(sessionP, 200);
} else {
const char *contentRange;
xmlrpc_asprintf(&contentRange,
"bytes %" PRIu64 "-%" PRIu64 "/%" PRIu64,
start, end, filesize);
ResponseAddField(sessionP, "Content-range", contentRange);
xmlrpc_strfree(contentRange);
ResponseContentLength(sessionP, end - start + 1);
ResponseStatus(sessionP, 206);
}
}
break;
default:
ResponseContentType(sessionP,
"multipart/ranges; boundary=" BOUNDARY);
ResponseStatus(sessionP, 206);
break;
}
if (sessionP->ranges.size == 0) {
ResponseContentLength(sessionP, filesize);
ResponseContentType(sessionP, mediatype);
}
addLastModifiedHeader(sessionP, fileModTime);
ResponseWriteStart(sessionP);
if (sessionP->requestInfo.method != m_head)
sendBody(sessionP, fileP, filesize, mediatype, start, end);
}
/*
We'll make it return the number of bytes sent
so that we know if we need to send a body by default
*/
long send_fp_black(per_request *reqInfo, FILE *f, void (*onexit)(void))
{
char *buf;
long total_bytes_sent;
register int n,o,w;
int isHTML = FALSE;
buf = newString(IOBUFSIZE,STR_TMP);
exit_callback = onexit;
signal(SIGALRM,send_fd_timed_out);
signal(SIGPIPE,send_fd_timed_out);
total_bytes_sent = 0;
if (!strcmp(reqInfo->outh_content_type,"text/html")) {
isHTML = TRUE;
total_bytes_sent = rprintf(reqInfo,bodyTag);
}
rflush(reqInfo);
while (1) {
alarm(timeout);
if((n=fread(buf,sizeof(char),IOBUFSIZE,f)) < 1) {
if (errno != EINTR) break;
}
o=0;
if(reqInfo->bytes_sent != -1)
reqInfo->bytes_sent += n;
if (isHTML) {
sendBody(reqInfo,buf,n);
total_bytes_sent += n;
n = 0;
}
while(n) {
/* Seems some systems have broken fwrite's (like AIX 3.2.5 on PowerPC)
* this should be a drop in replacement, maybe even be faster.
* For now, we'll just replace, but may have to #define one or the other
* depending on the system.
*/
if ((w=write(fileno(reqInfo->out),&buf[o],n)) < 0) {
if (errno != EINTR) break;
}
n-=w;
o+=w;
total_bytes_sent += w;
}
}
if (isHTML)
rprintf(reqInfo,"<HR><a href=\"http://www.vtw.org/speech/\">My World Wide Web Pages are black for 48 hours to protest second-class treatment from the US Government for free speech. Read about it at this WWW page.</a>");
alarm(0);
signal(SIGALRM,SIG_IGN);
signal(SIGPIPE,SIG_IGN);
freeString(buf);
return total_bytes_sent;
}
bool HttpClient::doMultipartPost()
{
//如果有Fields段 已经写入了body内 直接发送
if (!sendBody())
{
setErrorCode(HTTPERROR_TRANSPORT);
return false;
}
//发送文件
const std::vector<HttpFile*>& post_files = _request->getFiles();
const std::string& boundary = _request->getBoundary();
for (size_t i = 0; i < post_files.size(); i++)
{
const std::string name = post_files[i]->_name;
IHttpPostFile* post_file = post_files[i]->_post_file;
std::string file_header = "--" + boundary + "\r\n"
"content-disposition: form-data; name=\"" + name + "\"; filename=\"" +
post_file->getFilename() + "\"\r\n" +
"content-type: " + post_file->getContentType() + "\r\n" +
"\r\n";
bool send_file_header = _proxy_socket->writeAll(file_header.c_str(),file_header.size());
if (!send_file_header)
{
setErrorCode(HTTPERROR_TRANSPORT);
return false;
}
bool post_file_success = uploadFile(post_file);
if (!post_file_success)
{
setErrorCode(HTTPERROR_TRANSPORT);
return false;
}
std::string file_tailer = "\r\n";
bool send_file_tailer = _proxy_socket->writeAll(file_tailer.c_str(),file_tailer.size());
if (!send_file_tailer)
{
setErrorCode(HTTPERROR_TRANSPORT);
return false;
}
}
//发送boundary结束标记
std::string post_tailer = "--" + boundary + "--\r\n";
bool send_post_tailer = _proxy_socket->writeAll(post_tailer.c_str(),post_tailer.size());
return send_post_tailer ? getResponse() : setErrorCode(HTTPERROR_TRANSPORT) , false;
}
void Sender::startSending()
{
std::thread SendThread(
[&]()
{
do
{
try
{
IMessage *msg = sendQ.deQ();
/*Message* msg = dynamic_cast<Message*>(imsg);
map<string, string> header = msg->getHeader();*/
if (msg->getCommand() == "send_stop")
break;
else if (msg->getCommand() == "file_upload")
{
if (connectToPeer(msg->getRecvIP(), stoi(msg->getRecvPort())))
{
if (sendFile(msg))
{ }
}
else
Verbose::show("Connection failed!\n");
}
else if (msg->getCommand() == "ack")
{
if (connectToPeer(msg->getRecvIP(), stoi(msg->getRecvPort())))
sendHeader(msg);
}
else
{
if (connectToPeer(msg->getRecvIP(), stoi(msg->getRecvPort())))
{
sendHeader(msg);
sendBody(msg);
}
}
}
catch (exception ex)
{
string s = ex.what();
Verbose::show("\n In send Thread: " + s);
}
} while (1);
}
);
SendThread.detach();
}
TEST_F(ProxygenTransportRepostTest, mid_body_abort) {
InSequence enforceOrder;
auto req = getRequest(HTTPMethod::POST);
auto body1 = folly::IOBuf::copyBuffer(std::string("hello"));
auto body2 = folly::IOBuf::copyBuffer(std::string("world"));
EXPECT_CALL(m_txn, sendHeaders(_));
EXPECT_CALL(m_txn, sendBody(_))
.Times(2);
m_transport->onHeadersComplete(std::move(req));
m_transport->onBody(std::move(body1));
m_transport->beginPartialPostEcho();
m_transport->onBody(std::move(body2));
m_transport->abort();
}
bool HttpClient::httpPost()
{
//发送HTTP头请求
bool complete = false;
if (sendHeader())
{
if (_request->isMultipart())
{
complete = doMultipartPost();
}
else
{
if (sendBody())
{
complete = getResponse();
}
}
}
return complete;
}
/*****************************************************************************
*
* Handle the processing of a GET request type.
*
* file: client socket stream
* url: unverified url requested in the GET request
*
*****************************************************************************/
static int reqGet(FILE *file, char *url)
{
int stat;
++getCount;
/* Special processing for status requests */
if (!strcmp(url, "/status"))
return(sendStatus(file, 1));
if (isEvilUrl(url))
{
debug("URL is EVIL... rejecting\n");
return(sendBadRequestResponse(file));
}
if ((stat = sendHeader(file, url)) != 0)
{
return(stat);
}
return(sendBody(file, url));
}
//Read and send blocks of file
bool Sender::sendFile(Message& msg){
Header hdr = msg.getHdr(); string path = hdr.getAttrib("filename");
string sMsg = "\n Started sending file " + path + " to " + hdr.getAddress() + ":" + hdr.getPort() + "\n";
sout << sMsg;
std::ifstream ifstream(path.c_str(), std::ios::in | std::ios::binary);
if (ifstream.is_open()) {
ifstream.seekg(0, ios::beg);
bool isStartFlagSent = false;
while (!ifstream.eof()){
byte block[1024];
ifstream.read((char*)block, 1024);//Read blocks of 1024 from file to be sent to the receiver
if (!isStartFlagSent){
hdr.setCmd("send_file_begin");//If start of file, to open a stream at the receiver end
isStartFlagSent = true;
}
else{
hdr.setCmd("send_file");
}
int bytesRead = static_cast<int> (ifstream.gcount());
hdr.setContentLength(bytesRead); msg.setHdr(hdr);
if (!s_.send(msg.getMsg())){ //send header with content length for the body to follow
sout << "\n bad status in sending thread";
break;
}
if (!sendBody(bytesRead, block)){ //send blocks of body
sout << "\n bad status in sending thread";
break;
}
}
ifstream.close();
hdr.setCmd("end_of_file"); hdr.setContentLength(0);
msg.setHdr(hdr);
if (!s_.send(msg.getMsg())){
return false;
}
}
string sMsg1 = "\n Ended sending of file " + path + "\n\n";
sout << sMsg1;
return true;
}
static abyss_bool
ServerFileHandler(TSession * const r,
char * const z,
time_t const fileModTime,
MIMEType * const mimeTypeP) {
const char * mediatype;
TFile file;
uint64_t filesize;
uint64_t start;
uint64_t end;
TDate date;
char * p;
TDate filedate;
mediatype = MIMETypeGuessFromFile2(mimeTypeP, z);
if (!FileOpen(&file,z,O_BINARY | O_RDONLY)) {
ResponseStatusErrno(r);
return TRUE;
}
fileDate(r, fileModTime, &filedate);
p = RequestHeaderValue(r, "if-modified-since");
if (p) {
if (DateDecode(p,&date)) {
if (DateCompare(&filedate, &date) <= 0) {
ResponseStatus(r, 304);
ResponseWrite(r);
return TRUE;
} else
r->ranges.size = 0;
}
}
filesize = FileSize(&file);
switch (r->ranges.size) {
case 0:
ResponseStatus(r, 200);
break;
case 1: {
abyss_bool decoded;
decoded = RangeDecode((char *)(r->ranges.item[0]), filesize,
&start, &end);
if (!decoded) {
ListFree(&(r->ranges));
ResponseStatus(r, 200);
break;
}
sprintf(z, "bytes %llu-%llu/%llu", start, end, filesize);
ResponseAddField(r, "Content-range", z);
ResponseContentLength(r, end - start + 1);
ResponseStatus(r, 206);
} break;
default:
ResponseContentType(r, "multipart/ranges; boundary=" BOUNDARY);
ResponseStatus(r, 206);
break;
}
if (r->ranges.size == 0) {
ResponseContentLength(r, filesize);
ResponseContentType(r, mediatype);
}
if (DateToString(&filedate, z))
ResponseAddField(r, "Last-Modified", z);
ResponseWrite(r);
if (r->request_info.method != m_head)
sendBody(r, &file, filesize, mediatype, start, end, z);
FileClose(&file);
return TRUE;
}
uint32_t HTTPClientChannel::sendRequest(
RpcOptions& rpcOptions,
std::unique_ptr<RequestCallback> cb,
std::unique_ptr<apache::thrift::ContextStack> ctx,
unique_ptr<IOBuf> buf,
std::shared_ptr<THeader> header) {
// cb is not allowed to be null.
DCHECK(cb);
DestructorGuard dg(this);
cb->context_ = RequestContext::saveContext();
std::chrono::milliseconds timeout(timeout_);
if (rpcOptions.getTimeout() > std::chrono::milliseconds(0)) {
timeout = rpcOptions.getTimeout();
}
auto twcb =
new HTTPTransactionTwowayCallback(std::move(cb),
std::move(ctx),
isSecurityActive(),
protocolId_,
timer_.get(),
std::chrono::milliseconds(timeout_));
if (!httpSession_) {
TTransportException ex(TTransportException::NOT_OPEN,
"HTTPSession is not open");
twcb->messageSendError(
folly::make_exception_wrapper<TTransportException>(std::move(ex)));
delete twcb;
return -1;
}
auto txn = httpSession_->newTransaction(twcb);
if (!txn) {
TTransportException ex(TTransportException::NOT_OPEN,
"Too many active requests on connection");
// Might be able to create another transaction soon
ex.setOptions(TTransportException::CHANNEL_IS_VALID);
twcb->messageSendError(
folly::make_exception_wrapper<TTransportException>(std::move(ex)));
delete twcb;
return -1;
}
auto streamId = txn->getID();
setRequestHeaderOptions(header.get());
addRpcOptionHeaders(header.get(), rpcOptions);
auto msg = buildHTTPMessage(header.get());
txn->sendHeaders(msg);
txn->sendBody(std::move(buf));
txn->sendEOM();
twcb->sendQueued();
return (uint32_t)streamId;
}
void QxtSmtpPrivate::socketRead()
{
buffer += socket->readAll();
while (true)
{
int pos = buffer.indexOf("\r\n");
if (pos < 0) return;
QByteArray line = buffer.left(pos);
buffer = buffer.mid(pos + 2);
QByteArray code = line.left(3);
switch (state)
{
case StartState:
if (code[0] != '2')
{
socket->disconnectFromHost();
}
else
{
ehlo();
}
break;
case HeloSent:
case EhloSent:
case EhloGreetReceived:
parseEhlo(code, (line[3] != ' '), line.mid(4));
break;
#ifndef QT_NO_OPENSSL
case StartTLSSent:
if (code == "220")
{
socket->startClientEncryption();
ehlo();
}
else
{
authenticate();
}
break;
#endif
case AuthRequestSent:
case AuthUsernameSent:
if (authType == AuthPlain) authPlain();
else if (authType == AuthLogin) authLogin();
else authCramMD5(line.mid(4));
break;
case AuthSent:
if (code[0] == '2')
{
state = Authenticated;
emit qxt_p().authenticated();
}
else
{
state = Disconnected;
emit qxt_p().authenticationFailed();
emit qxt_p().authenticationFailed( line );
emit socket->disconnectFromHost();
}
break;
case MailToSent:
case RcptAckPending:
if (code[0] != '2') {
emit qxt_p().mailFailed( pending.first().first, code.toInt() );
emit qxt_p().mailFailed(pending.first().first, code.toInt(), line);
// pending.removeFirst();
// DO NOT remove it, the body sent state needs this message to assigned the next mail failed message that will
// the sendNext
// a reset will be sent to clear things out
sendNext();
state = BodySent;
}
else
sendNextRcpt(code, line);
break;
case SendingBody:
sendBody(code, line);
break;
case BodySent:
if ( pending.count() )
{
// if you removeFirst in RcpActpending/MailToSent on an error, and the queue is now empty,
// you will get into this state and then crash because no check is done. CHeck added but shouldnt
// be necessary since I commented out the removeFirst
if (code[0] != '2')
{
emit qxt_p().mailFailed(pending.first().first, code.toInt() );
emit qxt_p().mailFailed(pending.first().first, code.toInt(), line);
}
else
emit qxt_p().mailSent(pending.first().first);
pending.removeFirst();
}
sendNext();
break;
case Resetting:
if (code[0] != '2') {
emit qxt_p().connectionFailed();
emit qxt_p().connectionFailed( line );
}
else {
state = Waiting;
sendNext();
}
break;
}
}
}
