static int restore_sbuf(struct sbuf *sb, struct bu *arr, int a, int i, const char *tmppath1, const char *tmppath2, enum action act, const char *client, char status, struct cntr *p1cntr, struct cntr *cntr, struct config *cconf)
{
//logp("%s: %s\n", act==ACTION_RESTORE?"restore":"verify", sb->path);
write_status(client, status, sb->path, p1cntr, cntr);
if((sb->datapth && async_write(CMD_DATAPTH,
sb->datapth, strlen(sb->datapth)))
|| async_write(CMD_STAT, sb->statbuf, sb->slen))
return -1;
else if(sb->cmd==CMD_FILE
|| sb->cmd==CMD_ENC_FILE
|| sb->cmd==CMD_METADATA
|| sb->cmd==CMD_ENC_METADATA
|| sb->cmd==CMD_EFS_FILE)
{
return restore_file(arr, a, i, sb->datapth,
sb->path, tmppath1, tmppath2, act,
sb->endfile, sb->cmd, sb->winattr, cntr, cconf);
}
else
{
if(async_write(sb->cmd, sb->path, sb->plen))
return -1;
// If it is a link, send what
// it points to.
else if(sbuf_is_link(sb))
{
if(async_write(sb->cmd, sb->linkto, sb->llen))
return -1;
}
do_filecounter(cntr, sb->cmd, 0);
}
return 0;
}
void monitor_connection::handle_read(const boost::system::error_code &err, std::size_t bytes_transferred)
{
if (err || bytes_transferred < 1) {
close();
return;
}
switch (m_buffer[0]) {
case 'i': case 'I':
async_write(get_information());
break;
case 's': case 'S': {
const char *result = "Stopping...\n";
boost::asio::async_write(m_socket, boost::asio::buffer(result, strlen(result)),
std::bind(&monitor_connection::handle_stop_write, shared_from_this(),
std::placeholders::_1, std::placeholders::_2));
break;
}
default:
case 'h': case 'H':
async_write("i - statistics information\n"
"s - stop server\n"
"h - this help message\n");
break;
}
}
void handle_upstream_read(const boost::system::error_code& error,
const size_t& bytes_transferred)
{
cerr << "***UPSTREAM_READ" << endl;
if (!error)
{
if(c) {
cerr<<"Read from rabin. C exists" <<endl;
memcpy(upstream_data_, c, n);
delete[] c;
c = NULL;
} else {
cerr<<"Did not read from rabin. data is: " << upstream_data_<<"\n\n size "<<bytes_transferred<<endl;
n = bytes_transferred;
}
async_write(downstream_socket_,
boost::asio::buffer(upstream_data_, n),
boost::bind(&bridge::handle_downstream_write,
shared_from_this(),
boost::asio::placeholders::error));
}
else {
cerr<<"Upstream read error" <<endl;
error.message();
close();
}
}
void PlcSession::handleReadData(uint32_t* len, char* data, const boost::system::error_code& ec)
{
if(!ec)
{
std::cout << "Received: " << data << std::endl;
std::ofstream ofs("program.prg");
assert(ofs.good());
ofs << data;
}
else
{
std::cout << "Error while reading data: " << ec.message() << std::endl;
}
delete len;
delete[] data;
mPlc.requestReloadProgram();
unsigned int* answer = new unsigned int();
*answer = 0;
async_write(mSocket, buffer(answer, sizeof(unsigned int)), boost::bind(&PlcSession::handleWriteAnswer, this, answer, placeholders::error));
}
void async_serial::_write_end(const boost::system::error_code& error)
{
if(!error) {
boost::lock_guard<boost::mutex> l(_write_queue_mutex);
if(_write_queue.empty()) {
_write_buffer.reset();
_write_buffer_size=0;
return;
}
_write_buffer_size = _write_queue.size();
_write_buffer.reset(new char[_write_queue.size()]);
std::copy(_write_queue.begin(),_write_queue.end(),
_write_buffer.get());
_write_queue.clear();
async_write(
_port,
boost::asio::buffer(_write_buffer.get(),
_write_buffer_size),
boost::bind(
&async_serial::_write_end,
this,
boost::asio::placeholders::error));
} else {
_set_error_status(true);
_do_close();
}
}
void AsyncSerial::writeEnd(const boost::system::error_code& error)
{
if(!error)
{
boost::lock_guard<boost::mutex> l(pimpl->writeQueueMutex);
if(pimpl->writeQueue.empty())
{
pimpl->writeBuffer.reset();
pimpl->writeBufferSize=0;
sleep_milliseconds(75);
return;
}
pimpl->writeBufferSize=pimpl->writeQueue.size();
pimpl->writeBuffer.reset(new char[pimpl->writeQueue.size()]);
copy(pimpl->writeQueue.begin(),pimpl->writeQueue.end(),
pimpl->writeBuffer.get());
pimpl->writeQueue.clear();
async_write(pimpl->port,boost::asio::buffer(pimpl->writeBuffer.get(),
pimpl->writeBufferSize),
boost::bind(&AsyncSerial::writeEnd, this, boost::asio::placeholders::error));
} else {
try
{
setErrorStatus(true);
doClose();
}
catch (...)
{
}
}
}
void http_client::request(int conn, const char *method, const char *post_page, std::map<std::string, std::string> *extra_headers,
const char *ext_data, size_t ext_len, EXT_DST ed /*= DST_NONE*/)
{
auto http_impl = std::dynamic_pointer_cast<http_impl_t<tcp_client_impl>>(m_impl);
auto sch_impl = std::dynamic_pointer_cast<scheduler_impl>(http_impl->m_util.m_sch->m_impl);
//判断当前连接是否有效
if (conn < 0 || conn >= sch_impl->m_ev_array.size() || !sch_impl->m_ev_array[conn])
return;
if (__glibc_unlikely(!method || !post_page))
return;
auto http_conn = std::dynamic_pointer_cast<http_conn_t<tcp_client_conn>>(sch_impl->m_ev_array[conn]);
std::string http_request = std::string(method)+" "+std::string(post_page)+" HTTP/1.1\r\n"; //构造请求行
http_request += "Host: "+http_conn->domain_name+"\r\n"; //构造请求头中的Host字段
http_request += "Connection: Keep-Alive\r\n"; //复用连接
if (DST_NONE != ed)
http_request += "Content-Type: "+g_ext_type[ed]+"; charset=utf-8\r\n";
if (extra_headers) {
for (auto& header : *extra_headers) //加入额外的请求头部
http_request += header.first+": "+header.second+"\r\n";
}
if (ext_data && ext_len) { //若有则加入请求体
http_request += "Content-Length: "+std::to_string(ext_len)+"\r\n\r\n";
http_request.append(ext_data, ext_len);
} else {
http_request += "\r\n";
}
http_conn->async_write(http_request.c_str(), http_request.size());
}
void http_response(std::shared_ptr<scheduler_impl>& sch_impl, int fd, const char *ext_data, size_t ext_len,
EXT_DST ed, int status, std::map<std::string, std::string> *extra_headers)
{
//判断连接是否有效
if (fd < 0 || fd >= sch_impl->m_ev_array.size() || !sch_impl->m_ev_array[fd])
return;
auto tcp_ev = std::dynamic_pointer_cast<tcp_event>(sch_impl->m_ev_array[fd]);
std::string http_response = "HTTP/1.1 ";
auto sts_it = g_sts_desc.find(status);
if (g_sts_desc.end() == sts_it)
return;
http_response += std::to_string(status)+" "+sts_it->second+"\r\n";
if (DST_NONE != ed)
http_response += "Content-Type: "+g_ext_type[ed]+"; charset=utf-8\r\n";
if (extra_headers) {
for (auto& header : *extra_headers)
http_response += header.first+": "+header.second+"\r\n";
}
http_response += "Content-Length: "+std::to_string(ext_len)+"\r\n\r\n";
if (ext_data && ext_len)
http_response.append(ext_data, ext_len);
tcp_ev->async_write(http_response.c_str(), http_response.size());
}
void ws_client::send_data(int conn, const char *ext_data, size_t ext_len, WS_TYPE wt /*= WS_TEXT*/)
{
auto http_impl = std::dynamic_pointer_cast<http_impl_t<tcp_client_impl>>(m_impl);
auto sch_impl = std::dynamic_pointer_cast<scheduler_impl>(http_impl->m_util.m_sch->m_impl);
//判断当前连接是否有效
if (conn < 0 || conn >= sch_impl->m_ev_array.size() || !sch_impl->m_ev_array[conn])
return;
if (__glibc_unlikely(!ext_data || !ext_len))
return;
auto http_conn = std::dynamic_pointer_cast<http_conn_t<tcp_client_conn>>(sch_impl->m_ev_array[conn]);
std::string http_request(2, 0);
if (WS_TEXT == wt)
http_request[0] = (char)0x81;
else if (WS_BIN == wt)
http_request[0] = (char)0x82;
http_request[1] = 126;
http_request[1] |= 0x80;
uint16_t net_len = htons((uint16_t)ext_len);
http_request.append((const char*)&net_len, sizeof(net_len));
uint32_t mask_key = rand();
http_request.append((const char*)&mask_key, sizeof(mask_key));
http_request.append(ext_data, ext_len);
for (int i = 0; i < ext_len; i++)
http_request[8+i] ^= http_request[i%4+4];
http_conn->async_write(http_request.c_str(), http_request.size());
}
inline void async_write(AsyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, WriteHandler handler)
{
async_write(s, b.data(), completion_condition,
detail::write_streambuf_handler<
AsyncWriteStream, Allocator, WriteHandler>(b, handler));
}
//---------------------------------------------------------------------
void SslConnection::DoWrite(std::string pData)
{
bool write_in_progress = !mToSend.empty();
mToSend.push_back(pData);
if (!write_in_progress)
{
async_write(mToSend.front());
}
}
//--------------------------------------------------------------------------------
void Session::do_write(Packet msg)
{
bool write_in_progress = !mToSend.empty();
mToSend.push_back(msg);
if (!write_in_progress)
{
async_write(mToSend.front());
}
}
void HTTPCallbackTcpConnection::handlePostRequest(
const boost::system::error_code& error) {
ifstream index(CROSS_SITE_CALLBACK_HTML);
string fileContent((istreambuf_iterator<char>(index)),
istreambuf_iterator<char>());
async_write(localSocket, buffer(fileContent),
bind(&HTTPCallbackTcpConnection::handleWrite, shared_from_this(),
placeholders::error));
}
void IOSessionCommon::writeMessage(MessageHeaderPtr message)
{
boost::mutex::scoped_lock scopedLock(_sessionMutex);
Buffer& messageBuffer = message->messageBuffer();
size_t payloadSize = messageBuffer.size() - IO_HEADER_SIZE;
(*reinterpret_cast<size_t*>(messageBuffer.data()+sizeof(MessageTypeIdentifier))) = payloadSize;
async_write(m_socket,buffer(message->messageBuffer()),bind(&IOSessionCommon::writeHandler,shared_from_this(),message,placeholders::error));
}
void HttpServerConnection::finishHeader() {
if(write_state == LINE || write_state == HEADER) {
if(write_state == LINE)
writeResponseCode(200,"OK");
if(!out_encoding_chunked)
async_write("\r\n");
write_state = BODY;
} else if(write_state != BODY)
ThrowInternalError("connection not ready for body");
}
void ChatClient::do_write(ChatMessage msg)
{
bool write_in_progress = !write_msgs_.empty();
write_msgs_.push_back(msg);
if (!write_in_progress) {
async_write(socket_, buffer(write_msgs_.front().data(), write_msgs_.front().length()),
boost::bind(&ChatClient::handle_write, this,
boost::asio::placeholders::error));
}
}
void i2p_stream::send_accept(boost::shared_ptr<handler_type> h)
{
TORRENT_ASSERT(m_magic == 0x1337);
m_state = read_accept_response;
char cmd[400];
int size = snprintf(cmd, sizeof(cmd), "STREAM ACCEPT ID=%s\n", m_id);
// fprintf(stderr, ">>> %s", cmd);
ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
async_write(m_sock, boost::asio::buffer(cmd, size)
, boost::bind(&i2p_stream::start_read_line, this, _1, h));
}
inline void async_write(AsyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a WriteHandler.
BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
async_write(s, b.data(), transfer_all(),
detail::write_streambuf_handler<
AsyncWriteStream, Allocator, WriteHandler>(b, handler));
}
void i2p_stream::send_name_lookup(boost::shared_ptr<handler_type> h)
{
TORRENT_ASSERT(m_magic == 0x1337);
m_state = read_name_lookup_response;
char cmd[1024];
int size = snprintf(cmd, sizeof(cmd), "NAMING LOOKUP NAME=%s\n", m_name_lookup.c_str());
// fprintf(stderr, ">>> %s", cmd);
ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
async_write(m_sock, boost::asio::buffer(cmd, size)
, boost::bind(&i2p_stream::start_read_line, this, _1, h));
}
int HTTPConnectionWriteChunkv(HTTPConnectionRef const conn, uv_buf_t const parts[], unsigned int const count) {
if(!conn) return 0;
uint64_t total = 0;
for(size_t i = 0; i < count; i++) total += parts[i].len;
if(total <= 0) return 0;
int rc = 0;
rc = rc < 0 ? rc : HTTPConnectionWriteChunkLength(conn, total);
rc = rc < 0 ? rc : async_write((uv_stream_t *)conn->stream, parts, count);
rc = rc < 0 ? rc : HTTPConnectionWrite(conn, (byte_t const *)STR_LEN("\r\n"));
return rc;
}
void HttpServerConnection::finish() {
finishHeader();
if(out_encoding_chunked) // finish chunk
async_write("\r\n0\r\n\r\n");
async_write_buffered();
if(keep_alive) {
write_state = LINE;
set_nodelay(true); // flushes it
set_nodelay(false);
} else
gracefulClose();
}
void i2p_stream::send_session_create(boost::shared_ptr<handler_type> h)
{
TORRENT_ASSERT(m_magic == 0x1337);
m_state = read_session_create_response;
char cmd[400];
int size = snprintf(cmd, sizeof(cmd), "SESSION CREATE STYLE=STREAM ID=%s DESTINATION=TRANSIENT\n"
, m_id);
// fprintf(stderr, ">>> %s", cmd);
ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
async_write(m_sock, boost::asio::buffer(cmd, size)
, boost::bind(&i2p_stream::start_read_line, this, _1, h));
}
void i2p_stream::send_connect(boost::shared_ptr<handler_type> h)
{
TORRENT_ASSERT(m_magic == 0x1337);
m_state = read_connect_response;
char cmd[1024];
int size = snprintf(cmd, sizeof(cmd), "STREAM CONNECT ID=%s DESTINATION=%s\n"
, m_id, m_dest.c_str());
// fprintf(stderr, ">>> %s", cmd);
ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
async_write(m_sock, boost::asio::buffer(cmd, size)
, boost::bind(&i2p_stream::start_read_line, this, _1, h));
}
void
tcp_client::async_write(void) {
m_io_service.async_write(m_fd, m_write_buffer, m_write_buffer.size(),
[&](std::size_t length) {
std::lock_guard<std::mutex> lock(m_write_buffer_mutex);
m_write_buffer.erase(m_write_buffer.begin(), m_write_buffer.begin() + length);
if (m_is_connected and m_write_buffer.size())
async_write();
});
}
void process(){
_handler->process( _cur , this );
if (_reply.data){
async_write( _socket ,
buffer( (char*)_reply.data , _reply.data->len ) ,
boost::bind( &MessageServerSession::handleWriteDone , shared_from_this() , boost::asio::placeholders::error ) );
} else {
_cur.reset();
_startHeaderRead();
}
}
void sendMsg(unsigned id, F f, O o, Message msg)
{
if (hasConnection(id)) {
PtrBuffer buffer = getSendBuffer(id);
ostream os(&(*buffer));
os << msg.serialize() << '\0';
async_write(*getSocket(id), *buffer,
bind(&ConnectionList::_sendMsg<F, O>, this, id, f, o, msg, _1, _2));
}
}
void handle_remote_read(const boost::system::error_code& error,
const size_t& bytes_transferred)
{
if (!error)
{
async_write(client_socket_,
boost::asio::buffer(remote_data_, bytes_transferred),
client_write_);
}
else
close();
}
void Connection::send(const char * begin, const char * end)
{
MLOG_MESSAGE(Debug, "send(" << requestId_ << ", " << mlog::dump(begin, end) << ")");
const char * prefix = "Content-Type: text/plain\r\n\r\n";
size_t prefixLen = strlen(prefix);
size_t len = end - begin + prefixLen;
size_t alen = (len + 7) / 8 * 8;
RequestId reqId = mstd::hton(requestId_);
output_.resize(0x1000); //sizeof(FCGIRecord) + ahlen + sizeof(FCGIRecord) + alen + sizeof(FCGIRecord) + sizeof(FCGIRecord) + sizeof(FCGIEndRequestBody));
char * out = &output_[0];
FCGIRecord * rec = mstd::pointer_cast<FCGIRecord*>(out);
rec->version = 1;
rec->type = FCGI_STDOUT;
rec->requestId = reqId;
rec->contentLength = mstd::hton<uint16_t>(len);
rec->paddingLength = alen - len;
rec->reserved = 0;
out += sizeof(*rec);
memcpy(out, prefix, prefixLen);
out += prefixLen;
memcpy(out, begin, end - begin);
out += alen - prefixLen;
rec = mstd::pointer_cast<FCGIRecord*>(out);
rec->version = 1;
rec->type = FCGI_STDOUT;
rec->requestId = reqId;
rec->contentLength = mstd::hton<uint16_t>(0);
rec->paddingLength = 0;
rec->reserved = 0;
out += sizeof(*rec);
rec = mstd::pointer_cast<FCGIRecord*>(out);
rec->version = 1;
rec->type = FCGI_END_REQUEST;
rec->requestId = reqId;
rec->contentLength = mstd::hton<uint16_t>(sizeof(FCGIEndRequestBody));
rec->paddingLength = 0;
rec->reserved = 0;
out += sizeof(*rec);
FCGIEndRequestBody * body = mstd::pointer_cast<FCGIEndRequestBody*>(out);
body->appStatus = mstd::hton<uint32_t>(0);
body->protocolStatus = FCGI_REQUEST_COMPLETE;
out += sizeof(*body);
output_.resize(out - &output_[0]);
async_write(**socket_, boost::asio::buffer(output_), bindWrite(ptr()));
}
CAMLprim value iocp_ml_write(value fd, value vbuf, value vlen)
{
CAMLparam3(fd, vbuf, vlen);
CAMLlocal1(res);
intnat len = Long_val(vlen);
SOCKET s = Socket_val(fd);
char *buf = String_val(vbuf);
assert(Descr_kind_val(fd) == KIND_SOCKET);
res = Val_int(async_write(s, buf, len));
CAMLreturn(res);
/* async_write(s, buf, len); */
/* return Val_unit; */
}
void ChatClient::handle_write(const error_code &error)
{
if (!error) {
write_msgs_.pop_front();
if (!write_msgs_.empty()) {
async_write(socket_, buffer(write_msgs_.front().data(), write_msgs_.front().length()),
boost::bind(&ChatClient::handle_write, this,
boost::asio::placeholders::error));
}
} else {
do_close();
}
}
