Author: jvermillard
Date: Wed Jan 9 09:14:11 2008
New Revision: 610469
URL: http://svn.apache.org/viewvc?rev=610469&view=rev
Log:
filter for generate various communication corruption
Added:
mina/sandbox/jvermillard/error-generator/src/
mina/sandbox/jvermillard/error-generator/src/org/
mina/sandbox/jvermillard/error-generator/src/org/apache/
mina/sandbox/jvermillard/error-generator/src/org/apache/mina/
mina/sandbox/jvermillard/error-generator/src/org/apache/mina/filter/
mina/sandbox/jvermillard/error-generator/src/org/apache/mina/filter/errorgenerator/
mina/sandbox/jvermillard/error-generator/src/org/apache/mina/filter/errorgenerator/ErrorGeneratorFilter.java
Added:
mina/sandbox/jvermillard/error-generator/src/org/apache/mina/filter/errorgenerator/ErrorGeneratorFilter.java
URL:
http://svn.apache.org/viewvc/mina/sandbox/jvermillard/error-generator/src/org/apache/mina/filter/errorgenerator/ErrorGeneratorFilter.java?rev=610469&view=auto
==============================================================================
---
mina/sandbox/jvermillard/error-generator/src/org/apache/mina/filter/errorgenerator/ErrorGeneratorFilter.java
(added)
+++
mina/sandbox/jvermillard/error-generator/src/org/apache/mina/filter/errorgenerator/ErrorGeneratorFilter.java
Wed Jan 9 09:14:11 2008
@@ -0,0 +1,212 @@
+package org.apache.mina.filter.errorgenerator;
+
+import java.util.Random;
+
+import org.apache.mina.common.DefaultWriteRequest;
+import org.apache.mina.common.IoBuffer;
+import org.apache.mina.common.IoFilterAdapter;
+import org.apache.mina.common.IoSession;
+import org.apache.mina.common.IoSessionLogger;
+import org.apache.mina.common.WriteRequest;
+import org.slf4j.Logger;
+
+public class ErrorGeneratorFilter extends IoFilterAdapter {
+ private int removeByteProbability=0;
+ private int insertByteProbability=0;
+ private int changeByteProbability=0;
+ private int removePduProbability=0;
+ private int duplicatePduProbability=0;
+ private int resendPduLasterProbability=0;
+ private int maxInsertByte=10;
+ private boolean manipulateWrites=false;
+ private boolean manipulateReads=false;
+ private Random rng=new Random();
+
+ @Override
+ public void filterWrite(NextFilter nextFilter, IoSession session,
WriteRequest writeRequest) throws Exception {
+ if(manipulateWrites) {
+ // manipulate bytes
+ if(writeRequest.getMessage() instanceof IoBuffer) {
+
manipulateIoBuffer(session,(IoBuffer)writeRequest.getMessage());
+ IoBuffer
buffer=insertBytesToNewIoBuffer(session,(IoBuffer)writeRequest.getMessage());
+ if(buffer!=null) {
+ writeRequest=new
DefaultWriteRequest(buffer,writeRequest.getFuture(),writeRequest.getDestination());
+ }
+ // manipulate PDU
+ } else {
+ if(duplicatePduProbability > rng.nextInt()) {
+ nextFilter.filterWrite(session,
writeRequest);
+ }
+ if(resendPduLasterProbability > rng.nextInt()) {
+ // store it somewhere and trigger a
write execution for later
+ // TODO
+ }
+ if(removePduProbability > rng.nextInt()) {
+ return;
+ }
+ }
+ }
+ nextFilter.filterWrite(session, writeRequest);
+ }
+
+ @Override
+ public void messageReceived(NextFilter nextFilter, IoSession session,
Object message) throws Exception {
+ if(manipulateReads) {
+ if(message instanceof IoBuffer) {
+ // manipulate bytes
+ manipulateIoBuffer(session,(IoBuffer)message);
+ IoBuffer
buffer=insertBytesToNewIoBuffer(session,(IoBuffer)message);
+ if(buffer!=null) {
+ message=buffer;
+ }
+ } else {
+ // manipulate PDU
+ }
+ }
+ nextFilter.messageReceived(session, message);
+ }
+
+ private IoBuffer insertBytesToNewIoBuffer(IoSession session,IoBuffer
buffer) {
+ if(insertByteProbability > rng.nextInt(1000)) {
+ System.err.println(buffer.getHexDump());
+ // where to insert bytes ?
+ int pos=rng.nextInt(buffer.remaining())-1;
+
+ // how many byte to insert ?
+ int count=rng.nextInt(maxInsertByte);
+
+ IoBuffer
newBuff=IoBuffer.allocate(buffer.remaining()+count);
+ for(int i=0;i<pos;i++)
+ newBuff.put(buffer.get());
+ for(int i=0;i<count;i++) {
+ newBuff.put((byte) (rng.nextInt(256)));
+ }
+ while(buffer.remaining()>0) {
+ newBuff.put(buffer.get());
+ }
+ newBuff.flip();
+
+ System.err.println("Inserted "+count+" bytes.");
+ System.err.println(newBuff.getHexDump());
+ return newBuff;
+ }
+ return null;
+ }
+
+ private void manipulateIoBuffer(IoSession session,IoBuffer buffer) {
+ if(removeByteProbability > rng.nextInt(1000)) {
+ System.err.println(buffer.getHexDump());
+ // where to remove bytes ?
+ int pos=rng.nextInt(buffer.remaining());
+ // how many byte to remove ?
+ int count=rng.nextInt( buffer.remaining()-pos)+1;
+ if(count==buffer.remaining())
+ count=buffer.remaining()-1;
+
+ IoBuffer
newBuff=IoBuffer.allocate(buffer.remaining()-count);
+ for(int i=0;i<pos;i++)
+ newBuff.put(buffer.get());
+
+ buffer.skip(count); // hole
+ while(newBuff.remaining()>0)
+ newBuff.put(buffer.get());
+ newBuff.flip();
+ // copy the new buffer in the old one
+ buffer.rewind();
+ buffer.put(newBuff);
+ buffer.flip();
+ System.err.println("Removed "+count+" bytes at position
"+pos+".");
+ System.err.println(buffer.getHexDump());
+ }
+ if(changeByteProbability > rng.nextInt(1000)) {
+ System.err.println(buffer.getHexDump());
+ // how many byte to change ?
+ int count=rng.nextInt(buffer.remaining()-1)+1;
+
+ byte[] values=new byte[count];
+ rng.nextBytes(values);
+ for(int i=0;i<values.length;i++) {
+ int pos=rng.nextInt(buffer.remaining());
+ buffer.put(pos, values[i]);
+ }
+ System.err.println("Modified "+count+" bytes.");
+ System.err.println(buffer.getHexDump());
+ }
+ }
+
+ private Logger getLogger(IoSession session) {
+ return IoSessionLogger.getLogger(session);
+ }
+
+ public int getChangeByteProbability() {
+ return changeByteProbability;
+ }
+
+ public void setChangeByteProbability(int changeByteProbability) {
+ this.changeByteProbability = changeByteProbability;
+ }
+
+ public int getDuplicatePduProbability() {
+ return duplicatePduProbability;
+ }
+
+ public void setDuplicatePduProbability(int duplicatePduProbability) {
+ this.duplicatePduProbability = duplicatePduProbability;
+ }
+
+ public int getInsertByteProbability() {
+ return insertByteProbability;
+ }
+
+ public void setInsertByteProbability(int insertByteProbability) {
+ this.insertByteProbability = insertByteProbability;
+ }
+
+ public boolean isManipulateReads() {
+ return manipulateReads;
+ }
+
+ public void setManipulateReads(boolean manipulateReads) {
+ this.manipulateReads = manipulateReads;
+ }
+
+ public boolean isManipulateWrites() {
+ return manipulateWrites;
+ }
+
+ public void setManipulateWrites(boolean manipulateWrites) {
+ this.manipulateWrites = manipulateWrites;
+ }
+
+ public int getRemoveByteProbability() {
+ return removeByteProbability;
+ }
+
+ public void setRemoveByteProbability(int removeByteProbability) {
+ this.removeByteProbability = removeByteProbability;
+ }
+
+ public int getRemovePduProbability() {
+ return removePduProbability;
+ }
+
+ public void setRemovePduProbability(int removePduProbability) {
+ this.removePduProbability = removePduProbability;
+ }
+
+ public int getResendPduLasterProbability() {
+ return resendPduLasterProbability;
+ }
+
+ public void setResendPduLasterProbability(int
resendPduLasterProbability) {
+ this.resendPduLasterProbability = resendPduLasterProbability;
+ }
+
+ public int getMaxInsertByte() {
+ return maxInsertByte;
+ }
+
+ public void setMaxInsertByte(int maxInsertByte) {
+ this.maxInsertByte = maxInsertByte;
+ }
+}
\ No newline at end of file
