Exemplo n.º 1
0
    virtual int svc () 
    {  	   
  	   //int  i =0;
  	   ACE_Message_Block *mblk;  	   
	   int  len = 0;
	   
       while(!fin.eof())
      {      	 
      	 fin.getline(file_buf, LineSize);      	 
      	 len = ACE_OS::strlen( file_buf );
         ACE_NEW_RETURN (mblk, ACE_Message_Block (len+200), 0);
         if (file_buf[len-1] == '\r')
         {
         	len = len - 1;
         }          
	     mblk->copy (file_buf, len+1 ); 
	     // 通过put_next函数,将消息传递给下一个过滤器
	     put_next (mblk); 
	  }
       ACE_NEW_RETURN(mblk, ACE_Message_Block (0, ACE_Message_Block::MB_STOP),  0);
	   put_next (mblk);
	   fin.close();
	   ACE_DEBUG ((LM_DEBUG, "read svc return .\n")); 
       return 0;
    }
Exemplo n.º 2
0
 virtual int put (ACE_Message_Block *mblk, ACE_Time_Value *) 
 {
   if (mblk->msg_type () != ACE_Message_Block::MB_STOP)
   {
     size_t fmt_len (ACE_OS::sprintf (mblk->wr_ptr ()-1,  "%s", "attention please!\r\n"  ));
     mblk->wr_ptr (fmt_len);	
   }
   //ACE_DEBUG ((LM_DEBUG, "suffix:%@.%s\n",mblk,mblk->base()));
   return put_next (mblk);
 }
Exemplo n.º 3
0
  virtual int put (ACE_Message_Block *mblk, ACE_Time_Value *) 
  {
  
    for (ACE_Message_Block *temp = mblk;      temp != 0;   temp = temp->cont ())    
    {     
    	 if (temp->msg_type () != ACE_Message_Block::MB_STOP)
      {
      	format_data(temp);
      }
    }
    
    return put_next (mblk);
 } 
Exemplo n.º 4
0
 virtual int svc () 
 {
   int stop = 0;          
   for (ACE_Message_Block *mb; !stop && getq (mb) != -1; ) 
   {
     if (mb->msg_type () == ACE_Message_Block::MB_STOP)
     {
       stop = 1;
     }
     else
     {  	      	    
 	    ACE_DEBUG ((LM_DEBUG, "%s",mb->base()));    	                           
     }
     put_next (mb);
   }
   return 0;
 }
