/**
* Received message callback. This function is executed to process the
* received messages. If this is a valid message, the message is
* dispatched to the handler defined by the user.
*
* @param buff Message byte buffer.
* @param rbytes Size of the message.
* @param ec Error code.
*/
void link::recv_handler(buffer<uint8>& buff, size_t rbytes,
const boost::system::error_code& ec)
{
if (ec) {
mih::message pm;
_handler(pm, ec);
} else {
mih::frame* fm = mih::frame::cast(buff.get(), rbytes);
if (fm) {
mih::message pm(*fm);
_handler(pm, ec);
}
}
void* rbuff = buff.get();
size_t rlen = buff.size();
_sock.async_receive(boost::asio::buffer(rbuff, rlen),
boost::bind(&link::recv_handler,
this,
bind_rv(buff),
boost::asio::placeholders::bytes_transferred,
boost::asio::placeholders::error));
}
bool OsTimer::signalHandler(boost::system::error_code ec)
{
if (!_handler)
return false;
_handler(*this, ec);
return true;
}
bool Connection::processReceive(size_t bytes, bool proxy)
{
for (auto i = 0; i < bytes; i++) {
if (_parser.advance(_buffer[i], _response) == Complete) {
_parser.reset();
if (proxy) {
_response = HttpResponse();
}
else {
auto cookies = _response.headers("Set-Cookie");
for (auto cookie : cookies) {
_context.setCookie(cookie);
}
if (_request.close() || _response.has("Connection", "Close"))
closeConnection();
auto response = std::move(_response);
_response = HttpResponse();
_handler(std::move(response), error_code());
_handler = nullptr;
_busy = false;
}
return true;
}
}
return false;
}
void event_timer::operator()(void){
tcode::diagnostics::error_code ec;
if ( tcode::threading::atomic_bit_on( _flag , FLAG_CANCEL )){
ec = tcode::diagnostics::cancel;
}
_handler( ec , *this);
}
void CLS_PROC::_start(){
do{
_handler();
usleep(FLAGS_query_interval);
}while(!m_exit);
}
virtual void exec()
{
if (nullptr != _handler)
{
_handler();
_handler = nullptr;
}
}
/**
* Received message callback. This function is executed to process the
* received messages. If this is a valid message, the message is
* dispatched to the handler defined by the user.
*
* @param buff Message byte buffer.
* @param rbytes Size of the message.
* @param ec Error code.
*/
void user::recv_handler(buffer<uint8>& buff, size_t rbytes, const boost::system::error_code& ec)
{
if (ec) {
mih::message pm;
_handler(pm, ec);
} else {
mih::frame* fm = mih::frame::cast(buff.get(), rbytes);
if (fm) {
mih::message pm(*fm);
if (fm->opcode() == mih::operation::confirm) {
handler h;
get_handler(fm->tid(), h);
if (h) {
h(pm, ec);
// Unsolicited MIH capability discover reception
} else if(fm->sid() == mih::service::management &&
fm->aid() == mih::action::capability_discover) {
_handler(pm, ec);
} else {
_handler(pm, boost::system::errc::make_error_code(boost::system::errc::bad_message));
}
} else if (fm->opcode() != mih::operation::indication) {
_handler(pm, boost::system::errc::make_error_code(boost::system::errc::bad_message));
} else {
_handler(pm, ec);
}
}
}
void* rbuff = buff.get();
size_t rlen = buff.size();
_sock.async_receive(boost::asio::buffer(rbuff, rlen),
boost::bind(&user::recv_handler,
this,
bind_rv(buff),
boost::asio::placeholders::bytes_transferred,
boost::asio::placeholders::error));
}
bool Connection::handleError(const error_code &ec)
{
if (ec) {
_handler(std::move(_response), ec);
_handler = nullptr;
closeConnection();
return true;
}
return false;
}
void UART_handler::handler(void)
{
while (not _uart->is_empty())
{
if (add(_uart->getc()) == DATA_READY)
{
_flag = COMPLETE;
_handler(this);
}
}
}
void BSDEthernetTap::threadMain()
throw()
{
fd_set readfds,nullfds;
MAC to,from;
int n,nfds,r;
char getBuf[8194];
// Wait for a moment after startup -- wait for Network to finish
// constructing itself.
Thread::sleep(500);
FD_ZERO(&readfds);
FD_ZERO(&nullfds);
nfds = (int)std::max(_shutdownSignalPipe[0],_fd) + 1;
r = 0;
for(;;) {
FD_SET(_shutdownSignalPipe[0],&readfds);
FD_SET(_fd,&readfds);
select(nfds,&readfds,&nullfds,&nullfds,(struct timeval *)0);
if (FD_ISSET(_shutdownSignalPipe[0],&readfds)) // writes to shutdown pipe terminate thread
break;
if (FD_ISSET(_fd,&readfds)) {
n = (int)::read(_fd,getBuf + r,sizeof(getBuf) - r);
if (n < 0) {
if ((errno != EINTR)&&(errno != ETIMEDOUT))
break;
} else {
// Some tap drivers like to send the ethernet frame and the
// payload in two chunks, so handle that by accumulating
// data until we have at least a frame.
r += n;
if (r > 14) {
if (r > ((int)_mtu + 14)) // sanity check for weird TAP behavior on some platforms
r = _mtu + 14;
if (_enabled) {
to.setTo(getBuf,6);
from.setTo(getBuf + 6,6);
unsigned int etherType = ntohs(((const uint16_t *)getBuf)[6]);
// TODO: VLAN support
_handler(_arg,_nwid,from,to,etherType,0,(const void *)(getBuf + 14),r - 14);
}
r = 0;
}
}
}
}
}
void socket::onClose()
{
auto buf = buffer::create(0);
(*buf) << (get_remoteaddress());
message msg(buf);
msg.set_type(EMessageType::SocketClose);
msg.set_sender(_sockid);
msg.set_receiver(_module_id);
_handler(msg);
_service.remove_socket(_sockid);
}
static void *rc_loop(void *args)
{
uint32_t ev;
while(1) {
rc_get_event(&ev);
if(ev != 255)
{
_handler(ev);
}
}
}
void useShader(QOpenGLShaderProgram& _s,
std::function<void(UniformHandler&)>f) {
withCurrentContext([&](QOpenGLFunctions& _gl) {
_s.bind();
{
UniformHandler _handler(_gl, _s);
f(_handler);
// Destructor of handler is called here implicitly
// by RAII to unbind all textures
}
_s.release();
});
}
/**
* Send the supplied message then read back the other node's response
* and pass that to the user-supplied handler.
*
* @target_ssid The name of the AP the other node has set up.
* @message The string to send to the node.
* @returns: True if the exchange was a succes, false otherwise.
*
*/
bool ESP8266WiFiMesh::exchangeInfo(String message, WiFiClient curr_client)
{
curr_client.println( message.c_str() );
if (!waitForClient(curr_client, 1000))
return false;
String response = curr_client.readStringUntil('\r');
curr_client.readStringUntil('\n');
if (response.length() <= 2)
return false;
/* Pass data to user callback */
_handler(response);
return true;
}
void socket::handleRead(const asio::error_code& e, std::size_t bytes_transferred)
{
if (bytes_transferred == 0 || e)
{
_state = ESocketState::ClientClose;
_errorCode = e;
onClose();
return;
}
if (!e && bytes_transferred)
{
_lastRecvTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
_recvBuf.append(_recvBuffer, bytes_transferred);
while (_recvBuf.size() > sizeof(msg_size_t))
{
msg_size_t size = *(msg_size_t*)_recvBuf.data();
if (size > MAX_MSG_SIZE)
{
onClose();
return;
}
assert(size <= MAX_MSG_SIZE);
//消息不完整 继续接收消息
if (_recvBuf.size() < sizeof(msg_size_t) + size)
{
break;
}
_recvBuf.skip(sizeof(msg_size_t));
auto buf = buffer::create(size, 24);
buf->append(_recvBuf.data(), size);
message msg(buf);
msg.set_type(EMessageType::SocketData);
msg.set_sender(_sockid);
msg.set_receiver(_module_id);
_handler(msg);
_recvBuf.skip(size);
}
postRead();
}
}
void Timer::update(float time, BaseGameObject* object)
{
bool enabled = (EnableHandler != NULL) ? EnableHandler(object): true;
if (enabled || (_timeCounter < _startTime))
_timeCounter += time;
if (!enabled && (_timeCounter > _startTime))
_timeCounter = _startTime;
if (enabled)
{
if (_timeCounter > _time)
{
_handler(object);
_timeCounter = 0.0f;
}
}
}
void ESP8266WiFiMesh::acceptRequest()
{
while (true) {
_client = _server.available();
if (!_client)
break;
if (!waitForClient(_client, 1500)) {
continue;
}
/* Read in request and pass it to the supplied handler */
String request = _client.readStringUntil('\r');
_client.readStringUntil('\n');
String response = _handler(request);
/* Send the response back to the client */
if (_client.connected())
_client.println(response);
}
}
bool socket::start()
{
_lastRecvTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
_remoteEndPoint = _socket.remote_endpoint(_errorCode);
_state = ESocketState::Ok;
if (checkState())
{
auto buf = buffer::create(0);
(*buf) << get_remoteaddress();
message msg(buf);
msg.set_type(EMessageType::SocketConnect);
msg.set_sender(_sockid);
msg.set_receiver(_module_id);
_handler(msg);
postRead();
return true;
}
return false;
}
void IpcConnection::threadMain()
throw()
{
char tmp[65536];
char linebuf[65536];
unsigned int lineptr = 0;
char c;
#ifdef __WINDOWS__
DWORD n,i;
std::string wbuf;
#else
int s,n,i;
#endif
while (_run) {
#ifdef __WINDOWS__
{
Mutex::Lock _l(_writeLock);
if (!_run)
break;
if (_writeBuf.length() > 0) {
wbuf.append(_writeBuf);
_writeBuf.clear();
}
}
if (wbuf.length() > 0) {
n = 0;
if ((WriteFile(_sock,wbuf.data(),(DWORD)(wbuf.length()),&n,NULL))&&(n > 0)) {
if (n < (DWORD)wbuf.length())
wbuf.erase(0,n);
else wbuf.clear();
} else if (GetLastError() != ERROR_OPERATION_ABORTED)
break;
FlushFileBuffers(_sock);
}
if (!_run)
break;
n = 0;
if ((!ReadFile(_sock,tmp,sizeof(tmp),&n,NULL))||(n <= 0)) {
if (GetLastError() == ERROR_OPERATION_ABORTED)
n = 0;
else break;
}
if (!_run)
break;
#else
if ((s = _sock) <= 0)
break;
n = (int)::read(s,tmp,sizeof(tmp));
if ((n <= 0)||(_sock <= 0))
break;
#endif
for(i=0;i<n;++i) {
c = (linebuf[lineptr] = tmp[i]);
if ((c == '\r')||(c == '\n')||(lineptr == (sizeof(linebuf) - 1))) {
if (lineptr) {
linebuf[lineptr] = (char)0;
_handler(_arg,this,IPC_EVENT_COMMAND,linebuf);
lineptr = 0;
}
} else ++lineptr;
}
}
_writeLock.lock();
bool r = _run;
_writeLock.unlock();
#ifdef __WINDOWS__
if (_incoming)
DisconnectNamedPipe(_sock);
CloseHandle(_sock);
_running = false;
#endif
if (r)
_handler(_arg,this,IPC_EVENT_CONNECTION_CLOSED,(const char *)0);
}
void operator()( void ) {
tls_data td;
tls_data::instance(&td);
_handler();
tls_data::instance(nullptr);
}
ret_type operator()(void)
{
_handler();
}
void SingleTimer::onTimeout() {
if (_handler) {
_handler();
}
}
void Http::Request::main()
throw()
{
char buf[131072];
try {
http_parser_init(&_parser,HTTP_RESPONSE);
_parser.data = this;
http_parser_url urlParsed;
if (http_parser_parse_url(_url.c_str(),_url.length(),0,&urlParsed)) {
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"URL parse error");
return;
}
if (!(urlParsed.field_set & (1 << UF_SCHEMA))) {
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"URL specifies no schema");
return;
}
std::string schema(_url.substr(urlParsed.field_data[UF_SCHEMA].off,urlParsed.field_data[UF_SCHEMA].len));
if (schema == "file") {
const std::string filePath(_url.substr(urlParsed.field_data[UF_PATH].off,urlParsed.field_data[UF_PATH].len));
uint64_t lm = Utils::getLastModified(filePath.c_str());
if (lm) {
const std::map<std::string,std::string>::const_iterator ifModSince(_requestHeaders.find("If-Modified-Since"));
if ((ifModSince != _requestHeaders.end())&&(ifModSince->second.length())) {
uint64_t t64 = Utils::fromRfc1123(ifModSince->second);
if ((t64)&&(lm > t64)) {
suicidalThread = !_handler(this,_arg,_url,304,_responseHeaders,"");
return;
}
}
if (Utils::readFile(filePath.c_str(),_responseBody)) {
_responseHeaders["Last-Modified"] = Utils::toRfc1123(lm);
suicidalThread = !_handler(this,_arg,_url,200,_responseHeaders,_responseBody);
return;
}
}
suicidalThread = !_handler(this,_arg,_url,404,_responseHeaders,"file not found or not readable");
return;
} else if (schema == "http") {
if (!(urlParsed.field_set & (1 << UF_HOST))) {
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"URL contains no host");
return;
}
std::string host(_url.substr(urlParsed.field_data[UF_HOST].off,urlParsed.field_data[UF_HOST].len));
std::list<InetAddress> v4,v6;
{
struct addrinfo *res = (struct addrinfo *)0;
if (!getaddrinfo(host.c_str(),(const char *)0,(const struct addrinfo *)0,&res)) {
struct addrinfo *p = res;
do {
if (p->ai_family == AF_INET)
v4.push_back(InetAddress(p->ai_addr));
else if (p->ai_family == AF_INET6)
v6.push_back(InetAddress(p->ai_addr));
} while ((p = p->ai_next));
freeaddrinfo(res);
}
}
std::list<InetAddress> *addrList;
if (v4.empty()&&v6.empty()) {
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"could not find address for host in URL");
return;
} else if (v4.empty()) {
addrList = &v6;
} else {
addrList = &v4;
}
InetAddress *addr;
{
addrList->sort();
addrList->unique();
unsigned int i = 0,k = 0;
k = Utils::randomInt<unsigned int>() % addrList->size();
std::list<InetAddress>::iterator a(addrList->begin());
while (i++ != k) ++a;
addr = &(*a);
}
int remotePort = ((urlParsed.field_set & (1 << UF_PORT))&&(urlParsed.port)) ? (int)urlParsed.port : (int)80;
if ((remotePort <= 0)||(remotePort > 0xffff)) {
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"URL port out of range");
return;
}
addr->setPort(remotePort);
_fd = socket(addr->isV6() ? AF_INET6 : AF_INET,SOCK_STREAM,0);
if (_fd <= 0) {
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"could not open socket");
return;
}
for(;;) {
if (connect(_fd,addr->saddr(),addr->saddrLen())) {
if (errno == EINTR)
continue;
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"connection failed to remote host");
return;
} else break;
}
const char *mstr = "GET";
switch(_method) {
case HTTP_METHOD_HEAD: mstr = "HEAD"; break;
default: break;
}
int mlen = (int)snprintf(buf,sizeof(buf),"%s %s HTTP/1.1\r\nAccept-Encoding: \r\nHost: %s\r\n",mstr,_url.substr(urlParsed.field_data[UF_PATH].off,urlParsed.field_data[UF_PATH].len).c_str(),host.c_str());
if (mlen >= (int)sizeof(buf)) {
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"URL too long");
return;
}
if (!_sendAll(_fd,buf,mlen)) {
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"write error");
return;
}
for(std::map<std::string,std::string>::const_iterator rh(_requestHeaders.begin());rh!=_requestHeaders.end();++rh) {
mlen = (int)snprintf(buf,sizeof(buf),"%s: %s\r\n",rh->first.c_str(),rh->second.c_str());
if (mlen >= (int)sizeof(buf)) {
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"header too long");
return;
}
if (!_sendAll(_fd,buf,mlen)) {
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"write error");
return;
}
}
if (!_sendAll(_fd,"\r\n",2)) {
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"write error");
return;
}
_responseStatusCode = 0;
_messageComplete = false;
for(;;) {
mlen = (int)::recv(_fd,buf,sizeof(buf),0);
if (mlen < 0) {
if (errno != EINTR)
break;
else continue;
}
if (((int)http_parser_execute(&_parser,&_http_parser_settings,buf,mlen) != mlen)||(_parser.upgrade)) {
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"invalid HTTP response from server");
return;
}
if (_messageComplete) {
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,_responseStatusCode,_responseHeaders,_responseBody);
return;
}
}
::close(_fd); _fd = 0;
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"empty HTTP response from server");
return;
} else {
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"only 'file' and 'http' methods are supported");
return;
}
} catch ( ... ) {
suicidalThread = !_handler(this,_arg,_url,0,_responseHeaders,"unexpected exception retrieving URL");
return;
}
}
void complete()
{
_handler(_read_error, _write_error, _bytes_read, _bytes_written);
}
virtual bool on_timer() { _handler(); return true; }
