//有数据传过来了，读取数据
void ReadFromServer(aeEventLoop *el, int fd, void *privdata, int mask)
{
char buffer[MAX_LEN] = { 0 };
int res;
res = read(fd, buffer, MAX_LEN-1);
if( res == 0 ){
//printf("client socket closed...\n");
ClientClose(el, fd, res);
}
else if( res < 0 ){
if(errno == EWOULDBLOCK || errno == EAGAIN){
//printf("read finished...\n");
}
else if(errno == EINTR){
//printf("initevent....continue...");
}
else{
//printf("read error...\n");
ClientClose(el, fd, res);
}
}
else if( res == MAX_LEN-1){
//printf("partial content : %s", buffer);
//printf("read not finished...continue...\n");
}
else if( 0 < res < MAX_LEN-1){
//printf("partial content : %s", buffer);
//printf("read finished...\n");
total_res += 1;
aeDeleteFileEvent(el, fd, AE_READABLE);
WriteHandler(el, fd, NULL, 0);
}
}
void
Sender_exec_i::get_started (void)
{
try
{
if (this->wh_)
{
delete this->wh_;
this->wh_ = 0;
}
ACE_NEW_THROW_EX (this->wh_,
WriteHandler (*this),
::CORBA::NO_MEMORY ());
this->reactor ()->notify (this->wh_);
}
catch (const ::CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ERROR: get_started : Exception caught\n")));
}
catch (...)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ERROR: get_started : Unknown exception caught\n")));
}
}
Sender_exec_i::Sender_exec_i (void)
: keys_ (5)
, iterations_ (ITERATIONS)
{
ACE_NEW_THROW_EX (this->wh_,
WriteHandler (*this),
::CORBA::NO_MEMORY ());
}
void Win32NamedPipeNetworkSession::implWrite(const std::vector<ByteBuffer> & buffers)
{
if ( !mSocketPtr )
{
RCF_LOG_4() << "Win32NamedPipeNetworkSession - connection has been closed.";
return;
}
RCF_LOG_4()(RCF::lengthByteBuffers(buffers))
<< "Win32NamedPipeNetworkSession - calling WriteFile().";
ASIO_NS::windows::overlapped_ptr overlapped(
mSocketPtr->get_io_service(),
WriteHandler(sharedFromThis()));
const ByteBuffer & byteBuffer = buffers.front();
DWORD dwBytesWritten = 0;
bool writeOk = false;
HANDLE hPipe = mSocketPtr->native();
BOOL ok = WriteFile(
hPipe,
byteBuffer.getPtr(),
static_cast<DWORD>(byteBuffer.getLength()),
&dwBytesWritten,
overlapped.get());
DWORD dwErr = GetLastError();;
if (!ok && (
dwErr == ERROR_IO_PENDING
|| dwErr == ERROR_MORE_DATA))
{
writeOk = true;
}
else if (dwBytesWritten)
{
writeOk = true;
}
if (writeOk)
{
overlapped.release();
}
else
{
AsioErrorCode ec(
dwErr,
ASIO_NS::error::get_system_category());
overlapped.complete(ec, 0);
}
}
Sender_exec_i::Sender_exec_i (void)
: iterations_ (3),
run_ (1),
total_iter (0),
wh_ (0)
{
ACE_NEW_THROW_EX (this->wh_,
WriteHandler (*this),
CORBA::INTERNAL ());
}
void
Sender_exec_i::restart (void)
{
++this->run_;
delete this->wh_;
ACE_NEW_THROW_EX (this->wh_,
WriteHandler (*this),
CORBA::INTERNAL ());
this->reactor ()->notify (this->wh_);
}
void
Sender_exec_i::restart (void)
{
++this->run_;
if (this->wh_)
{
delete this->wh_;
this->wh_ = 0;
}
ACE_NEW_THROW_EX (this->wh_,
WriteHandler (*this),
::CORBA::NO_MEMORY ());
this->reactor ()->notify (this->wh_);
}
void Socket::WriteHandlerWrapper(boost::system::error_code /*error*/, std::size_t /*transferedBytes*/)
{
std::unique_lock<std::mutex> guard(_writeLock);
_isWritingAsync = false;
WriteHandler(guard);
}
void IrcBot::Send(const std::string &message)
{
//writeBuffer = message.data();
for (int i = 0; i < message.size(); i++)
{
wbuf[i] = message[i];
}
try
{
async_write(sock, buffer(wbuf, message.size() * sizeof(char)), [this](boost::system::error_code ec, std::size_t bytesWritten) { WriteHandler(ec, bytesWritten); });
}
catch (boost::system::system_error writeError)
{
ConsoleMessage("Error encountered while sending/writing.");
}
}
/*
* 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;
}
