svn commit: r610469 - in /mina/sandbox/jvermillard/error-generator/src: ./ org/ org/apache/ org/apache/mina/ org/apache/mina/filter/ org/apache/mina/filter/errorgenerator/ org/apache/mina/filter/errorgenerator/ErrorGeneratorFilter.java

[jv...@apache.org]

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