void
RPG_Net_Protocol_Module_IRCSplitter::handleDataMessage(RPG_Net_Protocol_Message*& message_inout,
                                                       bool& passMessageDownstream_out)
{
  RPG_TRACE(ACE_TEXT("RPG_Net_Protocol_Module_IRCSplitter::handleDataMessage"));

  // init return value(s), default behavior is to pass all messages along...
  // --> we don't want that !
  passMessageDownstream_out = false;

  // sanity check(s)
  ACE_ASSERT(message_inout);
  ACE_ASSERT(myIsInitialized);

  // perhaps we already have part of this message ?
  if (myCurrentBuffer)
    myCurrentBuffer->cont(message_inout); // chain the buffer
  myCurrentBuffer = message_inout;

  // scan the bytestream for frame bounds "\r\n"

  // do we know where to start ?
  if (myCurrentMessage == NULL)
    myCurrentMessage = myCurrentBuffer; // start scanning at offset 0...

  // *NOTE*: the scanner checks sequences of >= 2 bytes (.*\r\n)
  // --> make sure we have a minimum amount of data...
  // --> more sanity check(s)
  if (myCurrentMessage->total_length() < RPG_NET_PROTOCOL_IRC_FRAME_BOUNDARY_SIZE)
    return; // don't have enough data, cannot proceed
  if (myCurrentBuffer->length() < RPG_NET_PROTOCOL_IRC_FRAME_BOUNDARY_SIZE)
  {
    // *sigh*: OK, so this CAN actually happen...
    // case1: if we have anything OTHER than '\n', there's nothing to do
    //        --> wait for more data
    // case2: if we have an '\n' we have to check the trailing character
    //        of the PRECEDING buffer:
    //        - if it's an '\r' --> voilà, we've found a frame boundary
    //        - else            --> wait for more data
    if (((*myCurrentBuffer->rd_ptr()) == '\n') &&
        (myCurrentMessage != myCurrentBuffer))
    {
      ACE_Message_Block* preceding_buffer = myCurrentMessage;
      for (;
           preceding_buffer->cont() != myCurrentBuffer;
           preceding_buffer = preceding_buffer->cont());
      if (*(preceding_buffer->rd_ptr() + (preceding_buffer->length() - 1)) == '\r')
      {
        // OK, we have all of it !
        if (myCrunchMessages)
        {
          myCurrentMessage->crunch();
        } // end IF

        // --> push it downstream...
        if (put_next(myCurrentMessage, NULL) == -1)
        {
          ACE_DEBUG((LM_ERROR,
                     ACE_TEXT("failed to ACE_Task::put_next(): \"%m\", continuing\n")));

          // clean up
          myCurrentMessage->release();
        } // end IF

        // bye bye...
        myCurrentMessageLength = 0;
        myCurrentMessage = NULL;
        myCurrentBuffer = NULL;

        return;
      } // end IF
    } // end IF

    return; // don't have enough data, cannot proceed
  } // end IF

  // OK, init scanner...

  // *WARNING*: cannot use yy_scan_buffer(), as flex modifies the data... :-(
//   // *NOTE*: in order to accomodate flex, the buffer needs two trailing
//   // '\0' characters...
//   // --> make sure it has this capacity
//   if (myCurrentBuffer->space() < RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE)
//   {
//     // *sigh*: (try to) resize it then...
//     if (myCurrentBuffer->size(myCurrentBuffer->size() + RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE))
//     {
//       ACE_DEBUG((LM_ERROR,
//                  ACE_TEXT("failed to ACE_Message_Block::size(%u), aborting\n"),
//                  (myCurrentBuffer->size() + RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE)));
//
//       // what else can we do ?
//       return;
//     } // end IF
//     myCurrentBufferIsResized = true;
//
//     // *WARNING*: beyond this point, make sure we resize the buffer back
//     // to its original length...
//     // *NOTE*: this is safe, as realloc() just crops the trailing bytes again...
//   } // end IF
// //   for (int i = 0;
// //        i < RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE;
// //        i++)
// //     *(myCurrentBuffer->wr_ptr() + i) = YY_END_OF_BUFFER_CHAR;
//   *(myCurrentBuffer->wr_ptr()) = '\0';
//   *(myCurrentBuffer->wr_ptr() + 1) = '\0';
//
//   if (!scan_begin(myCurrentBuffer->rd_ptr(),
//                   myCurrentBuffer->length() + RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE))
  if (!scan_begin(myCurrentBuffer->rd_ptr(),
                  myCurrentBuffer->length()))
  {
    ACE_DEBUG((LM_ERROR,
               ACE_TEXT("failed to scan_begin(%@, %u), aborting\n"),
               myCurrentBuffer->rd_ptr(),
               myCurrentBuffer->length()));

//     // clean up
//     if (myCurrentBufferIsResized)
//     {
//       if (myCurrentBuffer->size(myCurrentBuffer->size() - RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE))
//         ACE_DEBUG((LM_ERROR,
//                    ACE_TEXT("failed to ACE_Message_Block::size(%u), continuing\n"),
//                    (myCurrentBuffer->size() - RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE)));
//       myCurrentBufferIsResized = false;
//     } // end IF

    // what else can we do ?
    return;
  } // end IF

//   // debug info
//   ACE_DEBUG((LM_DEBUG,
//              ACE_TEXT("[%u]: scanning %u byte(s)\n\"%s\"\n"),
//              myCurrentBuffer->getID(),
//              myCurrentBuffer->length(),
//              std::string(myCurrentBuffer->rd_ptr(), myCurrentBuffer->length()).c_str()));

  // scan it !
  myCurrentNumFrames = 0;
  bool finished_scanning = false;
  int scanned_bytes = 0;
  int scanned_chunk = 0;
//   while (myCurrentMessageLength = myScanner.yylex())
  do
  {
    scanned_chunk = RPG_Net_Protocol_IRCBisect_lex(myScannerContext);
//    scanned_chunk = IRCBisectlex(myScannerContext);
    switch (scanned_chunk)
    {
      case 0:
      {
        // --> finished scanning this buffer
        finished_scanning = true; // no (more) frame boundaries found

        // remember how much data was scanned so far...
        myCurrentMessageLength += scanned_bytes;

        break;
      }
      case -1:
      {
        // found a frame border scanned_bytes bytes into the buffer

        // *NOTE*: if scanned_bytes == 0, then it's the corner
        // case where the current buffer starts with either:
        // - a '\n'
        // - a "\r\n"
        // *NOTE*: in EITHER case, a new frame has been found...
        if ((scanned_bytes == 0) &&
            (*myCurrentBuffer->rd_ptr() == '\n'))
        {
          scanned_bytes = 1;
          myCurrentMessageLength += RPG_NET_PROTOCOL_IRC_FRAME_BOUNDARY_SIZE;
        } // end IF
        else
        {
          scanned_bytes += RPG_NET_PROTOCOL_IRC_FRAME_BOUNDARY_SIZE;
          myCurrentMessageLength += scanned_bytes;
        } // end IF

//         ACE_DEBUG((LM_DEBUG,
//                    ACE_TEXT("buffer (ID: %u, length: %u): frame boundary [#%u] @ offset %u\n\"%s\"\n"),
//                    myCurrentBuffer->getID(),
//                    myCurrentMessageLength,
//                    myCurrentNumFrames,
//                    (scanned_bytes + (myCurrentBuffer->rd_ptr() - myCurrentBuffer->base())),
//                    std::string(myCurrentBuffer->rd_ptr(), scanned_bytes).c_str()));

        RPG_Net_Protocol_Message* message = myCurrentMessage;
        if (myCurrentMessageLength < myCurrentMessage->total_length())
        {
          // more data to scan...

          // *NOTE*: copy ctor shallow-copies the current data block
          myCurrentMessage = dynamic_cast<RPG_Net_Protocol_Message*>(myCurrentBuffer->duplicate());
          ACE_ASSERT(myCurrentMessage);
          // adjust wr_ptr (point to one-past-the-end of the current message)
          myCurrentBuffer->wr_ptr(myCurrentBuffer->rd_ptr() + scanned_bytes);
          ACE_ASSERT(myCurrentMessageLength == message->total_length());
          // adjust rd_ptr (point to the beginning of the next message)
          myCurrentMessage->rd_ptr(scanned_bytes);
        } // end IF
        else
        {
          // NO more data to scan...
          ACE_ASSERT(myCurrentMessageLength == myCurrentMessage->total_length());

          // set new message head
          myCurrentMessage = NULL;
        } // end ELSE

        if (myCrunchMessages)
        {
          message->crunch();
        } // end IF

//         ACE_DEBUG((LM_DEBUG,
//                    ACE_TEXT("processing message (ID: %u - %u byte(s))...\n"),
//                    message->getID(),
//                    message->total_length()));

        // --> push it downstream...
        if (put_next(message, NULL) == -1)
        {
          ACE_DEBUG((LM_ERROR,
                     ACE_TEXT("failed to ACE_Task::put_next(): \"%m\", continuing\n")));

          // clean up
          message->release();
        } // end IF

        // set new current buffer
        myCurrentBuffer = myCurrentMessage;
        // reset state
        myCurrentMessageLength = 0;
        scanned_bytes = 0;

        // ...continue scanning !
        break;
      }
      default:
      {
        // scanned one/some character(s)...
        scanned_bytes += scanned_chunk;

        break;
      }
    } // end SWITCH
  } while (!finished_scanning);

  // clean up
  scan_end();
//   // *NOTE*: that even if we've sent some frames downstream in the meantime,
//   // we're still referencing the same buffer we resized earlier - it's always
//   // the new "head" message...
//   if (myCurrentBufferIsResized)
//   {
//     if (myCurrentBuffer->size(myCurrentBuffer->size() - RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE))
//       ACE_DEBUG((LM_ERROR,
//                  ACE_TEXT("failed to ACE_Message_Block::size(%u), continuing\n"),
//                  (myCurrentBuffer->size() - RPG_NET_PROTOCOL_FLEX_BUFFER_BOUNDARY_SIZE)));
//     myCurrentBufferIsResized = false;
//   } // end IF

//   ACE_DEBUG((LM_DEBUG,
//              ACE_TEXT("found %u frame bound(s)...\n"),
//              myCurrentNumFrames));
}
Exemplo n.º 6
0
  virtual int svc () {
    const size_t FileReadSize = 8 * 1024;
    ACE_Message_Block mblk (FileReadSize);

    for (;; mblk.crunch ()) {
      // Read as much as will fit in the message block.
      ssize_t bytes_read = logfile_.recv (mblk.wr_ptr (),
                                          mblk.space ());
      if (bytes_read <= 0)
        break;
      mblk.wr_ptr (static_cast<size_t> (bytes_read));

      // We have a bunch of data from the log file. The data is
      // arranged like so:
      //    hostname\0
      //    CDR-encoded log record
      // So, first we scan for the end of the host name, then
      // initialize another ACE_Message_Block aligned for CDR
      // demarshaling and copy the remainder of the block into it. We
      // can't use duplicate() because we need to be sure the data
      // pointer is aligned properly for CDR demarshaling.  If at any
      // point, there's not enough data left in the message block to
      // extract what's needed, crunch the block to move all remaining
      // data to the beginning and read more from the file.
      for (;;) {
        size_t name_len = ACE_OS::strnlen
                             (mblk.rd_ptr (), mblk.length ());
        if (name_len == mblk.length ()) break;

        char *name_p = mblk.rd_ptr ();
        ACE_Message_Block *rec, *head, *temp;
        ACE_NEW_RETURN
          (head, ACE_Message_Block (name_len, MB_CLIENT), 0);
        head->copy (name_p, name_len);
        mblk.rd_ptr (name_len + 1);   // Skip nul also

        size_t need = mblk.length () + ACE_CDR::MAX_ALIGNMENT;
        ACE_NEW_RETURN (rec, ACE_Message_Block (need), 0);
        ACE_CDR::mb_align (rec);
        rec->copy (mblk.rd_ptr (), mblk.length ());

        // Now rec contains the remaining data we've read so far from
        // the file. Create an ACE_InputCDR to start demarshaling the
        // log record, header first to find the length, then the data.
        // Since the ACE_InputCDR constructor increases the reference count
        // on rec, we release it upon return to prevent leaks.
        // The cdr 'read' methods return 0 on failure, 1 on success.
        ACE_InputCDR cdr (rec); rec->release ();
        ACE_CDR::Boolean byte_order;
        if (!cdr.read_boolean (byte_order)) {
          head->release (); rec->release (); break;
        }
        cdr.reset_byte_order (byte_order);

        // Now read the length of the record. From there, we'll know
        // if rec contains the complete record or not.
        ACE_CDR::ULong length;
        if (!cdr.read_ulong (length)) {
          head->release (); mblk.rd_ptr (name_p); break;
        }
        if (length > cdr.length ()) {
          head->release (); mblk.rd_ptr (name_p); break;
        }

        // The complete record is in rec... grab all the fields into
        // separate, chained message blocks.
        ACE_NEW_RETURN (temp,
                        ACE_Message_Block (length, MB_TEXT),
                        0);
        ACE_NEW_RETURN
          (temp,
           ACE_Message_Block (2 * sizeof (ACE_CDR::Long),
                              MB_TIME, temp),
           0);
        ACE_NEW_RETURN
          (temp,
           ACE_Message_Block (sizeof (ACE_CDR::Long),
                              MB_PID, temp),
           0);
        ACE_NEW_RETURN
          (temp,
           ACE_Message_Block (sizeof (ACE_CDR::Long),
                              MB_TYPE, temp),
           0);
        head->cont (temp);

        // Extract the type
        ACE_CDR::Long *lp;
        lp = reinterpret_cast<ACE_CDR::Long*> (temp->wr_ptr ());
        cdr >> *lp;
        temp->wr_ptr (sizeof (ACE_CDR::Long));
        temp = temp->cont ();

        // Extract the pid
        lp = reinterpret_cast<ACE_CDR::Long*> (temp->wr_ptr ());
        cdr >> *lp;
        temp->wr_ptr (sizeof (ACE_CDR::Long));
        temp = temp->cont ();

        // Extract the timestamp (2 Longs)
        lp = reinterpret_cast<ACE_CDR::Long*> (temp->wr_ptr ());
        cdr >> *lp; ++lp; cdr >> *lp;
        temp->wr_ptr (2 * sizeof (ACE_CDR::Long));
        temp = temp->cont ();

        // Demarshal the length of the message text, then demarshal
        // the text into the block.
        ACE_CDR::ULong text_len;
        cdr >> text_len;
        cdr.read_char_array (temp->wr_ptr (), text_len);
        temp->wr_ptr (text_len);

        // Forward the whole lot to the next module.
        if (put_next (head) == -1) break;

        // Move the file-content block's read pointer up past whatever
        // was just processed. Although the mblk's rd_ptr has not been
        // moved, cdr's has.  Therefore, use its length() to determine
        // how much is left.
        mblk.rd_ptr (mblk.length () - cdr.length ());
      }
    }

    // Now that the file is done, send a block down the stream to tell
    // the other modules to stop.
    ACE_Message_Block *stop;
    ACE_NEW_RETURN
      (stop, ACE_Message_Block (0, ACE_Message_Block::MB_STOP),
       0);
    put_next (stop);
    return 0;
  }
