int AcceptHandler::handle_input(ACE_HANDLE) {
ACE_TRACE("AcceptHandler::handle_input(ACE_HANDLE)");
ACE_INET_Addr clientAddr;
// create a new ReadHandler
ReadHandler *reader = 0;
ACE_NEW_NORETURN (reader, ReadHandler());
if (reader == 0)
ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to allocate ")
ACE_TEXT ("reader. (errno = %i: %m)\n"), errno), -1);
// put reader in an auto pointer so we can use ACE_ERROR_RETURN safely
auto_ptr<ReadHandler> pReader(reader);
// accept the connection using the reader's stream
if (mAcceptor.accept(reader->getStream(), &clientAddr) == -1)
ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to accept ")
ACE_TEXT ("client connection. (errno = %i: %m)\n"), errno), -1);
// register the reader with the reactor
if (mReactor->register_handler(reader,
ACE_Event_Handler::READ_MASK) == -1)
ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to register ")
ACE_TEXT ("read handler. (errno = %i: %m)\n"), errno), -1);
// from now on the read handler takes care of itself
pReader.release();
return 0; // keep going
}
void Socket::ReadHandlerInternal(boost::system::error_code error, size_t transferredBytes)
{
if (error)
{
CloseSocket();
return;
}
_readBuffer.WriteCompleted(transferredBytes);
ReadHandler();
}
void Win32NamedPipeNetworkSession::implRead(char * buffer, std::size_t bufferLen)
{
if ( !mSocketPtr )
{
RCF_LOG_4() << "Win32NamedPipeNetworkSession - connection has been closed.";
return;
}
RCF_LOG_4()(bufferLen)
<< "Win32NamedPipeNetworkSession - calling ReadFile().";
ASIO_NS::windows::overlapped_ptr overlapped(
mSocketPtr->get_io_service(),
ReadHandler(sharedFromThis()));
DWORD dwBytesRead = 0;
bool readOk = false;
HANDLE hPipe = mSocketPtr->native();
BOOL ok = ReadFile(
hPipe,
buffer,
static_cast<DWORD>(bufferLen),
&dwBytesRead,
overlapped.get());
DWORD realError = 0;
DWORD dwErr = 0;
if (!ok)
{
dwErr = GetLastError();
if ( dwErr != ERROR_IO_PENDING
&& dwErr != ERROR_MORE_DATA)
{
realError = dwErr;
}
}
if ( dwBytesRead
|| (ok && dwBytesRead == 0 && bufferLen == 0)
|| (!ok && realError == 0))
{
readOk = true;
}
if (readOk)
{
overlapped.release();
}
else
{
AsioErrorCode ec(
dwErr,
ASIO_NS::error::get_system_category());
overlapped.complete(ec, 0);
}
}
void IrcBot::ConnectHandler(const boost::system::error_code &error)
{
ConsoleMessage("connect handler");
if (!error)
{
boost::asio::write(sock, buffer(pass));
boost::asio::write(sock, buffer(nick));
boost::asio::write(sock, buffer(user));
sock.async_read_some(buffer(readBuffer), [this](boost::system::error_code ec, std::size_t bytesRead) { ReadHandler(ec, bytesRead); });
}
}
void IrcBot::ReadHandler(const boost::system::error_code &error, std::size_t bytesRead)
{
if (shuttingDown)
{
return;
}
if (!error)
{
messageString = readBuffer.data();
std::cout << std::string(readBuffer.data(), bytesRead);
HandlePing(messageString);
// handle welcome message 001
if (messageString.find(serverWelcomeMessage) == 0)//if (messageString.find(":" + serverName + " 001") == 0)
{
Send(join);
}
HandleRequest(messageString);
if (activeGame != NONE)
{
HandleGameInput(messageString);
}
readBuffer.fill('\0');
sock.async_read_some(buffer(readBuffer), [this](boost::system::error_code ec, std::size_t bytesRead) { ReadHandler(ec, bytesRead); });
}
else
{
ConsoleMessage(error.message());
}
}
/*
* lower level routine for actually handling a request
* deals with data (ping is handled higher)
*/
void *DataHandler(void *v)
{
struct handlerdata *hd = v;
char *retbuffer = NULL;
struct client_msg cm; // the return message
#if OW_CYGWIN
/* Random generator seem to need initialization for each new thread
* If not, seed will be reset and rand() will return 0 the first call.
*/
{
struct timeval tv;
gettimeofday(&tv, NULL);
srand((unsigned int) tv.tv_usec);
}
#endif
memset(&cm, 0, sizeof(struct client_msg));
cm.version = MakeServerprotocol(OWSERVER_PROTOCOL_VERSION);
cm.control_flags = hd->sm.control_flags; // default flag return -- includes persistence state
/* Pre-handling for special testing mode to exclude certain messages */
switch ((enum msg_classification) hd->sm.type) {
case msg_dirall:
case msg_dirallslash:
if (Globals.no_dirall) {
LEVEL_DEBUG("DIRALL message rejected.") ;
hd->sm.type = msg_error;
}
break;
case msg_get:
case msg_getslash:
if (Globals.no_get) {
LEVEL_DEBUG("GET message rejected.") ;
hd->sm.type = msg_error;
}
break;
default:
break;
}
/* Now Check message types and only parse valid messages */
switch ((enum msg_classification) hd->sm.type) { // outer switch
case msg_read: // good message
case msg_write: // good message
case msg_dir: // good message
case msg_presence: // good message
case msg_dirall: // good message
case msg_dirallslash: // good message
case msg_get: // good message
case msg_getslash: // good message
if (hd->sm.payload == 0) { /* Bad query -- no data after header */
LEVEL_DEBUG("No payload -- ignore.") ;
cm.ret = -EBADMSG;
} else {
struct parsedname *pn;
OWQ_allocate_struct_and_pointer(owq);
pn = PN(owq);
/* Parse the path string and crete query object */
LEVEL_CALL("DataHandler: parse path=%s", hd->sp.path);
cm.ret = BAD( OWQ_create(hd->sp.path, owq) ) ? -1 : 0 ;
if ( cm.ret != 0 ) {
LEVEL_DEBUG("DataHandler: OWQ_create failed cm.ret=%d", cm.ret);
break;
}
/* Use client persistent settings (temp scale, display mode ...) */
pn->control_flags = hd->sm.control_flags;
/* Override some settings from control flags */
if ( (pn->control_flags & UNCACHED) != 0 ) {
// client wants uncached
pn->state |= ePS_uncached;
}
if ( (pn->control_flags & ALIAS_REQUEST) == 0 ) {
// client wants unaliased
pn->state |= ePS_unaliased;
}
/* Antilooping tags */
pn->tokens = hd->sp.tokens;
pn->tokenstring = hd->sp.tokenstring;
//printf("Handler: sm.sg=%X pn.state=%X\n", sm.sg, pn.state);
//printf("Scale=%s\n", TemperatureScaleName(SGTemperatureScale(sm.sg)));
switch ((enum msg_classification) hd->sm.type) {
case msg_presence:
LEVEL_CALL("Presence message for %s", SAFESTRING(pn->path));
// Basically, if we were able to ParsedName it's here!
cm.size = 0;
retbuffer = owmalloc( SERIAL_NUMBER_SIZE ) ;
if ( retbuffer ) {
memcpy( retbuffer, pn->sn, SERIAL_NUMBER_SIZE ) ;
cm.payload = SERIAL_NUMBER_SIZE ;
} else {
cm.payload = 0 ;
}
cm.ret = 0; // good answer
break;
case msg_read:
LEVEL_CALL("Read message");
retbuffer = ReadHandler(hd, &cm, owq);
LEVEL_DEBUG("Read message done value=%p", retbuffer);
break;
case msg_write:
LEVEL_CALL("Write message");
if ( (int) hd->sp.datasize < hd->sm.size ) {
cm.ret = -EMSGSIZE;
} else {
/* set buffer (size already set) */
OWQ_assign_write_buffer( (ASCII *) hd->sp.data, hd->sm.size, hd->sm.offset, owq) ;
WriteHandler(hd, &cm, owq);
}
break;
case msg_dir:
LEVEL_CALL("Directory message (one at a time)");
DirHandler(hd, &cm, pn);
break;
case msg_dirall:
LEVEL_CALL("Directory message (all at once)");
retbuffer = DirallHandler(hd, &cm, pn);
break;
case msg_dirallslash:
LEVEL_CALL("Directory message (all at once, with directory /)");
retbuffer = DirallslashHandler(hd, &cm, pn);
break;
case msg_get:
if (IsDir(pn)) {
LEVEL_CALL("Get -> Directory message (all at once)");
retbuffer = DirallHandler(hd, &cm, pn);
} else {
LEVEL_CALL("Get -> Read message");
retbuffer = ReadHandler(hd, &cm, owq);
}
break;
case msg_getslash:
if (IsDir(pn)) {
LEVEL_CALL("Get -> Directory message (all at once)");
retbuffer = DirallslashHandler(hd, &cm, pn);
} else {
LEVEL_CALL("Get -> Read message");
retbuffer = ReadHandler(hd, &cm, owq);
}
break;
default: // never reached
LEVEL_CALL("Error: unknown message %d", (int) hd->sm.type);
break;
}
OWQ_destroy(owq);
LEVEL_DEBUG("DataHandler: FS_ParsedName_destroy done");
}
break;
case msg_nop: // "bad" message
LEVEL_CALL("NOP message");
cm.ret = 0;
break;
case msg_size: // no longer used
case msg_error:
default: // "bad" message
cm.ret = -ENOMSG;
LEVEL_CALL("No message");
break;
}
LEVEL_DEBUG("DataHandler: cm.ret=%d", cm.ret);
TOCLIENTLOCK(hd);
if (cm.ret != -EIO) {
ToClient(hd->file_descriptor, &cm, retbuffer);
} else {
ErrorToClient(hd, &cm) ;
}
// Signal to PingLoop that we're done.
hd->toclient = toclient_complete ;
if ( hd->ping_pipe[fd_pipe_write] != FILE_DESCRIPTOR_BAD ) {
ignore_result = write( hd->ping_pipe[fd_pipe_write],"X",1) ; //dummy payload
}
TOCLIENTUNLOCK(hd);
if (retbuffer) {
owfree(retbuffer);
}
LEVEL_DEBUG("Finished with client request");
return VOID_RETURN;
}