Exemplo n.º 7
0
int Task::svc (void)
{
    // This is the function that our service threads run once they are spawned.

    ACE_DEBUG ((LM_DEBUG, " (%P|%t) %s Task::svc () -- once per servicing thread\n", d_nameOfTask));

    // First, we wait until all of our peer service threads have arrived
    // at this point also.

    d_barrier.wait ();

    ACE_Message_Block *messageBlock;

    while (1) {
        // And now we loop almost infinitely.

        // getq () will block until a Message_Block is available to be read,
        // or an error occurs.

        if ( this->getq (messageBlock, 0) == -1) {
            ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "Task::svc () getq"), -1);
        }

        if (messageBlock->msg_type () == ACE_Message_Block::MB_HANGUP) {

            // If the Message_Block is of type MB_HANGUP, then we're being asked
            // to shut down nicely.

            ACE_DEBUG ((LM_DEBUG, " (%P|%t) %s Task::svc () -- HANGUP block received\n", d_nameOfTask));

            // So, we duplicate the Block, and put it back into the Message_Queue,
            // in case there are some more peer service threads still running.

            if (this->putq (messageBlock->duplicate ()) == -1) {
                ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "Task::svc () putq"), -1);
            }

            // We release our copy of the Block.
            messageBlock->release ();

            // And we break out of the nearly infinitely loop, and
            // head towards close () ourselves.
            break;
        }

        // If we're here, then we've received a Message_Block that was
        // not informing us to quit, so we're assuming it's a valid
        // meaningful Block.

        ACE_DEBUG ((LM_DEBUG, " (%P|%t) %s Task::svc () -- Normal block received\n", d_nameOfTask));

        // We grab the read-pointer from the Block, and display it through a DEBUG statement.

        ACE_DEBUG ((LM_DEBUG, " (%P|%t) %s Task::svc () -- %s\n", d_nameOfTask, messageBlock->rd_ptr () ));

        // We pretend that this takes to time to process the Block.
        // If you're on a fast machine, you might have to raise this
        // value to actually witness different threads handling
        // blocks for each Task.

        ACE_OS::sleep (ACE_Time_Value (0, 250));

        // Since we're part of a Stream, we duplicate the Block, and
        // send it on to the next Task.

        if (put_next (messageBlock->duplicate ()) == -1) {
            ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "Task::svc () put_next"), -1);
        }

        // And then we release our copy of it.

        messageBlock->release ();
    }
    return 0;
}