-fixes few bugs
-code style improvements -added PseudoTcpSocketFactory(usage changed, see test.IcePseudoTcp example for reference)
This commit is contained in:
parent
139ac8a12f
commit
0856c4dfdf
29
src/org/ice4j/pseudotcp/EnShutdown.java
Normal file
29
src/org/ice4j/pseudotcp/EnShutdown.java
Normal file
@ -0,0 +1,29 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
* Maintained by the Jitsi community (https://jitsi.org).
|
||||
*
|
||||
* Distributable under LGPL license.
|
||||
* See terms of license at gnu.org.
|
||||
*/
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
/**
|
||||
* <tt>EnShutdown</tt> enumeration used internally
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
enum EnShutdown
|
||||
{
|
||||
/**
|
||||
* There was no shutdown
|
||||
*/
|
||||
SD_NONE,
|
||||
/**
|
||||
* There was a graceful shutdown
|
||||
*/
|
||||
SD_GRACEFUL,
|
||||
/**
|
||||
* There was a forceful shutdown
|
||||
*/
|
||||
SD_FORCEFUL
|
||||
};
|
||||
33
src/org/ice4j/pseudotcp/Option.java
Normal file
33
src/org/ice4j/pseudotcp/Option.java
Normal file
@ -0,0 +1,33 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
* Maintained by the Jitsi community (https://jitsi.org).
|
||||
*
|
||||
* Distributable under LGPL license.
|
||||
* See terms of license at gnu.org.
|
||||
*/
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
/**
|
||||
* Options used in PseudoTCP
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
public enum Option
|
||||
{
|
||||
/**
|
||||
* Whether to enable Nagle's algorithm (0 == off)
|
||||
*/
|
||||
OPT_NODELAY,
|
||||
/**
|
||||
* The Delayed ACK timeout (0 == off).
|
||||
*/
|
||||
OPT_ACKDELAY,
|
||||
/**
|
||||
* Set the receive buffer size, in bytes.
|
||||
*/
|
||||
OPT_RCVBUF,
|
||||
/**
|
||||
* Set the send buffer size, in bytes.
|
||||
*/
|
||||
OPT_SNDBUF,
|
||||
};
|
||||
@ -13,10 +13,16 @@ import java.util.logging.*;
|
||||
import org.ice4j.pseudotcp.util.*;
|
||||
|
||||
/**
|
||||
* Main protocol logic class. To open connection use Connect() method. Then @link(Recv) and @link(Send) operations may be used for data transfer.
|
||||
* To operate this class requires implementation of @link(IPseudoTcpNotify)
|
||||
* Main protocol logic class. To open connection use <tt>connect</tt> method.
|
||||
* Then <tt>recv</tt> and <tt>send</tt> operations may be used for data transfer.
|
||||
* To operate this class requires implementation of <tt>PseudoTcpNotify</tt>.
|
||||
* Also it must be notified about the time progress.
|
||||
* Based on https://developers.google.com/talk/libjingle/
|
||||
*
|
||||
* @see PseudoTCPBase#connect
|
||||
* @see PseudoTCPBase#recv
|
||||
* @see PseudoTCPBase#send
|
||||
* @see PseudoTcpNotify
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
public class PseudoTCPBase
|
||||
@ -263,7 +269,7 @@ public class PseudoTCPBase
|
||||
*/
|
||||
long m_ack_delay;
|
||||
boolean m_support_wnd_scale;
|
||||
IPseudoTcpNotify m_notify;
|
||||
PseudoTcpNotify m_notify;
|
||||
EnShutdown m_shutdown;
|
||||
/**
|
||||
* Debug name used to identify peers in log messages
|
||||
@ -275,10 +281,10 @@ public class PseudoTCPBase
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
*
|
||||
* @param notify {@link IPseudoTcpNotify} implementation
|
||||
* @param notify {@link PseudoTcpNotify} implementation
|
||||
* @param conv the conversation number used by this instance
|
||||
*/
|
||||
public PseudoTCPBase(IPseudoTcpNotify notify, long conv)
|
||||
public PseudoTCPBase(PseudoTcpNotify notify, long conv)
|
||||
{
|
||||
m_notify = notify;
|
||||
m_shutdown = EnShutdown.SD_NONE;
|
||||
@ -288,7 +294,7 @@ public class PseudoTCPBase
|
||||
m_sbuf = new ByteFifoBuffer(m_sbuf_len);
|
||||
// Sanity check on buffer sizes (needed for OnTcpWriteable notification logic)
|
||||
assert m_rbuf_len + MIN_PACKET < m_sbuf_len;
|
||||
long now = Now();
|
||||
long now = now();
|
||||
|
||||
m_state = PseudoTcpState.TCP_LISTEN;
|
||||
m_conv = conv;
|
||||
@ -332,7 +338,7 @@ public class PseudoTCPBase
|
||||
*
|
||||
* @throws IOException if the protocol is not in initial state
|
||||
*/
|
||||
public void Connect() throws IOException
|
||||
public void connect() throws IOException
|
||||
{
|
||||
if (m_state != PseudoTcpState.TCP_LISTEN)
|
||||
{
|
||||
@ -352,7 +358,7 @@ public class PseudoTCPBase
|
||||
*
|
||||
* @param mtu
|
||||
*/
|
||||
public void NotifyMTU(int mtu)
|
||||
public void notifyMTU(int mtu)
|
||||
{
|
||||
m_mtu_advise = mtu;
|
||||
if (m_state == PseudoTcpState.TCP_ESTABLISHED)
|
||||
@ -360,34 +366,46 @@ public class PseudoTCPBase
|
||||
adjustMTU();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return MTU value
|
||||
*/
|
||||
public int getMTU()
|
||||
{
|
||||
return (int)m_mtu_advise;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return current timestamp limited to 32 bits
|
||||
*/
|
||||
public static long Now()
|
||||
public static long now()
|
||||
{
|
||||
return System.currentTimeMillis() & 0xFFFFFFFFL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Evaluate next interval between @link(GetNextClock) calls.
|
||||
* Evaluate next interval between <tt>getNextClock</tt> calls.
|
||||
* It is based on current protocol action timeout
|
||||
*
|
||||
* @param now current timestamp
|
||||
* @return next interval
|
||||
*
|
||||
*/
|
||||
public long GetNextClock(long now)
|
||||
public long getNextClock(long now)
|
||||
{
|
||||
return clock_check(now);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method should be called in time intervals retrieved from @link(GetNextClock)
|
||||
* This method should be called in time intervals retrieved
|
||||
* from <tt>getNextClock</tt>
|
||||
*
|
||||
* @param now current timestamp
|
||||
* @see PseudoTCPBase#getNextClock(long)
|
||||
*/
|
||||
public void NotifyClock(long now)
|
||||
public void notifyClock(long now)
|
||||
{
|
||||
if (logger.isLoggable(Level.FINEST))
|
||||
{
|
||||
@ -401,7 +419,7 @@ public class PseudoTCPBase
|
||||
now = now & 0xFFFFFFFFL;
|
||||
|
||||
// Check if it's time to retransmit a segment
|
||||
if (m_rto_base > 0 && (TimeDiff(m_rto_base + m_rx_rto, now) <= 0))
|
||||
if (m_rto_base > 0 && (timeDiff(m_rto_base + m_rx_rto, now) <= 0))
|
||||
{
|
||||
assert m_slist.isEmpty() == false;
|
||||
// retransmit segments
|
||||
@ -430,9 +448,9 @@ public class PseudoTCPBase
|
||||
}
|
||||
|
||||
// Check if it's time to probe closed windows
|
||||
if ((getM_snd_wnd() == 0) && (TimeDiff(m_lastsend + m_rx_rto, now) <= 0))
|
||||
if ((getM_snd_wnd() == 0) && (timeDiff(m_lastsend + m_rx_rto, now) <= 0))
|
||||
{
|
||||
if (TimeDiff(now, m_lastrecv) >= 15000)
|
||||
if (timeDiff(now, m_lastrecv) >= 15000)
|
||||
{
|
||||
closedown(new IOException("Connection aborted"));
|
||||
return;
|
||||
@ -446,7 +464,7 @@ public class PseudoTCPBase
|
||||
}
|
||||
|
||||
// Check if it's time to send delayed acks
|
||||
long timeDiff = TimeDiff(m_t_ack + m_ack_delay, now);
|
||||
long timeDiff = timeDiff(m_t_ack + m_ack_delay, now);
|
||||
if (m_t_ack > 0 && (timeDiff <= 0))
|
||||
{
|
||||
packet(m_snd_nxt, (short) 0, 0, 0);
|
||||
@ -455,7 +473,7 @@ public class PseudoTCPBase
|
||||
if (PSEUDO_KEEPALIVE) // Check for idle timeout
|
||||
{
|
||||
if ((m_state == PseudoTcpState.TCP_ESTABLISHED)
|
||||
&& (TimeDiff(m_lastrecv + IDLE_TIMEOUT, now) <= 0))
|
||||
&& (timeDiff(m_lastrecv + IDLE_TIMEOUT, now) <= 0))
|
||||
{
|
||||
closedown(new IOException("Connection aborted"));
|
||||
return;
|
||||
@ -463,7 +481,7 @@ public class PseudoTCPBase
|
||||
|
||||
// Check for ping timeout (to keep udp mapping open)
|
||||
if ((m_state == PseudoTcpState.TCP_ESTABLISHED)
|
||||
&& (TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2 : IDLE_PING), now) <= 0))
|
||||
&& (timeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2 : IDLE_PING), now) <= 0))
|
||||
{
|
||||
packet(m_snd_nxt, (short) 0, 0, 0);
|
||||
}
|
||||
@ -479,7 +497,7 @@ public class PseudoTCPBase
|
||||
* @param len data length
|
||||
* @return true if packet was successfully parsed
|
||||
*/
|
||||
synchronized public boolean NotifyPacket(byte[] buffer, int len)
|
||||
synchronized public boolean notifyPacket(byte[] buffer, int len)
|
||||
{
|
||||
if (len > MAX_PACKET)
|
||||
{
|
||||
@ -493,9 +511,9 @@ public class PseudoTCPBase
|
||||
* Retrieve option's value. See {@link Option} for available options
|
||||
*
|
||||
* @param opt option which value will be retrieved
|
||||
* @return
|
||||
* @return option's value
|
||||
*/
|
||||
long GetOption(Option opt)
|
||||
long getOption(Option opt)
|
||||
{
|
||||
if (opt == Option.OPT_NODELAY)
|
||||
{
|
||||
@ -528,7 +546,7 @@ public class PseudoTCPBase
|
||||
* @param opt option whose value will be set
|
||||
* @param value the value to be set
|
||||
*/
|
||||
void SetOption(Option opt, int value)
|
||||
void setOption(Option opt, long value)
|
||||
{
|
||||
if (opt == Option.OPT_NODELAY)
|
||||
{
|
||||
@ -545,13 +563,13 @@ public class PseudoTCPBase
|
||||
if (opt == Option.OPT_SNDBUF)
|
||||
{
|
||||
assert m_state == PseudoTcpState.TCP_LISTEN;
|
||||
resizeSendBuffer(value);
|
||||
resizeSendBuffer((int)value);
|
||||
}
|
||||
else
|
||||
{
|
||||
assert opt == Option.OPT_RCVBUF;
|
||||
assert m_state == PseudoTcpState.TCP_LISTEN;
|
||||
resizeReceiveBuffer(value);
|
||||
resizeReceiveBuffer((int)value);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -561,7 +579,7 @@ public class PseudoTCPBase
|
||||
*
|
||||
* @return congestion window size
|
||||
*/
|
||||
long GetCongestionWindow()
|
||||
long getCongestionWindow()
|
||||
{
|
||||
return m_cwnd;
|
||||
}
|
||||
@ -570,7 +588,7 @@ public class PseudoTCPBase
|
||||
*
|
||||
* @return bytes in flight
|
||||
*/
|
||||
long GetBytesInFlight()
|
||||
long getBytesInFlight()
|
||||
{
|
||||
return m_snd_nxt - m_snd_una;
|
||||
}
|
||||
@ -579,9 +597,9 @@ public class PseudoTCPBase
|
||||
*
|
||||
* @return bytes buffered, but not sent yet
|
||||
*/
|
||||
long GetBytesBufferedNotSent()
|
||||
long getBytesBufferedNotSent()
|
||||
{
|
||||
long buffered_bytes = m_sbuf.GetBuffered();
|
||||
long buffered_bytes = m_sbuf.getBuffered();
|
||||
return m_snd_una + buffered_bytes - m_snd_nxt;
|
||||
}
|
||||
|
||||
@ -589,25 +607,25 @@ public class PseudoTCPBase
|
||||
*
|
||||
* @return bytes available in receive buffer
|
||||
*/
|
||||
int GetAvailable()
|
||||
int getAvailable()
|
||||
{
|
||||
return m_rbuf.GetBuffered();
|
||||
return m_rbuf.getBuffered();
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return space available in the send buffer
|
||||
*/
|
||||
int GetAvailableSendBuffer()
|
||||
int getAvailableSendBuffer()
|
||||
{
|
||||
return m_sbuf.GetWriteRemaining();
|
||||
return m_sbuf.getWriteRemaining();
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return round trip time estimate in ms
|
||||
*/
|
||||
long GetRoundTripTimeEstimateMs()
|
||||
long getRoundTripTimeEstimateMs()
|
||||
{
|
||||
return m_rx_srtt;
|
||||
}
|
||||
@ -622,14 +640,14 @@ public class PseudoTCPBase
|
||||
* @return byte count actually read
|
||||
* @throws IOException if the protocol is not in the connected state
|
||||
*/
|
||||
public synchronized int Recv(byte[] buffer, int offset, int len) throws IOException
|
||||
public synchronized int recv(byte[] buffer, int offset, int len) throws IOException
|
||||
{
|
||||
if (m_state != PseudoTcpState.TCP_ESTABLISHED)
|
||||
{
|
||||
throw new IOException("Socket not connected");
|
||||
}
|
||||
|
||||
int read = m_rbuf.Read(buffer, offset, len);
|
||||
int read = m_rbuf.read(buffer, offset, len);
|
||||
|
||||
// If there's no data in |m_rbuf|.
|
||||
if (read == 0)
|
||||
@ -639,7 +657,7 @@ public class PseudoTCPBase
|
||||
}
|
||||
assert read != -1;
|
||||
|
||||
int available_space = m_rbuf.GetWriteRemaining();
|
||||
int available_space = m_rbuf.getWriteRemaining();
|
||||
if (available_space - m_rcv_wnd >= Math.min(m_rbuf_len / 8, m_mss))
|
||||
{
|
||||
boolean bWasClosed = (m_rcv_wnd == 0); // !?! Not sure about this was closed business
|
||||
@ -657,24 +675,24 @@ public class PseudoTCPBase
|
||||
*
|
||||
* @param buffer
|
||||
* @param len
|
||||
* @return
|
||||
* @return received byte count
|
||||
* @throws IOException
|
||||
*/
|
||||
public int Recv(byte[] buffer, int len) throws IOException
|
||||
public int recv(byte[] buffer, int len) throws IOException
|
||||
{
|
||||
return Recv(buffer, 0, len);
|
||||
return recv(buffer, 0, len);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param buffer
|
||||
* @param len
|
||||
* @return
|
||||
* @return sent byte count
|
||||
* @throws IOException
|
||||
*/
|
||||
public int Send(byte[] buffer, int len) throws IOException
|
||||
public int send(byte[] buffer, int len) throws IOException
|
||||
{
|
||||
return Send(buffer, 0, len);
|
||||
return send(buffer, 0, len);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -686,7 +704,7 @@ public class PseudoTCPBase
|
||||
* @return bytes count written to the send buffer
|
||||
* @throws IOException if the protocol is not in connected state
|
||||
*/
|
||||
public synchronized int Send(byte[] buffer, int offset, int len)
|
||||
public synchronized int send(byte[] buffer, int offset, int len)
|
||||
throws IOException
|
||||
{
|
||||
if (m_state != PseudoTcpState.TCP_ESTABLISHED)
|
||||
@ -695,7 +713,7 @@ public class PseudoTCPBase
|
||||
}
|
||||
|
||||
long available_space;
|
||||
available_space = m_sbuf.GetWriteRemaining();
|
||||
available_space = m_sbuf.getWriteRemaining();
|
||||
|
||||
if (available_space == 0)
|
||||
{
|
||||
@ -713,7 +731,7 @@ public class PseudoTCPBase
|
||||
*
|
||||
* @param force if true all data received from this moment will be discarded
|
||||
*/
|
||||
public void Close(boolean force)
|
||||
void close(boolean force)
|
||||
{
|
||||
logger.log(Level.FINE, debugName + " close (" + force + ")");
|
||||
m_shutdown = force ? EnShutdown.SD_FORCEFUL : EnShutdown.SD_GRACEFUL;
|
||||
@ -738,7 +756,7 @@ public class PseudoTCPBase
|
||||
int queue(byte[] buffer, int offset, int len, boolean bCtrl)
|
||||
{
|
||||
int available_space;
|
||||
available_space = m_sbuf.GetWriteRemaining();
|
||||
available_space = m_sbuf.getWriteRemaining();
|
||||
if (len > available_space)
|
||||
{
|
||||
assert !bCtrl;
|
||||
@ -759,7 +777,7 @@ public class PseudoTCPBase
|
||||
else
|
||||
{
|
||||
long snd_buffered;
|
||||
snd_buffered = m_sbuf.GetBuffered();
|
||||
snd_buffered = m_sbuf.getBuffered();
|
||||
SSegment sseg = new SSegment(
|
||||
m_snd_una + snd_buffered,
|
||||
len,
|
||||
@ -773,25 +791,28 @@ public class PseudoTCPBase
|
||||
m_slist.add(sseg);
|
||||
}
|
||||
|
||||
int written = m_sbuf.Write(buffer, offset, len);
|
||||
int written = m_sbuf.write(buffer, offset, len);
|
||||
return written;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a packet starting at <tt>offset</tt> in the send buffer of
|
||||
* specified length and sends it with help of @link(IPseudoTcpNotify).
|
||||
* specified length and sends it with help of <tt>PseudoTcpNotify</tt>.
|
||||
*
|
||||
* @param seq used sequence number
|
||||
* @param flags
|
||||
* @param offset in the send buffer
|
||||
* @param len length of data from
|
||||
* @return @link(WriteResult) returned by @link(IPseudoTcpNotify)
|
||||
* @return <tt>WriteResult</tt> returned by <tt>PseudoTcpNotify</tt>
|
||||
*
|
||||
* @see PseudoTcpNotify
|
||||
* @see WriteResult
|
||||
*/
|
||||
WriteResult packet(long seq, short flags, long offset, long len)
|
||||
{
|
||||
assert HEADER_SIZE + len <= MAX_PACKET;
|
||||
|
||||
long now = Now();
|
||||
long now = now();
|
||||
|
||||
byte[] buffer = new byte[HEADER_SIZE + (int)len];
|
||||
long_to_bytes(m_conv, buffer, 0);
|
||||
@ -808,7 +829,7 @@ public class PseudoTCPBase
|
||||
|
||||
if (len > 0)
|
||||
{
|
||||
int bytes_read = m_sbuf.ReadOffset(buffer, HEADER_SIZE,
|
||||
int bytes_read = m_sbuf.readOffset(buffer, HEADER_SIZE,
|
||||
(int) len,
|
||||
(int) offset);
|
||||
assert bytes_read == len;
|
||||
@ -820,7 +841,7 @@ public class PseudoTCPBase
|
||||
+ "<WND=" + m_rcv_wnd + "><SCALE=" + m_rwnd_scale + "><TS=" + now
|
||||
+ "><TSR=" + m_ts_recent + "><LEN=" + len + ">");
|
||||
}
|
||||
WriteResult wres = m_notify.TcpWritePacket(this,
|
||||
WriteResult wres = m_notify.tcpWritePacket(this,
|
||||
buffer,
|
||||
(int) len + HEADER_SIZE);
|
||||
/**
|
||||
@ -845,9 +866,9 @@ public class PseudoTCPBase
|
||||
}
|
||||
|
||||
/**
|
||||
* Method can be used in some debugging utilities
|
||||
* Method can be used in debugging utilities to parse PTCP segment
|
||||
*/
|
||||
public static String parseSeg(byte[] buffer, int size)
|
||||
public static Segment parseSeg(byte[] buffer, int size)
|
||||
{
|
||||
if (size < 12)
|
||||
{
|
||||
@ -866,15 +887,27 @@ public class PseudoTCPBase
|
||||
|
||||
seg.data = copy_buffer(buffer, HEADER_SIZE, size - HEADER_SIZE);
|
||||
seg.len = size - HEADER_SIZE;
|
||||
|
||||
return seg;
|
||||
}
|
||||
|
||||
/**
|
||||
* Can be used to convert segments to text
|
||||
*
|
||||
* @param seg
|
||||
* @return segment in readable text form
|
||||
*/
|
||||
public static String segToStr(Segment seg)
|
||||
{
|
||||
String data="data: ";
|
||||
for(byte b : seg.data)
|
||||
{
|
||||
data += b;
|
||||
}
|
||||
return "segment " + "<CONV=" + seg.conv + "><FLG=" + seg.flags
|
||||
+ "><SEQ=" + seg.seq + ":" + (seg.seq + seg.len) + "><ACK=" + seg.ack
|
||||
+ "><WND=" + seg.wnd + "><TS=" + seg.tsval
|
||||
+ "><TSR=" + seg.tsecr + "><LEN=" + seg.len + "> "+data;
|
||||
return "<CONV=" + seg.conv + "><FLG=" + seg.flags + "><SEQ="
|
||||
+ seg.seq + ":" + (seg.seq + seg.len) + "><ACK=" + seg.ack
|
||||
+ "><WND=" + seg.wnd + "><TS=" + seg.tsval
|
||||
+ "><TSR=" + seg.tsecr + "><LEN=" + seg.len + "> "+data;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -892,18 +925,7 @@ public class PseudoTCPBase
|
||||
return false;
|
||||
}
|
||||
|
||||
Segment seg = new Segment();
|
||||
seg.conv = bytes_to_long(buffer, 0);
|
||||
seg.seq = bytes_to_long(buffer, 4);
|
||||
seg.ack = bytes_to_long(buffer, 8);
|
||||
seg.flags = buffer[13];
|
||||
seg.wnd = bytes_to_short(buffer, 14);
|
||||
|
||||
seg.tsval = bytes_to_long(buffer, 16);
|
||||
seg.tsecr = bytes_to_long(buffer, 20);
|
||||
|
||||
seg.data = copy_buffer(buffer, HEADER_SIZE, size - HEADER_SIZE);
|
||||
seg.len = size - HEADER_SIZE;
|
||||
Segment seg = parseSeg(buffer, size);
|
||||
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
{
|
||||
@ -931,7 +953,7 @@ public class PseudoTCPBase
|
||||
|
||||
long nTimeout;
|
||||
long snd_buffered;
|
||||
snd_buffered = m_sbuf.GetBuffered();
|
||||
snd_buffered = m_sbuf.getBuffered();
|
||||
if ((m_shutdown == EnShutdown.SD_GRACEFUL)
|
||||
&& ((m_state != PseudoTcpState.TCP_ESTABLISHED)
|
||||
|| ((snd_buffered == 0) && (m_t_ack == 0))))
|
||||
@ -948,15 +970,15 @@ public class PseudoTCPBase
|
||||
|
||||
if (m_t_ack > 0)
|
||||
{
|
||||
nTimeout = Math.min(nTimeout, TimeDiff(m_t_ack + m_ack_delay, now));
|
||||
nTimeout = Math.min(nTimeout, timeDiff(m_t_ack + m_ack_delay, now));
|
||||
}
|
||||
if (m_rto_base > 0)
|
||||
{
|
||||
nTimeout = Math.min(nTimeout, TimeDiff(m_rto_base + m_rx_rto, now));
|
||||
nTimeout = Math.min(nTimeout, timeDiff(m_rto_base + m_rx_rto, now));
|
||||
}
|
||||
if (getM_snd_wnd() == 0)
|
||||
{
|
||||
nTimeout = Math.min(nTimeout, TimeDiff(m_lastsend + m_rx_rto, now));
|
||||
nTimeout = Math.min(nTimeout, timeDiff(m_lastsend + m_rx_rto, now));
|
||||
}
|
||||
if (PSEUDO_KEEPALIVE)
|
||||
{
|
||||
@ -964,7 +986,7 @@ public class PseudoTCPBase
|
||||
{
|
||||
nTimeout = Math.min(
|
||||
nTimeout,
|
||||
TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2 : IDLE_PING), now));
|
||||
timeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2 : IDLE_PING), now));
|
||||
}
|
||||
}
|
||||
//nTimeout is used on wait methods, so cannot be equal to 0
|
||||
@ -993,7 +1015,7 @@ public class PseudoTCPBase
|
||||
return false;
|
||||
}
|
||||
|
||||
long now = Now();
|
||||
long now = now();
|
||||
m_lasttraffic = m_lastrecv = now;
|
||||
m_bOutgoing = false;
|
||||
|
||||
@ -1048,7 +1070,7 @@ public class PseudoTCPBase
|
||||
adjustMTU();
|
||||
if (m_notify != null)
|
||||
{
|
||||
m_notify.OnTcpOpen(this);
|
||||
m_notify.onTcpOpen(this);
|
||||
}
|
||||
//notify(evOpen);
|
||||
}
|
||||
@ -1075,7 +1097,7 @@ public class PseudoTCPBase
|
||||
// Calculate round-trip time
|
||||
if (seg.tsecr > 0)
|
||||
{
|
||||
long rtt = TimeDiff(now, seg.tsecr);
|
||||
long rtt = timeDiff(now, seg.tsecr);
|
||||
assert rtt >= 0;
|
||||
if (m_rx_srtt == 0)
|
||||
{
|
||||
@ -1106,7 +1128,7 @@ public class PseudoTCPBase
|
||||
|
||||
m_rto_base = (m_snd_una == m_snd_nxt) ? 0 : now;
|
||||
|
||||
m_sbuf.ConsumeReadData((int) nAcked);
|
||||
m_sbuf.consumeReadData((int) nAcked);
|
||||
synchronized (ack_notify)
|
||||
{
|
||||
if (logger.isLoggable(Level.FINER))
|
||||
@ -1237,7 +1259,7 @@ public class PseudoTCPBase
|
||||
adjustMTU();
|
||||
if (m_notify != null)
|
||||
{
|
||||
m_notify.OnTcpOpen(this);
|
||||
m_notify.onTcpOpen(this);
|
||||
}
|
||||
//notify(evOpen);
|
||||
}
|
||||
@ -1245,13 +1267,13 @@ public class PseudoTCPBase
|
||||
// The goal it to make sure we always have at least enough data to fill the
|
||||
// window. We'd like to notify the app when we are halfway to that point.
|
||||
long kIdealRefillSize = (m_sbuf_len + m_rbuf_len) / 2;
|
||||
long snd_buffered = m_sbuf.GetBuffered();
|
||||
long snd_buffered = m_sbuf.getBuffered();
|
||||
if (m_bWriteEnable && snd_buffered < kIdealRefillSize)
|
||||
{
|
||||
m_bWriteEnable = false;
|
||||
if (m_notify != null)
|
||||
{
|
||||
m_notify.OnTcpWriteable(this);
|
||||
m_notify.onTcpWriteable(this);
|
||||
}
|
||||
//notify(evWrite);
|
||||
}
|
||||
@ -1303,7 +1325,7 @@ public class PseudoTCPBase
|
||||
if (nAdjust < seg.len)
|
||||
{
|
||||
seg.seq += nAdjust;
|
||||
seg.data = ScrollBuffer(seg.data, nAdjust);
|
||||
seg.data = scrollBuffer(seg.data, (int)nAdjust);
|
||||
seg.len -= nAdjust;
|
||||
}
|
||||
else
|
||||
@ -1311,7 +1333,7 @@ public class PseudoTCPBase
|
||||
seg.len = 0;
|
||||
}
|
||||
}
|
||||
long available_space = m_rbuf.GetWriteRemaining();
|
||||
long available_space = m_rbuf.getWriteRemaining();
|
||||
if ((seg.seq + seg.len - m_rcv_nxt) > available_space)
|
||||
{
|
||||
long nAdjust = seg.seq + seg.len - m_rcv_nxt - available_space;
|
||||
@ -1339,7 +1361,7 @@ public class PseudoTCPBase
|
||||
{
|
||||
long nOffset = seg.seq - m_rcv_nxt;
|
||||
|
||||
int result = m_rbuf.WriteOffset(seg.data, seg.len,
|
||||
int result = m_rbuf.writeOffset(seg.data, seg.len,
|
||||
(int) nOffset);
|
||||
assert result == seg.len;
|
||||
|
||||
@ -1351,7 +1373,7 @@ public class PseudoTCPBase
|
||||
"Avail space: " + available_space
|
||||
+ " seg.len: " + seg.len);
|
||||
}
|
||||
m_rbuf.ConsumeWriteBuffer(seg.len);
|
||||
m_rbuf.consumeWriteBuffer(seg.len);
|
||||
m_rcv_nxt += seg.len;
|
||||
m_rcv_wnd -= seg.len;
|
||||
bNewData = true;
|
||||
@ -1377,7 +1399,7 @@ public class PseudoTCPBase
|
||||
+ m_rcv_nxt + " -> " + (m_rcv_nxt + nAdjust)
|
||||
+ ")");
|
||||
}
|
||||
m_rbuf.ConsumeWriteBuffer((int) nAdjust);
|
||||
m_rbuf.consumeWriteBuffer((int) nAdjust);
|
||||
m_rcv_nxt += nAdjust;
|
||||
m_rcv_wnd -= nAdjust;
|
||||
}
|
||||
@ -1415,7 +1437,7 @@ public class PseudoTCPBase
|
||||
m_bReadEnable = false;
|
||||
if (m_notify != null)
|
||||
{
|
||||
m_notify.OnTcpReadable(this);
|
||||
m_notify.onTcpReadable(this);
|
||||
}
|
||||
//notify(evRead);
|
||||
}
|
||||
@ -1429,7 +1451,7 @@ public class PseudoTCPBase
|
||||
* @param earlier timestamp in ms
|
||||
* @return difference between <tt>later</tt> and <tt>earlier</tt>
|
||||
*/
|
||||
private static long TimeDiff(long later, long earlier)
|
||||
private static long timeDiff(long later, long earlier)
|
||||
{
|
||||
return later - earlier;
|
||||
}
|
||||
@ -1527,10 +1549,11 @@ public class PseudoTCPBase
|
||||
return Math.min(Math.max(lower, middle), upper);
|
||||
}
|
||||
|
||||
private byte[] ScrollBuffer(byte[] data, long nAdjust)
|
||||
private byte[] scrollBuffer(byte[] data, int nAdjust)
|
||||
{
|
||||
//TODO: never been hit so far, to be implemented
|
||||
throw new UnsupportedOperationException("Not yet implemented");
|
||||
byte[] newBuffer = new byte[data.length - nAdjust];
|
||||
System.arraycopy(data, nAdjust, newBuffer, 0, newBuffer.length);
|
||||
return newBuffer;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1634,9 +1657,9 @@ public class PseudoTCPBase
|
||||
*/
|
||||
void attemptSend(SendFlags sflags)
|
||||
{
|
||||
long now = Now();
|
||||
long now = now();
|
||||
|
||||
if (TimeDiff(now, m_lastsend) > m_rx_rto)
|
||||
if (timeDiff(now, m_lastsend) > m_rx_rto)
|
||||
{
|
||||
m_cwnd = m_mss;
|
||||
}
|
||||
@ -1653,7 +1676,7 @@ public class PseudoTCPBase
|
||||
long nInFlight = m_snd_nxt - m_snd_una;
|
||||
long nUseable = (nInFlight < nWindow) ? (nWindow - nInFlight) : 0;
|
||||
|
||||
long snd_buffered = m_sbuf.GetBuffered();
|
||||
long snd_buffered = m_sbuf.getBuffered();
|
||||
/*
|
||||
* System.out.println("is available? buffered: " + snd_buffered + "
|
||||
* inFlight: " + nInFlight + " m_mss: " + m_mss + " m_snd_wnd: " +
|
||||
@ -1679,7 +1702,7 @@ public class PseudoTCPBase
|
||||
|
||||
if (bFirst)
|
||||
{
|
||||
long available_space = m_sbuf.GetWriteRemaining();
|
||||
long available_space = m_sbuf.getWriteRemaining();
|
||||
|
||||
bFirst = false;
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
@ -1708,7 +1731,7 @@ public class PseudoTCPBase
|
||||
}
|
||||
else
|
||||
{
|
||||
m_t_ack = Now();
|
||||
m_t_ack = now();
|
||||
logger.log(Level.FINER, "Delayed ack, m_t_ack: " + m_t_ack);
|
||||
}
|
||||
return;
|
||||
@ -1781,7 +1804,7 @@ public class PseudoTCPBase
|
||||
m_state = PseudoTcpState.TCP_CLOSED;
|
||||
if (m_notify != null)
|
||||
{
|
||||
m_notify.OnTcpClosed(this, e);
|
||||
m_notify.onTcpClosed(this, e);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1813,7 +1836,7 @@ public class PseudoTCPBase
|
||||
*/
|
||||
boolean isReceiveBufferFull()
|
||||
{
|
||||
return m_rbuf.GetWriteRemaining() == 0;
|
||||
return m_rbuf.getWriteRemaining() == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1961,7 +1984,7 @@ public class PseudoTCPBase
|
||||
void resizeSendBuffer(int new_size)
|
||||
{
|
||||
m_sbuf_len = new_size;
|
||||
m_sbuf.SetCapacity(new_size);
|
||||
m_sbuf.setCapacity(new_size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1983,7 +2006,7 @@ public class PseudoTCPBase
|
||||
|
||||
// Determine the proper size of the buffer.
|
||||
new_size <<= scale_factor;
|
||||
boolean result = m_rbuf.SetCapacity(new_size);
|
||||
boolean result = m_rbuf.setCapacity(new_size);
|
||||
|
||||
// Make sure the new buffer is large enough to contain data in the old
|
||||
// buffer. This should always be true because this method is called either
|
||||
@ -1994,7 +2017,7 @@ public class PseudoTCPBase
|
||||
m_rwnd_scale = scale_factor;
|
||||
m_ssthresh = new_size;
|
||||
|
||||
int available_space = m_rbuf.GetWriteRemaining();
|
||||
int available_space = m_rbuf.getWriteRemaining();
|
||||
m_rcv_wnd = available_space;
|
||||
}
|
||||
|
||||
@ -2050,119 +2073,22 @@ public class PseudoTCPBase
|
||||
}
|
||||
private final Object ack_notify = new Object();
|
||||
|
||||
public Object GetAckNotify()
|
||||
public Object getAckNotify()
|
||||
{
|
||||
return ack_notify;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Class used internally as a structure for receive segments
|
||||
*
|
||||
* @author Pawel
|
||||
*/
|
||||
class RSegment
|
||||
{
|
||||
public long seq, len;
|
||||
|
||||
public RSegment(long seq, long len)
|
||||
long getConversationID()
|
||||
{
|
||||
this.seq = seq;
|
||||
this.len = len;
|
||||
return m_conv;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Class used internally as a structure for send segments
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
class SSegment
|
||||
{
|
||||
long seq, len;
|
||||
//uint32 tstamp;
|
||||
short xmit;
|
||||
boolean bCtrl;
|
||||
|
||||
SSegment(long s, long l, boolean c)
|
||||
void setConversationID(long convID)
|
||||
{
|
||||
seq = s;
|
||||
len = l;
|
||||
xmit = 0;
|
||||
bCtrl = c;
|
||||
if(m_state != PseudoTcpState.TCP_LISTEN)
|
||||
throw new IllegalStateException();
|
||||
this.m_conv = convID;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Shutdown enum used internally
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
enum EnShutdown
|
||||
{
|
||||
/**
|
||||
* There was no shutdown
|
||||
*/
|
||||
SD_NONE,
|
||||
/**
|
||||
* There was a graceful shutdown
|
||||
*/
|
||||
SD_GRACEFUL,
|
||||
/**
|
||||
* There was a forceful shutdown
|
||||
*/
|
||||
SD_FORCEFUL
|
||||
};
|
||||
|
||||
/**
|
||||
* Options used in pseudotcp
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
enum Option
|
||||
{
|
||||
/**
|
||||
* Whether to enable Nagle's algorithm (0 == off)
|
||||
*/
|
||||
OPT_NODELAY,
|
||||
/**
|
||||
* The Delayed ACK timeout (0 == off).
|
||||
*/
|
||||
OPT_ACKDELAY,
|
||||
/**
|
||||
* Set the receive buffer size, in bytes.
|
||||
*/
|
||||
OPT_RCVBUF,
|
||||
/**
|
||||
* Set the send buffer size, in bytes.
|
||||
*/
|
||||
OPT_SNDBUF,
|
||||
};
|
||||
|
||||
/**
|
||||
* Send flags used internally
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
enum SendFlags
|
||||
{
|
||||
sfNone, sfImmediateAck, sfDelayedAck;
|
||||
}
|
||||
|
||||
/**
|
||||
* Class used internally as a segment structure
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
class Segment
|
||||
{
|
||||
long conv;
|
||||
long seq;
|
||||
long ack;
|
||||
byte flags;
|
||||
int wnd;
|
||||
long tsval;
|
||||
long tsecr;
|
||||
byte[] data;
|
||||
int len;
|
||||
}
|
||||
53
src/org/ice4j/pseudotcp/PseudoTcpNotify.java
Executable file
53
src/org/ice4j/pseudotcp/PseudoTcpNotify.java
Executable file
@ -0,0 +1,53 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
* Maintained by the Jitsi community (https://jitsi.org).
|
||||
*
|
||||
* Distributable under LGPL license.
|
||||
* See terms of license at gnu.org.
|
||||
*/
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
import java.io.*;
|
||||
|
||||
/**
|
||||
* Notification of tcp events.
|
||||
* Is implemented by <tt>PseudoTcpSocketImpl</tt> to expose stream functionality.
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
public interface PseudoTcpNotify
|
||||
{
|
||||
/**
|
||||
* Called when TCP enters opened state
|
||||
* @param tcp
|
||||
*/
|
||||
void onTcpOpen(PseudoTCPBase tcp);
|
||||
|
||||
/**
|
||||
* Called when any data is available in read buffer
|
||||
* @param tcp
|
||||
*/
|
||||
void onTcpReadable(PseudoTCPBase tcp);
|
||||
|
||||
/**
|
||||
* Called when there is free space available in the send buffer
|
||||
* @param tcp
|
||||
*/
|
||||
void onTcpWriteable(PseudoTCPBase tcp);
|
||||
|
||||
/**
|
||||
* Called when tcp enters closed state
|
||||
* @param tcp
|
||||
* @param e null means no error
|
||||
*/
|
||||
void onTcpClosed(PseudoTCPBase tcp, IOException e);
|
||||
|
||||
/**
|
||||
* Called when protocol requests packet transfer through the network.
|
||||
* @param tcp
|
||||
* @param buffer data
|
||||
* @param len data length
|
||||
* @return the result, see {@link WriteResult} description for more info
|
||||
*/
|
||||
WriteResult tcpWritePacket(PseudoTCPBase tcp, byte[] buffer, int len);
|
||||
}
|
||||
135
src/org/ice4j/pseudotcp/PseudoTcpSocket.java
Normal file
135
src/org/ice4j/pseudotcp/PseudoTcpSocket.java
Normal file
@ -0,0 +1,135 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
* Maintained by the Jitsi community (https://jitsi.org).
|
||||
*
|
||||
* Distributable under LGPL license.
|
||||
* See terms of license at gnu.org.
|
||||
*/
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
public class PseudoTcpSocket extends Socket
|
||||
{
|
||||
private final PseudoTcpSocketImpl socketImpl;
|
||||
|
||||
PseudoTcpSocket(PseudoTcpSocketImpl socketImpl)
|
||||
throws SocketException
|
||||
{
|
||||
super(socketImpl);
|
||||
this.socketImpl = socketImpl;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return PseudoTCP conversation ID
|
||||
*/
|
||||
public long getConversationID()
|
||||
{
|
||||
return socketImpl.getConversationID();
|
||||
}
|
||||
|
||||
/**
|
||||
* Set conversation ID for the socket
|
||||
* Must be called on unconnected socket
|
||||
*
|
||||
* @param convID
|
||||
* @throws IllegalStateException when called on connected or closed socket
|
||||
*/
|
||||
public void setConversationID(long convID)
|
||||
throws IllegalStateException
|
||||
{
|
||||
socketImpl.setConversationID(convID);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets MTU value
|
||||
* @param mtu
|
||||
*/
|
||||
public void setMTU(int mtu)
|
||||
{
|
||||
socketImpl.setMTU(mtu);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return MTU value
|
||||
*/
|
||||
public int getMTU()
|
||||
{
|
||||
return socketImpl.getMTU();
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return PseudoTCP option value
|
||||
*
|
||||
* @see Option
|
||||
*/
|
||||
public long getOption(Option option)
|
||||
{
|
||||
return socketImpl.getPTCPOption(option);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param option PseudoTCP option to set
|
||||
* @param optValue option's value
|
||||
*
|
||||
* @see Option
|
||||
*/
|
||||
public void setOption(Option option, long optValue)
|
||||
{
|
||||
socketImpl.setPTCPOption(option, optValue);
|
||||
}
|
||||
|
||||
/**
|
||||
* Blocking method waits for connection.
|
||||
*
|
||||
* @param timeout for this operation in ms
|
||||
* @throws IOException If socket gets closed or timeout expires
|
||||
*/
|
||||
public void accept(int timeout)
|
||||
throws IOException
|
||||
{
|
||||
socketImpl.accept(timeout);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets debug name that will be displayed in log messages for this socket
|
||||
* @param debugName
|
||||
*/
|
||||
public void setDebugName(String debugName)
|
||||
{
|
||||
socketImpl.setDebugName(debugName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns current <tt>PseudoTcpState</tt> of this socket
|
||||
* @return current <tt>PseudoTcpState</tt>
|
||||
*
|
||||
* @see PseudoTcpState
|
||||
*/
|
||||
public PseudoTcpState getState()
|
||||
{
|
||||
return socketImpl.getState();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isConnected()
|
||||
{
|
||||
return getState() == PseudoTcpState.TCP_ESTABLISHED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isClosed()
|
||||
{
|
||||
return getState() == PseudoTcpState.TCP_CLOSED;
|
||||
}
|
||||
|
||||
}
|
||||
138
src/org/ice4j/pseudotcp/PseudoTcpSocketFactory.java
Normal file
138
src/org/ice4j/pseudotcp/PseudoTcpSocketFactory.java
Normal file
@ -0,0 +1,138 @@
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import javax.net.*;
|
||||
|
||||
public class PseudoTcpSocketFactory
|
||||
extends SocketFactory
|
||||
implements SocketImplFactory
|
||||
{
|
||||
/**
|
||||
* Default conversation ID
|
||||
*/
|
||||
public static final long DEFAULT_CONVERSATION_ID=0;
|
||||
|
||||
/**
|
||||
* Default timeout for connect operation
|
||||
*/
|
||||
public static final int DEFAULT_CONNECT_TIMEOUT=5000;
|
||||
|
||||
/**
|
||||
* Creates a socket and connects it to the specified
|
||||
* port number at the specified address.
|
||||
*/
|
||||
@Override
|
||||
public Socket createSocket(String host, int port)
|
||||
throws IOException,
|
||||
UnknownHostException
|
||||
{
|
||||
Socket socket = createSocket();
|
||||
connectSocket(socket, new InetSocketAddress(host, port));
|
||||
return socket;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a socket and connect it to the specified remote address
|
||||
* on the specified remote port.
|
||||
*/
|
||||
@Override
|
||||
public Socket createSocket(InetAddress host, int port) throws IOException
|
||||
{
|
||||
Socket socket = createSocket();
|
||||
connectSocket(socket, new InetSocketAddress(host, port));
|
||||
return socket;
|
||||
}
|
||||
|
||||
private void connectSocket(Socket socket, InetSocketAddress remoteSockAddr)
|
||||
throws IOException
|
||||
{
|
||||
socket.connect(remoteSockAddr, DEFAULT_CONNECT_TIMEOUT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates socket bound to local <tt>sockAddr</tt>
|
||||
* @param sockAddr
|
||||
* @return socket bound to local address
|
||||
* @throws IOException
|
||||
*/
|
||||
public Socket createBoundSocket(InetSocketAddress sockAddr)
|
||||
throws IOException
|
||||
{
|
||||
return new PseudoTcpSocket(
|
||||
new PseudoTcpSocketImpl(DEFAULT_CONVERSATION_ID,
|
||||
new DatagramSocket(sockAddr)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a socket and connects it to the specified remote host at the specified remote port.
|
||||
*/
|
||||
@Override
|
||||
public Socket createSocket(String host,
|
||||
int port,
|
||||
InetAddress localHost,
|
||||
int localPort)
|
||||
throws IOException,
|
||||
UnknownHostException
|
||||
{
|
||||
Socket socket = createBoundSocket(
|
||||
new InetSocketAddress(localHost, localPort));
|
||||
connectSocket(socket, new InetSocketAddress(host, port));
|
||||
return socket;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a socket and connects it to the specified remote host on the specified remote port.
|
||||
*/
|
||||
@Override
|
||||
public Socket createSocket(InetAddress address, int port,
|
||||
InetAddress localAddress, int localPort) throws IOException
|
||||
{
|
||||
Socket socket = createBoundSocket(
|
||||
new InetSocketAddress(localAddress, localPort));
|
||||
connectSocket(socket, new InetSocketAddress(address, port));
|
||||
return socket;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a socket that will run on given <tt>datagramSocket</tt>
|
||||
*
|
||||
* @param datagramSocket
|
||||
* @return new socket running on given <tt>datagramSocket</tt>
|
||||
* @throws SocketException
|
||||
*/
|
||||
public PseudoTcpSocket createSocket(DatagramSocket datagramSocket)
|
||||
throws SocketException
|
||||
{
|
||||
return new PseudoTcpSocket(
|
||||
new PseudoTcpSocketImpl(DEFAULT_CONVERSATION_ID, datagramSocket));
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the PseudoTcp socket and binds it to any available port
|
||||
* on the local host machine. The socket will be bound to the
|
||||
* {@link InetAddress#isAnyLocalAddress wildcard} address,
|
||||
* an IP address chosen by the kernel.
|
||||
*
|
||||
*/
|
||||
public PseudoTcpSocket createSocket()
|
||||
throws SocketException
|
||||
{
|
||||
return new PseudoTcpSocket(
|
||||
new PseudoTcpSocketImpl(DEFAULT_CONVERSATION_ID));
|
||||
}
|
||||
|
||||
@Override
|
||||
public SocketImpl createSocketImpl()
|
||||
{
|
||||
try
|
||||
{
|
||||
return new PseudoTcpSocketImpl(DEFAULT_CONVERSATION_ID);
|
||||
}
|
||||
catch (SocketException e)
|
||||
{
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@ -12,9 +12,9 @@ import java.net.*;
|
||||
import java.util.*;
|
||||
import java.util.logging.*;
|
||||
|
||||
public class PseudoTcpSocketImpl
|
||||
class PseudoTcpSocketImpl
|
||||
extends SocketImpl
|
||||
implements IPseudoTcpNotify
|
||||
implements PseudoTcpNotify
|
||||
{
|
||||
/**
|
||||
* The logger.
|
||||
@ -138,7 +138,26 @@ public class PseudoTcpSocketImpl
|
||||
*/
|
||||
public void setMTU(int mtu)
|
||||
{
|
||||
this.pseudoTcp.NotifyMTU(mtu);
|
||||
this.pseudoTcp.notifyMTU(mtu);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return current MTU set
|
||||
*/
|
||||
public int getMTU()
|
||||
{
|
||||
return pseudoTcp.getMTU();
|
||||
}
|
||||
|
||||
long getConversationID()
|
||||
{
|
||||
return pseudoTcp.getConversationID();
|
||||
}
|
||||
|
||||
void setConversationID(long convID)
|
||||
{
|
||||
pseudoTcp.setConversationID(convID);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -170,7 +189,7 @@ public class PseudoTcpSocketImpl
|
||||
protected void connect(String host, int port)
|
||||
throws IOException
|
||||
{
|
||||
Connect(new InetSocketAddress(InetAddress.getByName(host), port), 0);
|
||||
doConnect(new InetSocketAddress(InetAddress.getByName(host), port), 0);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -197,7 +216,7 @@ public class PseudoTcpSocketImpl
|
||||
throws IOException
|
||||
{
|
||||
InetSocketAddress inetAddr = (InetSocketAddress) address;
|
||||
Connect(inetAddr, timeout);
|
||||
doConnect(inetAddr, timeout);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -233,15 +252,27 @@ public class PseudoTcpSocketImpl
|
||||
public void setOption(int optID, Object value)
|
||||
throws SocketException
|
||||
{
|
||||
//TODO: map options to PTCP options/method calls
|
||||
options.put(optID, value);
|
||||
}
|
||||
|
||||
public Object getOption(int optID)
|
||||
throws SocketException
|
||||
{
|
||||
//TODO: map options to PTCP options/method calls
|
||||
return options.get(optID);
|
||||
}
|
||||
|
||||
public long getPTCPOption(Option opt)
|
||||
{
|
||||
return pseudoTcp.getOption(opt);
|
||||
}
|
||||
|
||||
public void setPTCPOption(Option opt, long optValue)
|
||||
{
|
||||
pseudoTcp.setOption(opt, optValue);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Start connection procedure
|
||||
@ -250,14 +281,14 @@ public class PseudoTcpSocketImpl
|
||||
* @param timeout for this operation in ms
|
||||
* @throws IOException
|
||||
*/
|
||||
public void Connect(InetSocketAddress remoteAddress, long timeout)
|
||||
void doConnect(InetSocketAddress remoteAddress, long timeout)
|
||||
throws IOException
|
||||
{
|
||||
logger.fine("Connecting to "+remoteAddress);
|
||||
this.remoteAddr = remoteAddress;
|
||||
StartThreads();
|
||||
pseudoTcp.Connect();
|
||||
UpdateClock();
|
||||
startThreads();
|
||||
pseudoTcp.connect();
|
||||
updateClock();
|
||||
boolean noTimeout = timeout <= 0;
|
||||
try
|
||||
{
|
||||
@ -293,12 +324,12 @@ public class PseudoTcpSocketImpl
|
||||
* @param timeout for this operation in ms
|
||||
* @throws IOException If socket gets closed or timeout expires
|
||||
*/
|
||||
public void Accept(int timeout)
|
||||
void accept(int timeout)
|
||||
throws IOException
|
||||
{
|
||||
try
|
||||
{
|
||||
StartThreads();
|
||||
startThreads();
|
||||
PseudoTcpState state = pseudoTcp.getState();
|
||||
if (state == PseudoTcpState.TCP_CLOSED)
|
||||
{
|
||||
@ -334,7 +365,7 @@ public class PseudoTcpSocketImpl
|
||||
{
|
||||
//TODO: not sure how this should work
|
||||
int timeout = 5000;
|
||||
Accept(timeout);
|
||||
accept(timeout);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -349,7 +380,7 @@ public class PseudoTcpSocketImpl
|
||||
/**
|
||||
* Interrupts clock thread's wait method to force time update
|
||||
*/
|
||||
private void UpdateClock()
|
||||
private void updateClock()
|
||||
{
|
||||
synchronized (clock_notify)
|
||||
{
|
||||
@ -360,21 +391,21 @@ public class PseudoTcpSocketImpl
|
||||
/**
|
||||
* Starts all threads required by the socket
|
||||
*/
|
||||
private void StartThreads()
|
||||
private void startThreads()
|
||||
{
|
||||
pseudoTcp.NotifyClock(System.currentTimeMillis());
|
||||
pseudoTcp.notifyClock(System.currentTimeMillis());
|
||||
receiveThread = new Thread(new Runnable()
|
||||
{
|
||||
public void run()
|
||||
{
|
||||
ReceivePackets();
|
||||
receivePackets();
|
||||
}
|
||||
}, "PseudoTcpReceiveThread");
|
||||
clockThread = new Thread(new Runnable()
|
||||
{
|
||||
public void run()
|
||||
{
|
||||
RunClock();
|
||||
runClock();
|
||||
}
|
||||
}, "PseudoTcpClockThread");
|
||||
runReceive = true;
|
||||
@ -384,12 +415,13 @@ public class PseudoTcpSocketImpl
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements @link(IPseudoTcpNotify)
|
||||
* Implements <tt>PseudoTcpNotify</tt>
|
||||
* Called when TCP enters connected state.
|
||||
*
|
||||
* @param tcp
|
||||
* @see PseudoTcpNotify#onTcpOpen(PseudoTCPBase)
|
||||
*/
|
||||
public void OnTcpOpen(PseudoTCPBase tcp)
|
||||
public void onTcpOpen(PseudoTCPBase tcp)
|
||||
{
|
||||
logger.log(Level.FINE, "tcp opened");
|
||||
//Release threads blocked at state_notify monitor object.
|
||||
@ -398,32 +430,34 @@ public class PseudoTcpSocketImpl
|
||||
state_notify.notifyAll();
|
||||
}
|
||||
//TCP is considered writeable at this point
|
||||
OnTcpWriteable(tcp);
|
||||
onTcpWriteable(tcp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements @link(IPseudoTcpNotify)
|
||||
* Implements <tt>PseudoTcpNotify</tt>
|
||||
*
|
||||
* @param tcp
|
||||
* @see PseudoTcpNotify#onTcpReadable(PseudoTCPBase)
|
||||
*/
|
||||
public void OnTcpReadable(PseudoTCPBase tcp)
|
||||
public void onTcpReadable(PseudoTCPBase tcp)
|
||||
{
|
||||
//release all thread blocked at read_notify monitor
|
||||
synchronized (read_notify)
|
||||
{
|
||||
logger.log(
|
||||
Level.FINER,
|
||||
"TCP READABLE data available for reading: "+tcp.GetAvailable());
|
||||
"TCP READABLE data available for reading: "+tcp.getAvailable());
|
||||
read_notify.notifyAll();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements @link(IPseudoTcpNotify)
|
||||
* Implements <tt>PseudoTcpNotify</tt>
|
||||
*
|
||||
* @param tcp
|
||||
* @see PseudoTcpNotify#onTcpWriteable(PseudoTCPBase)
|
||||
*/
|
||||
public void OnTcpWriteable(PseudoTCPBase tcp)
|
||||
public void onTcpWriteable(PseudoTCPBase tcp)
|
||||
{
|
||||
|
||||
logger.log(Level.FINER, "stream writeable");
|
||||
@ -438,12 +472,14 @@ public class PseudoTcpSocketImpl
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements @link(IPseudoTcpNotify)
|
||||
* Implements <tt>PseudoTcpNotify</tt>
|
||||
*
|
||||
* @param tcp
|
||||
* @param e
|
||||
*
|
||||
* @see PseudoTcpNotify#onTcpClosed(PseudoTCPBase, IOException)
|
||||
*/
|
||||
public void OnTcpClosed(PseudoTCPBase tcp, IOException e)
|
||||
public void onTcpClosed(PseudoTCPBase tcp, IOException e)
|
||||
{
|
||||
if (e != null)
|
||||
{
|
||||
@ -488,21 +524,23 @@ public class PseudoTcpSocketImpl
|
||||
*
|
||||
* @throws InterruptedException
|
||||
*/
|
||||
private void JoinAllThreads() throws InterruptedException
|
||||
private void joinAllThreads() throws InterruptedException
|
||||
{
|
||||
clockThread.join();
|
||||
receiveThread.join();
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements @link(IPseudoTcpNotify)
|
||||
* Implements <tt>PseudoTcpNotify</tt>
|
||||
*
|
||||
* @param tcp
|
||||
* @param buffer
|
||||
* @param len
|
||||
* @return
|
||||
* @return operation result
|
||||
*
|
||||
* @see PseudoTcpNotify#tcpWritePacket(PseudoTCPBase, byte[], int)
|
||||
*/
|
||||
public WriteResult TcpWritePacket(PseudoTCPBase tcp, byte[] buffer, int len)
|
||||
public WriteResult tcpWritePacket(PseudoTCPBase tcp, byte[] buffer, int len)
|
||||
{
|
||||
if (logger.isLoggable(Level.FINEST))
|
||||
{
|
||||
@ -534,7 +572,7 @@ public class PseudoTcpSocketImpl
|
||||
/**
|
||||
* Receives packets from the network and passes them to TCP logic class
|
||||
*/
|
||||
private void ReceivePackets()
|
||||
private void receivePackets()
|
||||
{
|
||||
byte[] buffer = new byte[DATAGRAM_RCV_BUFFER_SIZE];
|
||||
DatagramPacket packet = new DatagramPacket(buffer, DATAGRAM_RCV_BUFFER_SIZE);
|
||||
@ -560,9 +598,9 @@ public class PseudoTcpSocketImpl
|
||||
}
|
||||
synchronized (pseudoTcp)
|
||||
{
|
||||
pseudoTcp.NotifyPacket(buffer, packet.getLength());
|
||||
pseudoTcp.notifyPacket(buffer, packet.getLength());
|
||||
//we need to update the clock after new packet is receivied
|
||||
UpdateClock();
|
||||
updateClock();
|
||||
}
|
||||
}
|
||||
catch (IOException ex)
|
||||
@ -590,15 +628,15 @@ public class PseudoTcpSocketImpl
|
||||
* Method runs cyclic notification about time progress for TCP logic class
|
||||
* It runs in a separate thread
|
||||
*/
|
||||
private void RunClock()
|
||||
private void runClock()
|
||||
{
|
||||
long sleep;
|
||||
while (runClock)
|
||||
{
|
||||
synchronized (pseudoTcp)
|
||||
{
|
||||
pseudoTcp.NotifyClock(System.currentTimeMillis());
|
||||
sleep = pseudoTcp.GetNextClock(System.currentTimeMillis());
|
||||
pseudoTcp.notifyClock(System.currentTimeMillis());
|
||||
sleep = pseudoTcp.getNextClock(System.currentTimeMillis());
|
||||
}
|
||||
|
||||
//there might be negative interval even if there's no error
|
||||
@ -682,12 +720,12 @@ public class PseudoTcpSocketImpl
|
||||
{
|
||||
try
|
||||
{
|
||||
pseudoTcp.Close(true);
|
||||
pseudoTcp.close(true);
|
||||
//System.out.println("ON CLOSE: in flight "+pseudoTcp.GetBytesInFlight());
|
||||
//System.out.println("ON CLOSE: buff not sent "+pseudoTcp.GetBytesBufferedNotSent());
|
||||
OnTcpClosed(pseudoTcp, null);
|
||||
onTcpClosed(pseudoTcp, null);
|
||||
socket.close();
|
||||
JoinAllThreads();
|
||||
joinAllThreads();
|
||||
//UpdateClock();
|
||||
//TODO: closing procedure
|
||||
//Here the thread should be blocked until TCP
|
||||
@ -719,7 +757,7 @@ public class PseudoTcpSocketImpl
|
||||
|
||||
|
||||
/**
|
||||
* This class implements @link(InputStream) *
|
||||
* This class implements <tt>java.io.InputStream</tt>
|
||||
*/
|
||||
class PseudoTcpInputStream extends InputStream
|
||||
{
|
||||
@ -774,7 +812,7 @@ public class PseudoTcpSocketImpl
|
||||
{
|
||||
synchronized (read_notify)
|
||||
{
|
||||
read = pseudoTcp.Recv(buffer, offset, length);
|
||||
read = pseudoTcp.recv(buffer, offset, length);
|
||||
if (logger.isLoggable(Level.FINER))
|
||||
{
|
||||
logger.log(Level.FINER, "Read Recv read count: " + read);
|
||||
@ -788,7 +826,7 @@ public class PseudoTcpSocketImpl
|
||||
if (logger.isLoggable(Level.FINER))
|
||||
{
|
||||
logger.log(Level.FINER,
|
||||
"Read notified: " + pseudoTcp.GetAvailable());
|
||||
"Read notified: " + pseudoTcp.getAvailable());
|
||||
}
|
||||
}
|
||||
if (exception != null)
|
||||
@ -813,7 +851,7 @@ public class PseudoTcpSocketImpl
|
||||
@Override
|
||||
public int available() throws IOException
|
||||
{
|
||||
return pseudoTcp.GetAvailable();
|
||||
return pseudoTcp.getAvailable();
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -823,7 +861,7 @@ public class PseudoTcpSocketImpl
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements @link(OutputStream)
|
||||
* Implements <tt>java.io.OutputStream</tt>
|
||||
*/
|
||||
class PseudoTcpOutputStream extends OutputStream
|
||||
{
|
||||
@ -859,7 +897,7 @@ public class PseudoTcpSocketImpl
|
||||
{
|
||||
synchronized (pseudoTcp)
|
||||
{
|
||||
sent = pseudoTcp.Send(buffer, offset + length - toSend, toSend);
|
||||
sent = pseudoTcp.send(buffer, offset + length - toSend, toSend);
|
||||
}
|
||||
if (sent > 0)
|
||||
{
|
||||
@ -876,7 +914,7 @@ public class PseudoTcpSocketImpl
|
||||
}
|
||||
logger.log(Level.FINER,
|
||||
"Write notified, available: "
|
||||
+ pseudoTcp.GetAvailableSendBuffer());
|
||||
+ pseudoTcp.getAvailableSendBuffer());
|
||||
if (exception != null)
|
||||
{
|
||||
throw exception;
|
||||
@ -906,8 +944,8 @@ public class PseudoTcpSocketImpl
|
||||
public synchronized void flush() throws IOException
|
||||
{
|
||||
logger.log(Level.FINE, "Flushing...");
|
||||
final Object ackNotify = pseudoTcp.GetAckNotify();
|
||||
while (pseudoTcp.GetBytesBufferedNotSent() > 0)
|
||||
final Object ackNotify = pseudoTcp.getAckNotify();
|
||||
while (pseudoTcp.getBytesBufferedNotSent() > 0)
|
||||
{
|
||||
synchronized (ackNotify)
|
||||
{
|
||||
|
||||
25
src/org/ice4j/pseudotcp/RSegment.java
Normal file
25
src/org/ice4j/pseudotcp/RSegment.java
Normal file
@ -0,0 +1,25 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
* Maintained by the Jitsi community (https://jitsi.org).
|
||||
*
|
||||
* Distributable under LGPL license.
|
||||
* See terms of license at gnu.org.
|
||||
*/
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
|
||||
/**
|
||||
* Class used internally as a structure for receive segments
|
||||
*
|
||||
* @author Pawel
|
||||
*/
|
||||
class RSegment
|
||||
{
|
||||
public long seq, len;
|
||||
|
||||
public RSegment(long seq, long len)
|
||||
{
|
||||
this.seq = seq;
|
||||
this.len = len;
|
||||
}
|
||||
}
|
||||
29
src/org/ice4j/pseudotcp/SSegment.java
Normal file
29
src/org/ice4j/pseudotcp/SSegment.java
Normal file
@ -0,0 +1,29 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
* Maintained by the Jitsi community (https://jitsi.org).
|
||||
*
|
||||
* Distributable under LGPL license.
|
||||
* See terms of license at gnu.org.
|
||||
*/
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
/**
|
||||
* Class used internally as a structure for send segments
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
class SSegment
|
||||
{
|
||||
long seq, len;
|
||||
//uint32 tstamp;
|
||||
short xmit;
|
||||
boolean bCtrl;
|
||||
|
||||
SSegment(long s, long l, boolean c)
|
||||
{
|
||||
seq = s;
|
||||
len = l;
|
||||
xmit = 0;
|
||||
bCtrl = c;
|
||||
}
|
||||
}
|
||||
27
src/org/ice4j/pseudotcp/Segment.java
Normal file
27
src/org/ice4j/pseudotcp/Segment.java
Normal file
@ -0,0 +1,27 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
* Maintained by the Jitsi community (https://jitsi.org).
|
||||
*
|
||||
* Distributable under LGPL license.
|
||||
* See terms of license at gnu.org.
|
||||
*/
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
|
||||
/**
|
||||
* Class used as a segment structure
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
public class Segment
|
||||
{
|
||||
long conv;
|
||||
long seq;
|
||||
long ack;
|
||||
byte flags;
|
||||
int wnd;
|
||||
long tsval;
|
||||
long tsecr;
|
||||
byte[] data;
|
||||
int len;
|
||||
}
|
||||
18
src/org/ice4j/pseudotcp/SendFlags.java
Normal file
18
src/org/ice4j/pseudotcp/SendFlags.java
Normal file
@ -0,0 +1,18 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
* Maintained by the Jitsi community (https://jitsi.org).
|
||||
*
|
||||
* Distributable under LGPL license.
|
||||
* See terms of license at gnu.org.
|
||||
*/
|
||||
package org.ice4j.pseudotcp;
|
||||
|
||||
/**
|
||||
* Send flags used internally
|
||||
*
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
enum SendFlags
|
||||
{
|
||||
sfNone, sfImmediateAck, sfDelayedAck;
|
||||
}
|
||||
@ -46,33 +46,33 @@ public class ByteFifoBuffer
|
||||
/**
|
||||
* @return buffer's capacity
|
||||
*/
|
||||
public int Length()
|
||||
public int length()
|
||||
{
|
||||
return array.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Method reads <tt>count</tt> bytes into <tt>out_buffer</tt>
|
||||
* Method reads <tt>count</tt> bytes into <tt>out_buffer</tt>.
|
||||
* Current read position is incremented by count of bytes
|
||||
* that has been successfully read
|
||||
* that has been successfully read.
|
||||
*
|
||||
* @param out_buffer
|
||||
* @param count
|
||||
* @return bytes successfully read
|
||||
*/
|
||||
public int Read(byte[] out_buffer, int count)
|
||||
public int read(byte[] out_buffer, int count)
|
||||
{
|
||||
return Read(out_buffer, 0, count);
|
||||
return read(out_buffer, 0, count);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read with buffer offset
|
||||
* @param out_buffer
|
||||
* @param buff_offset
|
||||
* @param len
|
||||
* @return
|
||||
* @param count bytes to read
|
||||
* @return read byte count
|
||||
*/
|
||||
public int Read(byte[] out_buffer, int buff_offset, int count) {
|
||||
public int read(byte[] out_buffer, int buff_offset, int count) {
|
||||
count = readLimit(count);
|
||||
if (count > 0)
|
||||
{
|
||||
@ -127,7 +127,7 @@ public class ByteFifoBuffer
|
||||
*
|
||||
* @return space left in buffer for write
|
||||
*/
|
||||
public int GetWriteRemaining()
|
||||
public int getWriteRemaining()
|
||||
{
|
||||
return array.length - buffered;
|
||||
}
|
||||
@ -136,7 +136,7 @@ public class ByteFifoBuffer
|
||||
*
|
||||
* @return bytes stored in buffer and available for reading
|
||||
*/
|
||||
public int GetBuffered()
|
||||
public int getBuffered()
|
||||
{
|
||||
return buffered;
|
||||
}
|
||||
@ -148,9 +148,9 @@ public class ByteFifoBuffer
|
||||
* @param count
|
||||
* @return bytes successfully written to buffer
|
||||
*/
|
||||
public int Write(byte[] buffer, int count)
|
||||
public int write(byte[] buffer, int count)
|
||||
{
|
||||
return Write(buffer, 0, count);
|
||||
return write(buffer, 0, count);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -160,7 +160,7 @@ public class ByteFifoBuffer
|
||||
* @param count
|
||||
* @return byte count actually read
|
||||
*/
|
||||
public int Write(byte[] data, int offset, int count)
|
||||
public int write(byte[] data, int offset, int count)
|
||||
{
|
||||
/*
|
||||
* System.out.println("----write " + this + " " + len + " buffered " +
|
||||
@ -233,7 +233,7 @@ public class ByteFifoBuffer
|
||||
throws IllegalArgumentException
|
||||
{
|
||||
int spaceReq;
|
||||
int availSpace = GetWriteRemaining();
|
||||
int availSpace = getWriteRemaining();
|
||||
if (newWrPos < write_pos)
|
||||
{
|
||||
spaceReq = newWrPos + (array.length - write_pos);
|
||||
@ -254,11 +254,11 @@ public class ByteFifoBuffer
|
||||
*
|
||||
* @param count
|
||||
*/
|
||||
public void ConsumeWriteBuffer(int count)
|
||||
public void consumeWriteBuffer(int count)
|
||||
throws IllegalArgumentException,
|
||||
BufferOverflowException
|
||||
{
|
||||
if (count > GetWriteRemaining())
|
||||
if (count > getWriteRemaining())
|
||||
{
|
||||
throw new BufferOverflowException();
|
||||
}
|
||||
@ -280,9 +280,9 @@ public class ByteFifoBuffer
|
||||
* @return <tt>true</tt> if operation is possible to perform, that is if new
|
||||
* buffered data fits into new buffer
|
||||
*/
|
||||
public boolean SetCapacity(int new_size)
|
||||
public boolean setCapacity(int new_size)
|
||||
{
|
||||
if (new_size < GetBuffered())
|
||||
if (new_size < getBuffered())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
@ -299,7 +299,7 @@ public class ByteFifoBuffer
|
||||
* @throws BufferUnderflowException if new position exceeds buffered data
|
||||
* count
|
||||
*/
|
||||
public void ConsumeReadData(int count)
|
||||
public void consumeReadData(int count)
|
||||
throws IllegalArgumentException,
|
||||
BufferUnderflowException
|
||||
{
|
||||
@ -328,7 +328,7 @@ public class ByteFifoBuffer
|
||||
* @param offset from current read position
|
||||
* @return bytes successfully read
|
||||
*/
|
||||
public int ReadOffset(byte[] dst_buff,
|
||||
public int readOffset(byte[] dst_buff,
|
||||
int dst_buff_offset,
|
||||
int count,
|
||||
int offset)
|
||||
@ -353,10 +353,10 @@ public class ByteFifoBuffer
|
||||
* @param nOffset from buffer's write position
|
||||
* @return bytes successfully written
|
||||
*/
|
||||
public int WriteOffset(byte[] data, int count, int nOffset)
|
||||
public int writeOffset(byte[] data, int count, int nOffset)
|
||||
throws BufferOverflowException
|
||||
{
|
||||
if (count > GetWriteRemaining())
|
||||
if (count > getWriteRemaining())
|
||||
{
|
||||
throw new BufferOverflowException();
|
||||
}
|
||||
@ -366,25 +366,18 @@ public class ByteFifoBuffer
|
||||
}
|
||||
int offWritePos = (this.write_pos + nOffset) % array.length;
|
||||
count = writeLimit(count);
|
||||
//try{
|
||||
assertWriteLimit(offWritePos + count);
|
||||
//}catch(IllegalArgumentException e){
|
||||
// System.out.println("Write offset: " + nOffset + " count: " + count
|
||||
//+ " wpos: " + write_pos + " buffered: " + buffered + " len: " + length + this);
|
||||
// throw e;
|
||||
//}
|
||||
//buffer.position(writePos + nOffset);
|
||||
writeOp(data, 0, count, array, offWritePos, array.length);
|
||||
//buffer.position(writePos);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
public void ResetReadPosition()
|
||||
public void resetReadPosition()
|
||||
{
|
||||
this.read_pos = 0;
|
||||
}
|
||||
|
||||
public void ResetWritePosition()
|
||||
public void resetWritePosition()
|
||||
{
|
||||
this.write_pos = 0;
|
||||
this.buffered = 0;
|
||||
|
||||
@ -41,12 +41,12 @@ public class MultiThreadSupportTest
|
||||
}
|
||||
|
||||
private long assertWaitInterval = 100;
|
||||
protected interface IWaitUntilDone
|
||||
protected interface WaitUntilDone
|
||||
{
|
||||
public boolean isDone();
|
||||
}
|
||||
|
||||
protected boolean assert_wait_until(IWaitUntilDone wait, long timeoutMs)
|
||||
protected boolean assert_wait_until(WaitUntilDone wait, long timeoutMs)
|
||||
{
|
||||
try
|
||||
{
|
||||
|
||||
@ -34,12 +34,14 @@ public class PseudoTcpStreamTest
|
||||
* Test one-way transfer with @link(PseudoTcpStream)
|
||||
*
|
||||
* @throws SocketException
|
||||
* @throws UnknownHostException
|
||||
*/
|
||||
public void testConnectTransferClose() throws SocketException
|
||||
public void testConnectTransferClose()
|
||||
throws SocketException,
|
||||
UnknownHostException
|
||||
{
|
||||
Thread.setDefaultUncaughtExceptionHandler(this);
|
||||
final int server_port = 49999;
|
||||
long conv_id = 0;
|
||||
int transferTimeout = 5000;
|
||||
|
||||
// bytes that will be read as a single byte
|
||||
@ -48,12 +50,10 @@ public class PseudoTcpStreamTest
|
||||
PseudoTcpTestBase.createDummyData(singleStepCount);
|
||||
final int sizeA = 138746;
|
||||
final byte[] bufferA = PseudoTcpTestBase.createDummyData(sizeA);
|
||||
final int sizeB = 483746;
|
||||
final int sizeB = 4803746;
|
||||
final byte[] bufferB = PseudoTcpTestBase.createDummyData(sizeB);
|
||||
|
||||
final PseudoTcpSocketImpl server = new PseudoTcpSocketImpl(conv_id);
|
||||
final PseudoTcpSocketImpl client = new PseudoTcpSocketImpl(conv_id);
|
||||
|
||||
final InetSocketAddress serverAddress =
|
||||
new InetSocketAddress(InetAddress.getLocalHost(), server_port);
|
||||
Thread serverThread = new Thread(new Runnable()
|
||||
{
|
||||
@Override
|
||||
@ -61,8 +61,12 @@ public class PseudoTcpStreamTest
|
||||
{
|
||||
try
|
||||
{
|
||||
server.bind(InetAddress.getLocalHost(), server_port);
|
||||
server.accept(null);
|
||||
final PseudoTcpSocket server =
|
||||
new PseudoTcpSocketFactory().
|
||||
createSocket();
|
||||
server.setDebugName("L");
|
||||
server.bind(serverAddress);
|
||||
server.accept(5000);
|
||||
byte[] rcvdSingle = new byte[singleStepCount];
|
||||
// read by one byte
|
||||
for (int i = 0; i < singleStepCount; i++)
|
||||
@ -76,7 +80,7 @@ public class PseudoTcpStreamTest
|
||||
byte[] recvdBufferB =
|
||||
receiveBuffer(server.getInputStream(), sizeB);
|
||||
assertArrayEquals(bufferB, recvdBufferB);
|
||||
// server.Close();
|
||||
// server.close();
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -85,16 +89,17 @@ public class PseudoTcpStreamTest
|
||||
}
|
||||
});
|
||||
|
||||
final PseudoTcpSocket client =
|
||||
new PseudoTcpSocketFactory().createSocket();
|
||||
Thread clientThread = new Thread(new Runnable()
|
||||
{
|
||||
@Override
|
||||
public void run()
|
||||
{
|
||||
try
|
||||
{
|
||||
client.connect(InetAddress.getLocalHost(), server_port);
|
||||
assertEquals(PseudoTcpState.TCP_ESTABLISHED,
|
||||
client.getState());
|
||||
{
|
||||
client.setDebugName("R");
|
||||
client.connect(serverAddress, 5000);
|
||||
// write single array
|
||||
for (int i = 0; i < singleStepCount; i++)
|
||||
client.getOutputStream().write(bufferSingle[i]);
|
||||
@ -134,7 +139,7 @@ public class PseudoTcpStreamTest
|
||||
clientThread.start();
|
||||
try
|
||||
{
|
||||
boolean success = assert_wait_until(new IWaitUntilDone()
|
||||
boolean success = assert_wait_until(new WaitUntilDone()
|
||||
{
|
||||
@Override
|
||||
public boolean isDone()
|
||||
@ -184,7 +189,7 @@ public class PseudoTcpStreamTest
|
||||
try
|
||||
{
|
||||
PseudoTcpSocketImpl server = new PseudoTcpSocketImpl(0);
|
||||
server.Accept(10);
|
||||
server.accept(10);
|
||||
fail("Should throw timeout exception");
|
||||
}
|
||||
catch (IOException ex)
|
||||
|
||||
@ -21,7 +21,7 @@ import org.ice4j.pseudotcp.util.*;
|
||||
* @author Pawel Domas
|
||||
*/
|
||||
public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
implements IPseudoTcpNotify
|
||||
implements PseudoTcpNotify
|
||||
{
|
||||
/**
|
||||
* The logger.
|
||||
@ -77,8 +77,8 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
remoteTcp.debugName = "REM";
|
||||
this.localTcp = new PseudoTCPBase(this, 1);
|
||||
localTcp.debugName = "LOC";
|
||||
SetLocalMtu(65535);
|
||||
SetRemoteMtu(65535);
|
||||
setLocalMtu(65535);
|
||||
setRemoteMtu(65535);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -100,9 +100,9 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param mtu
|
||||
*/
|
||||
void SetLocalMtu(int mtu)
|
||||
void setLocalMtu(int mtu)
|
||||
{
|
||||
localTcp.NotifyMTU(mtu);
|
||||
localTcp.notifyMTU(mtu);
|
||||
local_mtu_ = mtu;
|
||||
}
|
||||
|
||||
@ -111,9 +111,9 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param mtu
|
||||
*/
|
||||
void SetRemoteMtu(int mtu)
|
||||
void setRemoteMtu(int mtu)
|
||||
{
|
||||
remoteTcp.NotifyMTU(mtu);
|
||||
remoteTcp.notifyMTU(mtu);
|
||||
remote_mtu_ = mtu;
|
||||
}
|
||||
|
||||
@ -122,7 +122,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param delay
|
||||
*/
|
||||
void SetDelay(int delay)
|
||||
void setDelay(int delay)
|
||||
{
|
||||
delay_ = delay;
|
||||
}
|
||||
@ -132,7 +132,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param percent
|
||||
*/
|
||||
void SetLoss(int percent)
|
||||
void setLoss(int percent)
|
||||
{
|
||||
loss_ = percent;
|
||||
}
|
||||
@ -142,10 +142,10 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param enable_nagles
|
||||
*/
|
||||
void SetOptNagling(boolean enable_nagles)
|
||||
void setOptNagling(boolean enable_nagles)
|
||||
{
|
||||
localTcp.SetOption(Option.OPT_NODELAY, enable_nagles ? 0 : 1);
|
||||
remoteTcp.SetOption(Option.OPT_NODELAY, enable_nagles ? 0 : 1);
|
||||
localTcp.setOption(Option.OPT_NODELAY, enable_nagles ? 0 : 1);
|
||||
remoteTcp.setOption(Option.OPT_NODELAY, enable_nagles ? 0 : 1);
|
||||
|
||||
}
|
||||
|
||||
@ -154,10 +154,10 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param ack_delay
|
||||
*/
|
||||
void SetOptAckDelay(int ack_delay)
|
||||
void setOptAckDelay(int ack_delay)
|
||||
{
|
||||
localTcp.SetOption(Option.OPT_ACKDELAY, ack_delay);
|
||||
remoteTcp.SetOption(Option.OPT_ACKDELAY, ack_delay);
|
||||
localTcp.setOption(Option.OPT_ACKDELAY, ack_delay);
|
||||
remoteTcp.setOption(Option.OPT_ACKDELAY, ack_delay);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -165,10 +165,10 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param size
|
||||
*/
|
||||
void SetOptSndBuf(int size)
|
||||
void setOptSndBuf(int size)
|
||||
{
|
||||
localTcp.SetOption(Option.OPT_SNDBUF, size);
|
||||
remoteTcp.SetOption(Option.OPT_SNDBUF, size);
|
||||
localTcp.setOption(Option.OPT_SNDBUF, size);
|
||||
remoteTcp.setOption(Option.OPT_SNDBUF, size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -176,9 +176,9 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param size
|
||||
*/
|
||||
void SetRemoteOptRcvBuf(int size)
|
||||
void setRemoteOptRcvBuf(int size)
|
||||
{
|
||||
remoteTcp.SetOption(Option.OPT_RCVBUF, size);
|
||||
remoteTcp.setOption(Option.OPT_RCVBUF, size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -186,15 +186,15 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @param size
|
||||
*/
|
||||
void SetLocalOptRcvBuf(int size)
|
||||
void setLocalOptRcvBuf(int size)
|
||||
{
|
||||
localTcp.SetOption(Option.OPT_RCVBUF, size);
|
||||
localTcp.setOption(Option.OPT_RCVBUF, size);
|
||||
}
|
||||
|
||||
/**
|
||||
* Disable window scaling for remote peer
|
||||
*/
|
||||
void DisableRemoteWindowScale()
|
||||
void disableRemoteWindowScale()
|
||||
{
|
||||
remoteTcp.disableWindowScale();
|
||||
}
|
||||
@ -202,7 +202,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
/**
|
||||
* Disable window scaling for local peer
|
||||
*/
|
||||
void DisableLocalWindowScale()
|
||||
void disableLocalWindowScale()
|
||||
{
|
||||
localTcp.disableWindowScale();
|
||||
}
|
||||
@ -212,19 +212,19 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*
|
||||
* @throws IOException
|
||||
*/
|
||||
void Connect() throws IOException
|
||||
void connect() throws IOException
|
||||
{
|
||||
localTcp.Connect();
|
||||
UpdateLocalClock();
|
||||
localTcp.connect();
|
||||
updateLocalClock();
|
||||
}
|
||||
|
||||
/**
|
||||
* Closes the connection
|
||||
*/
|
||||
void Close()
|
||||
void close()
|
||||
{
|
||||
localTcp.Close(false);
|
||||
UpdateLocalClock();
|
||||
localTcp.close(false);
|
||||
updateLocalClock();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -234,12 +234,12 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @param tcp
|
||||
*/
|
||||
@Override
|
||||
public void OnTcpOpen(PseudoTCPBase tcp)
|
||||
public void onTcpOpen(PseudoTCPBase tcp)
|
||||
{
|
||||
if (tcp == localTcp)
|
||||
{
|
||||
have_connected_ = true;
|
||||
OnTcpWriteable(tcp);
|
||||
onTcpWriteable(tcp);
|
||||
}
|
||||
}
|
||||
|
||||
@ -250,7 +250,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @param exc
|
||||
*/
|
||||
@Override
|
||||
public void OnTcpClosed(PseudoTCPBase tcp, IOException exc)
|
||||
public void onTcpClosed(PseudoTCPBase tcp, IOException exc)
|
||||
{
|
||||
assert exc == null;
|
||||
if (tcp == remoteTcp)
|
||||
@ -263,7 +263,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*/
|
||||
private Random random = new Random();
|
||||
|
||||
int RandomInt()
|
||||
int randomInt()
|
||||
{
|
||||
return random.nextInt(100);
|
||||
}
|
||||
@ -276,9 +276,9 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @return
|
||||
* @throws IOException
|
||||
*/
|
||||
int LocalSend(byte[] data, int len) throws IOException
|
||||
int localSend(byte[] data, int len) throws IOException
|
||||
{
|
||||
return localTcp.Send(data, len);
|
||||
return localTcp.send(data, len);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -289,9 +289,9 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @return
|
||||
* @throws IOException
|
||||
*/
|
||||
int LocalRecv(byte[] buffer, int len) throws IOException
|
||||
int localRecv(byte[] buffer, int len) throws IOException
|
||||
{
|
||||
return localTcp.Recv(buffer, len);
|
||||
return localTcp.recv(buffer, len);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -302,10 +302,10 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @return
|
||||
* @throws IOException
|
||||
*/
|
||||
int RemoteRecv(byte[] buffer, int len) throws IOException
|
||||
int remoteRecv(byte[] buffer, int len) throws IOException
|
||||
{
|
||||
|
||||
return remoteTcp.Recv(buffer, len);
|
||||
return remoteTcp.recv(buffer, len);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -316,10 +316,10 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @return
|
||||
* @throws IOException
|
||||
*/
|
||||
int RemoteSend(byte[] data, int len)
|
||||
int remoteSend(byte[] data, int len)
|
||||
throws IOException
|
||||
{
|
||||
return remoteTcp.Send(data, len);
|
||||
return remoteTcp.send(data, len);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -329,11 +329,11 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @param len
|
||||
* @throws IOException
|
||||
*/
|
||||
private void LocalPacket(byte[] data, int len)
|
||||
private void localPacket(byte[] data, int len)
|
||||
throws IOException
|
||||
{
|
||||
localTcp.NotifyPacket(data, len);
|
||||
UpdateLocalClock();
|
||||
localTcp.notifyPacket(data, len);
|
||||
updateLocalClock();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -343,11 +343,11 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @param len
|
||||
* @throws IOException
|
||||
*/
|
||||
private void RemotePacket(byte[] data, int len)
|
||||
private void remotePacket(byte[] data, int len)
|
||||
throws IOException
|
||||
{
|
||||
remoteTcp.NotifyPacket(data, len);
|
||||
UpdateRemoteClock();
|
||||
remoteTcp.notifyPacket(data, len);
|
||||
updateRemoteClock();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -366,7 +366,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
{
|
||||
try
|
||||
{
|
||||
RemotePacket(data, len);
|
||||
remotePacket(data, len);
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -392,7 +392,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
{
|
||||
try
|
||||
{
|
||||
LocalPacket(data, len);
|
||||
localPacket(data, len);
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -412,11 +412,11 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @return
|
||||
*/
|
||||
@Override
|
||||
public WriteResult TcpWritePacket(PseudoTCPBase tcp, byte[] buffer, int len)
|
||||
public WriteResult tcpWritePacket(PseudoTCPBase tcp, byte[] buffer, int len)
|
||||
{
|
||||
// Randomly drop the desired percentage of packets.
|
||||
// Also drop packets that are larger than the configured MTU.
|
||||
if (RandomInt() < loss_)
|
||||
if (randomInt() < loss_)
|
||||
{
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
{
|
||||
@ -452,7 +452,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
/**
|
||||
* Wakes up local clock thread from wait method causing forced time update
|
||||
*/
|
||||
protected void UpdateLocalClock()
|
||||
protected void updateLocalClock()
|
||||
{
|
||||
if (localClockThread != null)
|
||||
{
|
||||
@ -466,7 +466,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
/**
|
||||
* Wakes up remote clock thread from wait method causing forced time update
|
||||
*/
|
||||
protected void UpdateRemoteClock()
|
||||
protected void updateRemoteClock()
|
||||
{
|
||||
if (remoteClockThread != null)
|
||||
{
|
||||
@ -483,22 +483,22 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @param tcp
|
||||
* @param lock
|
||||
*/
|
||||
private void UpdateNextClock(final PseudoTCPBase tcp, final Object lock)
|
||||
private void updateNextClock(final PseudoTCPBase tcp, final Object lock)
|
||||
{
|
||||
try
|
||||
{
|
||||
|
||||
long now = PseudoTCPBase.Now();
|
||||
long now = PseudoTCPBase.now();
|
||||
//System.out.println(tcp.debugName + " NOTIFY CLOCK: " + now);
|
||||
synchronized (tcp)
|
||||
{
|
||||
tcp.NotifyClock(now);
|
||||
tcp.notifyClock(now);
|
||||
}
|
||||
//UpdateClock(tcp);
|
||||
long interval; // NOLINT
|
||||
synchronized (tcp)
|
||||
{
|
||||
interval = tcp.GetNextClock(PseudoTCPBase.Now());
|
||||
interval = tcp.getNextClock(PseudoTCPBase.now());
|
||||
}
|
||||
//interval = Math.max(interval, 0L); // sometimes interval is < 0
|
||||
if (logger.isLoggable(Level.FINEST))
|
||||
@ -545,7 +545,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
/**
|
||||
* Start clock threads
|
||||
*/
|
||||
protected void StartClocks()
|
||||
protected void startClocks()
|
||||
{
|
||||
if (localClockThread == null && remoteClockThread == null)
|
||||
{
|
||||
@ -558,7 +558,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
while (runClocks)
|
||||
{
|
||||
//localTcp.NotifyClock(PseudoTCPBase.Now());
|
||||
UpdateNextClock(localTcp, localClockLock);
|
||||
updateNextClock(localTcp, localClockLock);
|
||||
|
||||
}
|
||||
|
||||
@ -572,7 +572,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
while (runClocks)
|
||||
{
|
||||
//remoteTcp.NotifyClock(PseudoTCPBase.Now());
|
||||
UpdateNextClock(remoteTcp, remoteClockLock);
|
||||
updateNextClock(remoteTcp, remoteClockLock);
|
||||
}
|
||||
|
||||
}
|
||||
@ -589,7 +589,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
/**
|
||||
* Stops clock threads
|
||||
*/
|
||||
protected void StopClocks()
|
||||
protected void stopClocks()
|
||||
{
|
||||
if (localClockThread != null && remoteClockThread != null)
|
||||
{
|
||||
@ -623,7 +623,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*/
|
||||
protected boolean assert_Connected_wait(int kConnectTimeoutMs)
|
||||
{
|
||||
return assert_wait_until(new IWaitUntilDone()
|
||||
return assert_wait_until(new WaitUntilDone()
|
||||
{
|
||||
@Override
|
||||
public boolean isDone()
|
||||
@ -642,7 +642,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
*/
|
||||
protected boolean assert_Disconnected_wait(long kTransferTimeoutMs)
|
||||
{
|
||||
return assert_wait_until(new IWaitUntilDone()
|
||||
return assert_wait_until(new WaitUntilDone()
|
||||
{
|
||||
@Override
|
||||
public boolean isDone()
|
||||
@ -676,7 +676,7 @@ public abstract class PseudoTcpTestBase extends MultiThreadSupportTest
|
||||
* @param kBps
|
||||
* @return timeout for transfer in ms(minimum 3000 ms)
|
||||
*/
|
||||
public long MaxTransferTime(long size, long kBps)
|
||||
public long maxTransferTime(long size, long kBps)
|
||||
{
|
||||
long transferTout = ((size) / kBps) * 8 * 1000;
|
||||
return transferTout > 3000 ? transferTout : 3000;
|
||||
|
||||
@ -66,7 +66,7 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
* @param size
|
||||
* @param iterations
|
||||
*/
|
||||
public void TestPingPong(int size, int iterations)
|
||||
public void doTestPingPong(int size, int iterations)
|
||||
{
|
||||
Thread.setDefaultUncaughtExceptionHandler(this);
|
||||
long start, end;
|
||||
@ -76,15 +76,15 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
// Create some dummy data
|
||||
byte[] dummy = createDummyData(size);
|
||||
send_stream = new ByteFifoBuffer(size);
|
||||
send_stream.Write(dummy, size);
|
||||
send_stream.write(dummy, size);
|
||||
//Prepare the receive stream
|
||||
recv_stream = new ByteFifoBuffer(size);
|
||||
//Connect and wait until connected
|
||||
start = PseudoTCPBase.Now();
|
||||
StartClocks();
|
||||
start = PseudoTCPBase.now();
|
||||
startClocks();
|
||||
try
|
||||
{
|
||||
Connect();
|
||||
connect();
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -96,8 +96,8 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
// Sending will start from OnTcpWriteable and stop when the required
|
||||
// number of iterations have completed.
|
||||
assert_Disconnected_wait(kMinTransferRate);
|
||||
long elapsed = PseudoTCPBase.Now() - start;
|
||||
StopClocks();
|
||||
long elapsed = PseudoTCPBase.now() - start;
|
||||
stopClocks();
|
||||
logger.log(Level.INFO,
|
||||
"Performed " + iterations + " pings in " + elapsed + " ms");
|
||||
}
|
||||
@ -108,13 +108,13 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
* @param tcp
|
||||
*/
|
||||
@Override
|
||||
public void OnTcpReadable(PseudoTCPBase tcp)
|
||||
public void onTcpReadable(PseudoTCPBase tcp)
|
||||
{
|
||||
assertEquals("Unexpected onTcpReadable", receiver, tcp);
|
||||
try
|
||||
{
|
||||
// Stream bytes to the recv stream as they arrive.
|
||||
ReadData();
|
||||
readData();
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -123,8 +123,8 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
}
|
||||
// If we've received the desired amount of data, rewind things
|
||||
// and send it back the other way!
|
||||
int recvd = recv_stream.GetBuffered();
|
||||
int required = send_stream.Length();
|
||||
int recvd = recv_stream.getBuffered();
|
||||
int required = send_stream.length();
|
||||
if (logger.isLoggable(Level.FINER))
|
||||
{
|
||||
logger.log(Level.FINER,
|
||||
@ -135,19 +135,19 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
if (receiver == getLocalTcp() && --iterationsRemaining == 0)
|
||||
{
|
||||
Close();
|
||||
close();
|
||||
// TODO: Fake OnTcpClosed() on the receiver for now.
|
||||
OnTcpClosed(getRemoteTcp(), null);
|
||||
onTcpClosed(getRemoteTcp(), null);
|
||||
return;
|
||||
}
|
||||
//switches receivier with sender and performs test the other way
|
||||
PseudoTCPBase tmp = receiver;
|
||||
receiver = sender;
|
||||
sender = tmp;
|
||||
send_stream.ResetReadPosition();
|
||||
send_stream.ConsumeWriteBuffer(send_stream.GetWriteRemaining());
|
||||
recv_stream.ResetWritePosition();
|
||||
OnTcpWriteable(sender);
|
||||
send_stream.resetReadPosition();
|
||||
send_stream.consumeWriteBuffer(send_stream.getWriteRemaining());
|
||||
recv_stream.resetWritePosition();
|
||||
onTcpWriteable(sender);
|
||||
}
|
||||
|
||||
}
|
||||
@ -158,7 +158,7 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
* @param tcp
|
||||
*/
|
||||
@Override
|
||||
public void OnTcpWriteable(PseudoTCPBase tcp)
|
||||
public void onTcpWriteable(PseudoTCPBase tcp)
|
||||
{
|
||||
if (tcp != sender)
|
||||
{
|
||||
@ -169,7 +169,7 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
logger.log(Level.FINER, "Flow Control Lifted");
|
||||
try
|
||||
{
|
||||
WriteData();
|
||||
writeData();
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -183,20 +183,20 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
*
|
||||
* @throws IOException
|
||||
*/
|
||||
private void ReadData() throws IOException
|
||||
private void readData() throws IOException
|
||||
{
|
||||
byte[] block = new byte[kBlockSize];
|
||||
int rcvd = 0;
|
||||
do
|
||||
{
|
||||
rcvd = receiver.Recv(block, block.length);
|
||||
rcvd = receiver.recv(block, block.length);
|
||||
if (rcvd > 0)
|
||||
{
|
||||
recv_stream.Write(block, rcvd);
|
||||
recv_stream.write(block, rcvd);
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
{
|
||||
logger.log(Level.FINE,
|
||||
"Receivied: " + recv_stream.GetBuffered());
|
||||
"Receivied: " + recv_stream.getBuffered());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -208,7 +208,7 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
*
|
||||
* @throws IOException
|
||||
*/
|
||||
private void WriteData() throws IOException
|
||||
private void writeData() throws IOException
|
||||
{
|
||||
int tosend;
|
||||
int sent = 0;
|
||||
@ -216,11 +216,11 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
do
|
||||
{
|
||||
tosend = bytesPerSend != 0 ? bytesPerSend : block.length;
|
||||
tosend = send_stream.Read(block, tosend);
|
||||
tosend = send_stream.read(block, tosend);
|
||||
if (tosend > 0)
|
||||
{
|
||||
sent = sender.Send(block, tosend);
|
||||
UpdateLocalClock();
|
||||
sent = sender.send(block, tosend);
|
||||
updateLocalClock();
|
||||
if (sent != -1)
|
||||
{
|
||||
if(logger.isLoggable(Level.FINE))
|
||||
@ -253,9 +253,9 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test ping - pong 1xMTU");
|
||||
PseudoTcpTestPingPong test = new PseudoTcpTestPingPong();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.TestPingPong(100, 100);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.doTestPingPong(100, 100);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -265,9 +265,9 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test ping - pong 3xMTU");
|
||||
PseudoTcpTestPingPong test = new PseudoTcpTestPingPong();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.TestPingPong(400, 100);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.doTestPingPong(400, 100);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -278,9 +278,9 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test ping - pong 2xMTU");
|
||||
PseudoTcpTestPingPong test = new PseudoTcpTestPingPong();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.TestPingPong(2000, 5);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.doTestPingPong(2000, 5);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -291,10 +291,10 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test ping - pong 2xMTU ack delay off");
|
||||
PseudoTcpTestPingPong test = new PseudoTcpTestPingPong();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetOptAckDelay(0);
|
||||
test.TestPingPong(2000, 100);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setOptAckDelay(0);
|
||||
test.doTestPingPong(2000, 100);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -305,10 +305,10 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test ping - pong 2xMTU nagling off");
|
||||
PseudoTcpTestPingPong test = new PseudoTcpTestPingPong();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetOptNagling(false);
|
||||
test.TestPingPong(2000, 5);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setOptNagling(false);
|
||||
test.doTestPingPong(2000, 5);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -319,11 +319,11 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test ping - pong short segments");
|
||||
PseudoTcpTestPingPong test = new PseudoTcpTestPingPong();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetOptAckDelay(5000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setOptAckDelay(5000);
|
||||
test.setBytesPerSend(50); // i.e. two Send calls per payload
|
||||
test.TestPingPong(100, 5);
|
||||
test.doTestPingPong(100, 5);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -334,11 +334,11 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test ping - pong short segments nagling off");
|
||||
PseudoTcpTestPingPong test = new PseudoTcpTestPingPong();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetOptNagling(false);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setOptNagling(false);
|
||||
test.setBytesPerSend(50); // i.e. two Send calls per payload
|
||||
test.TestPingPong(100, 5);
|
||||
test.doTestPingPong(100, 5);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -349,10 +349,10 @@ public class PseudoTcpTestPingPong extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test ping - pong short segments nagling off");
|
||||
PseudoTcpTestPingPong test = new PseudoTcpTestPingPong();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setBytesPerSend(50); // i.e. two Send calls per payload
|
||||
test.SetOptAckDelay(0);
|
||||
test.TestPingPong(100, 5);
|
||||
test.setOptAckDelay(0);
|
||||
test.doTestPingPong(100, 5);
|
||||
}
|
||||
}
|
||||
|
||||
@ -53,7 +53,7 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
*/
|
||||
private int testDataSize;
|
||||
|
||||
public void TestTransfer(int size)
|
||||
public void doTestTransfer(int size)
|
||||
{
|
||||
Thread.setDefaultUncaughtExceptionHandler(this);
|
||||
testDataSize = size;
|
||||
@ -63,15 +63,15 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
// Create some dummy data
|
||||
byte[] dummy = createDummyData(size);
|
||||
send_stream = new ByteFifoBuffer(size);
|
||||
send_stream.Write(dummy, size);
|
||||
send_stream.write(dummy, size);
|
||||
//Prepare the receive stream
|
||||
recv_stream = new ByteFifoBuffer(size);
|
||||
//Connect and wait until connected
|
||||
start = PseudoTCPBase.Now();
|
||||
StartClocks();
|
||||
start = PseudoTCPBase.now();
|
||||
startClocks();
|
||||
try
|
||||
{
|
||||
Connect();
|
||||
connect();
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -82,13 +82,13 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
// Connect and wait until connected.
|
||||
assert_Connected_wait(kConnectTimeoutMs);
|
||||
|
||||
ScheduleWriteAction(0);
|
||||
scheduleWriteAction(0);
|
||||
|
||||
long transferTout = MaxTransferTime(dummy.length, kMinTransferRate);
|
||||
long transferTout = maxTransferTime(dummy.length, kMinTransferRate);
|
||||
boolean transfferInTime = assert_Disconnected_wait(transferTout);
|
||||
elapsed = PseudoTCPBase.Now() - start;
|
||||
StopClocks();
|
||||
int received = recv_stream.GetBuffered();
|
||||
elapsed = PseudoTCPBase.now() - start;
|
||||
stopClocks();
|
||||
int received = recv_stream.getBuffered();
|
||||
assertEquals("Transfer timeout, transferred: " + received
|
||||
+ " required: " + dummy.length
|
||||
+ " elapsed: "
|
||||
@ -98,7 +98,7 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
assert 2 == send_position.size();
|
||||
assert 2 == recv_position.size();
|
||||
|
||||
int estimated_recv_window = EstimateReceiveWindowSize();
|
||||
int estimated_recv_window = estimateReceiveWindowSize();
|
||||
|
||||
// The difference in consecutive send positions should equal the
|
||||
// receive window size or match very closely. This verifies that receive
|
||||
@ -145,17 +145,17 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
*
|
||||
* @throws IOException
|
||||
*/
|
||||
void ReadUntilIOPending() throws IOException
|
||||
void readUntilIOPending() throws IOException
|
||||
{
|
||||
byte[] block = new byte[getRemoteTcp().getRecvBufferSize() * 2];
|
||||
int position = recv_stream.GetBuffered();
|
||||
int position = recv_stream.getBuffered();
|
||||
int rcvd, total = 0;
|
||||
do
|
||||
{
|
||||
rcvd = RemoteRecv(block, block.length);
|
||||
rcvd = remoteRecv(block, block.length);
|
||||
if (rcvd > 0)
|
||||
{
|
||||
recv_stream.Write(block, rcvd);
|
||||
recv_stream.write(block, rcvd);
|
||||
total += rcvd;
|
||||
position += rcvd;
|
||||
}
|
||||
@ -166,12 +166,12 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
// Disconnect if we have done two transfers.
|
||||
if (recv_position.size() == 2)
|
||||
{
|
||||
Close();
|
||||
OnTcpClosed(getRemoteTcp(), null);
|
||||
close();
|
||||
onTcpClosed(getRemoteTcp(), null);
|
||||
}
|
||||
else
|
||||
{
|
||||
WriteData();
|
||||
writeData();
|
||||
}
|
||||
}
|
||||
|
||||
@ -180,7 +180,7 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
*
|
||||
* @param delay
|
||||
*/
|
||||
void ScheduleWriteAction(long delay)
|
||||
void scheduleWriteAction(long delay)
|
||||
{
|
||||
writeTimer.schedule(new TimerTask()
|
||||
{
|
||||
@ -189,7 +189,7 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
{
|
||||
try
|
||||
{
|
||||
WriteData();
|
||||
writeData();
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -206,27 +206,27 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
*
|
||||
* @throws IOException
|
||||
*/
|
||||
void WriteData() throws IOException
|
||||
void writeData() throws IOException
|
||||
{
|
||||
//writeOpCount++;
|
||||
int tosend;
|
||||
int sent;
|
||||
int totalSent = 0;
|
||||
byte[] block = new byte[getRemoteTcp().getRecvBufferSize() * 2];
|
||||
int position = testDataSize - send_stream.GetBuffered();
|
||||
int position = testDataSize - send_stream.getBuffered();
|
||||
synchronized (getLocalTcp())
|
||||
{
|
||||
do
|
||||
{
|
||||
tosend = send_stream.ReadOffset(block, 0, block.length, 0);
|
||||
tosend = send_stream.readOffset(block, 0, block.length, 0);
|
||||
if (tosend > 0)
|
||||
{
|
||||
sent = LocalSend(block, tosend);
|
||||
UpdateLocalClock();
|
||||
sent = localSend(block, tosend);
|
||||
updateLocalClock();
|
||||
if (sent > 0)
|
||||
{
|
||||
totalSent += sent;
|
||||
send_stream.ConsumeReadData(sent);
|
||||
send_stream.consumeReadData(sent);
|
||||
position += sent;
|
||||
}
|
||||
else
|
||||
@ -244,12 +244,12 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
|
||||
}
|
||||
// Measured with precision according to window scale option used
|
||||
if (totalSent - getRemoteTcp().GetAvailable()
|
||||
if (totalSent - getRemoteTcp().getAvailable()
|
||||
> getShadowedBytes(getRemoteScaleFactor()))
|
||||
{
|
||||
//send buffer was fully filled
|
||||
//waits until it will be received by remote peer
|
||||
while (totalSent - getRemoteTcp().GetAvailable()
|
||||
while (totalSent - getRemoteTcp().getAvailable()
|
||||
> getShadowedBytes(getRemoteScaleFactor())
|
||||
&& !getRemoteTcp().isReceiveBufferFull())
|
||||
{
|
||||
@ -260,8 +260,8 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
{
|
||||
logger.log(Level.FINER,
|
||||
"Waiting... sent: " + totalSent + " avail: "
|
||||
+ getRemoteTcp().GetAvailable() + " buffered not sent: "
|
||||
+ getLocalTcp().GetBytesBufferedNotSent()
|
||||
+ getRemoteTcp().getAvailable() + " buffered not sent: "
|
||||
+ getLocalTcp().getBytesBufferedNotSent()
|
||||
+ " isFull? " + getRemoteTcp().isReceiveBufferFull());
|
||||
}
|
||||
}
|
||||
@ -279,7 +279,7 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
{
|
||||
try
|
||||
{
|
||||
ReadUntilIOPending();
|
||||
readUntilIOPending();
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
@ -293,7 +293,7 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
*
|
||||
* @return estimated receive window size
|
||||
*/
|
||||
int EstimateReceiveWindowSize()
|
||||
int estimateReceiveWindowSize()
|
||||
{
|
||||
return recv_position.get(0);
|
||||
}
|
||||
@ -302,24 +302,24 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
*
|
||||
* @return estimated send window size
|
||||
*/
|
||||
int EstimateSendWindowSize()
|
||||
int estimateSendWindowSize()
|
||||
{
|
||||
return send_position.get(0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void OnTcpReadable(PseudoTCPBase tcp)
|
||||
public void onTcpReadable(PseudoTCPBase tcp)
|
||||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public void OnTcpWriteable(PseudoTCPBase tcp)
|
||||
public void onTcpWriteable(PseudoTCPBase tcp)
|
||||
{
|
||||
}
|
||||
|
||||
void SetLocalOptSndBuf(int len)
|
||||
void setLocalOptSndBuf(int len)
|
||||
{
|
||||
getLocalTcp().SetOption(Option.OPT_SNDBUF, len);
|
||||
getLocalTcp().setOption(Option.OPT_SNDBUF, len);
|
||||
}
|
||||
|
||||
int getRemoteScaleFactor()
|
||||
@ -345,11 +345,11 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test receive window");
|
||||
PseudoTcpTestRecvWindow test = new PseudoTcpTestRecvWindow();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetOptNagling(false);
|
||||
test.SetOptAckDelay(0);
|
||||
test.TestTransfer(1024 * 1000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setOptNagling(false);
|
||||
test.setOptAckDelay(0);
|
||||
test.doTestTransfer(1024 * 1000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -360,13 +360,13 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
//TODO: finish test
|
||||
logger.log(Level.INFO, "Test very small receive window");
|
||||
PseudoTcpTestRecvWindow test = new PseudoTcpTestRecvWindow();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetOptNagling(false);
|
||||
test.SetOptAckDelay(0);
|
||||
test.SetOptSndBuf(900);
|
||||
test.TestTransfer(1024 * 1000);
|
||||
assertEquals(900, test.EstimateSendWindowSize());
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setOptNagling(false);
|
||||
test.setOptAckDelay(0);
|
||||
test.setOptSndBuf(900);
|
||||
test.doTestTransfer(1024 * 1000);
|
||||
assertEquals(900, test.estimateSendWindowSize());
|
||||
}
|
||||
|
||||
/**
|
||||
@ -376,21 +376,21 @@ public class PseudoTcpTestRecvWindow extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test set receive window size");
|
||||
PseudoTcpTestRecvWindow test = new PseudoTcpTestRecvWindow();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetOptNagling(false);
|
||||
test.SetOptAckDelay(0);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setOptNagling(false);
|
||||
test.setOptAckDelay(0);
|
||||
int wndSize = 300000;
|
||||
test.SetRemoteOptRcvBuf(wndSize);
|
||||
test.SetLocalOptSndBuf(wndSize);
|
||||
test.setRemoteOptRcvBuf(wndSize);
|
||||
test.setLocalOptSndBuf(wndSize);
|
||||
int wndScale = test.getRemoteScaleFactor();
|
||||
//logger.log(Level.INFO, "Using scale factor: {0}", wndScale);
|
||||
test.TestTransfer(1024 * 3000);
|
||||
test.doTestTransfer(1024 * 3000);
|
||||
//beacuse there may be situations
|
||||
//when 1 byte may be waiting in send queue
|
||||
//before
|
||||
//scaling factor == 1 not allows to determine exact window size (+-1)
|
||||
assert (wndSize - test.EstimateReceiveWindowSize()
|
||||
assert (wndSize - test.estimateReceiveWindowSize()
|
||||
<= PseudoTcpTestRecvWindow.getShadowedBytes(wndScale));
|
||||
}
|
||||
|
||||
|
||||
@ -52,7 +52,7 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
*
|
||||
* @param size
|
||||
*/
|
||||
public void TestTransfer(int size)
|
||||
public void doTestTransfer(int size)
|
||||
{
|
||||
Thread.setDefaultUncaughtExceptionHandler(this);
|
||||
long start, elapsed;
|
||||
@ -64,11 +64,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
// Prepare the receive stream.
|
||||
recvStream = new ByteArrayOutputStream(size);
|
||||
// Connect and wait until connected.
|
||||
start = PseudoTCPBase.Now();
|
||||
StartClocks();
|
||||
start = PseudoTCPBase.now();
|
||||
startClocks();
|
||||
try
|
||||
{
|
||||
Connect();
|
||||
connect();
|
||||
//assertEquals(0, Connect());
|
||||
}
|
||||
catch (IOException ex)
|
||||
@ -79,10 +79,10 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
assert_Connected_wait(kConnectTimeoutMs);
|
||||
// Sending will start from OnTcpWriteable and complete when all data has
|
||||
// been received.
|
||||
long transferTout = MaxTransferTime(sendData.length, kMinTransferRate);
|
||||
long transferTout = maxTransferTime(sendData.length, kMinTransferRate);
|
||||
boolean transfferInTime = assert_Disconnected_wait(transferTout);
|
||||
elapsed = PseudoTCPBase.Now() - start;
|
||||
StopClocks();
|
||||
elapsed = PseudoTCPBase.now() - start;
|
||||
stopClocks();
|
||||
received = recvStream.size();
|
||||
assertEquals("Transfer timeout, transferred: " + received
|
||||
+ " required: " + sendData.length
|
||||
@ -106,14 +106,14 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
*
|
||||
* @throws IOException
|
||||
*/
|
||||
void ReadData() throws IOException
|
||||
void readData() throws IOException
|
||||
{
|
||||
byte[] block = new byte[kBlockSize];
|
||||
int rcvd;
|
||||
do
|
||||
{
|
||||
rcvd = RemoteRecv(block, block.length);
|
||||
UpdateRemoteClock();
|
||||
rcvd = remoteRecv(block, block.length);
|
||||
updateRemoteClock();
|
||||
if (rcvd != -1)
|
||||
{
|
||||
recvStream.write(block, 0, rcvd);
|
||||
@ -128,7 +128,7 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
* @return true if there's no more data left to write
|
||||
* @throws IOException
|
||||
*/
|
||||
boolean WriteData() throws IOException
|
||||
boolean writeData() throws IOException
|
||||
{
|
||||
int tosend;
|
||||
int sent;
|
||||
@ -139,8 +139,8 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
System.arraycopy(sendData, totalSent, block, 0, tosend);
|
||||
if (tosend > 0)
|
||||
{
|
||||
sent = LocalSend(block, tosend);
|
||||
UpdateLocalClock();
|
||||
sent = localSend(block, tosend);
|
||||
updateLocalClock();
|
||||
if (sent != -1)
|
||||
{
|
||||
totalSent += sent;
|
||||
@ -173,13 +173,13 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
* @param tcp
|
||||
*/
|
||||
@Override
|
||||
public void OnTcpReadable(PseudoTCPBase tcp)
|
||||
public void onTcpReadable(PseudoTCPBase tcp)
|
||||
{
|
||||
if (tcp == getRemoteTcp())
|
||||
{
|
||||
try
|
||||
{
|
||||
ReadData();
|
||||
readData();
|
||||
// TODO: OnTcpClosed() is currently only notified on error -
|
||||
// there is no on-the-wire equivalent of TCP FIN.
|
||||
// So we fake the notification when all the data has been read.
|
||||
@ -193,7 +193,7 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
}
|
||||
if (received == required)
|
||||
{
|
||||
OnTcpClosed(getRemoteTcp(), null);
|
||||
onTcpClosed(getRemoteTcp(), null);
|
||||
}
|
||||
}
|
||||
catch (IOException ex)
|
||||
@ -210,7 +210,7 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
* @param tcp
|
||||
*/
|
||||
@Override
|
||||
public void OnTcpWriteable(PseudoTCPBase tcp)
|
||||
public void onTcpWriteable(PseudoTCPBase tcp)
|
||||
{
|
||||
if (tcp == getLocalTcp())
|
||||
{
|
||||
@ -219,9 +219,9 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
logger.log(Level.FINER, "Flow Control Lifted");
|
||||
try
|
||||
{
|
||||
if (WriteData())
|
||||
if (writeData())
|
||||
{
|
||||
Close();
|
||||
close();
|
||||
}
|
||||
}
|
||||
catch (IOException ex)
|
||||
@ -240,9 +240,9 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.TestTransfer(1000000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.doTestTransfer(1000000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -253,10 +253,10 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send with delay");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetDelay(50);
|
||||
test.TestTransfer(1000000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setDelay(50);
|
||||
test.doTestTransfer(1000000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -267,10 +267,10 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send with loss");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetLoss(10);
|
||||
test.TestTransfer(100000); // less data so test runs faster
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setLoss(10);
|
||||
test.doTestTransfer(100000); // less data so test runs faster
|
||||
}
|
||||
|
||||
/**
|
||||
@ -282,11 +282,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send with delay and loss");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetDelay(50);
|
||||
test.SetLoss(10);
|
||||
test.TestTransfer(100000); // less data so test runs faster
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setDelay(50);
|
||||
test.setLoss(10);
|
||||
test.doTestTransfer(100000); // less data so test runs faster
|
||||
}
|
||||
|
||||
/**
|
||||
@ -297,11 +297,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send with loss and OptNagling off");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetLoss(10);
|
||||
test.SetOptNagling(false);
|
||||
test.TestTransfer(100000); // less data so test runs faster
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setLoss(10);
|
||||
test.setOptNagling(false);
|
||||
test.doTestTransfer(100000); // less data so test runs faster
|
||||
}
|
||||
|
||||
/**
|
||||
@ -312,11 +312,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send with loss and OptAckDelay off");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetLoss(10);
|
||||
test.SetOptAckDelay(0);
|
||||
test.TestTransfer(100000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setLoss(10);
|
||||
test.setOptAckDelay(0);
|
||||
test.doTestTransfer(100000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -326,11 +326,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send with delay and OptNagling off");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetDelay(50);
|
||||
test.SetOptNagling(false);
|
||||
test.TestTransfer(100000); // less data so test runs faster
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setDelay(50);
|
||||
test.setOptNagling(false);
|
||||
test.doTestTransfer(100000); // less data so test runs faster
|
||||
}
|
||||
|
||||
/**
|
||||
@ -340,11 +340,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send with delay and OptAckDelay off");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetDelay(50);
|
||||
test.SetOptAckDelay(0);
|
||||
test.TestTransfer(100000); // less data so test runs faster
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setDelay(50);
|
||||
test.setOptAckDelay(0);
|
||||
test.doTestTransfer(100000); // less data so test runs faster
|
||||
}
|
||||
|
||||
/**
|
||||
@ -354,11 +354,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send - remote no window scale");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetLocalOptRcvBuf(100000);
|
||||
test.DisableRemoteWindowScale();
|
||||
test.TestTransfer(1000000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setLocalOptRcvBuf(100000);
|
||||
test.disableRemoteWindowScale();
|
||||
test.doTestTransfer(1000000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -369,11 +369,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send - local no window scale");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetRemoteOptRcvBuf(100000);
|
||||
test.DisableLocalWindowScale();
|
||||
test.TestTransfer(1000000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setRemoteOptRcvBuf(100000);
|
||||
test.disableLocalWindowScale();
|
||||
test.doTestTransfer(1000000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -383,11 +383,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send - both use window scale");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetRemoteOptRcvBuf(100000);
|
||||
test.SetLocalOptRcvBuf(100000);
|
||||
test.TestTransfer(1000000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setRemoteOptRcvBuf(100000);
|
||||
test.setLocalOptRcvBuf(100000);
|
||||
test.doTestTransfer(1000000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -397,23 +397,23 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send large in flight");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetRemoteOptRcvBuf(100000);
|
||||
test.SetLocalOptRcvBuf(100000);
|
||||
test.SetOptSndBuf(150000);
|
||||
test.TestTransfer(1000000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setRemoteOptRcvBuf(100000);
|
||||
test.setLocalOptRcvBuf(100000);
|
||||
test.setOptSndBuf(150000);
|
||||
test.doTestTransfer(1000000);
|
||||
}
|
||||
|
||||
public void testSendBothUseLargeWindowScale()
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send both use large window scale");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetRemoteOptRcvBuf(1000000);
|
||||
test.SetLocalOptRcvBuf(1000000);
|
||||
test.TestTransfer(10000000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setRemoteOptRcvBuf(1000000);
|
||||
test.setLocalOptRcvBuf(1000000);
|
||||
test.doTestTransfer(10000000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -423,11 +423,11 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send small receive buffer");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetRemoteOptRcvBuf(10000);
|
||||
test.SetLocalOptRcvBuf(10000);
|
||||
test.TestTransfer(1000000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setRemoteOptRcvBuf(10000);
|
||||
test.setLocalOptRcvBuf(10000);
|
||||
test.doTestTransfer(1000000);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -437,10 +437,10 @@ public class PseudoTcpTestTransfer extends PseudoTcpTestBase
|
||||
{
|
||||
//logger.log(Level.INFO, "Test send very small receive buffer");
|
||||
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
|
||||
test.SetLocalMtu(1500);
|
||||
test.SetRemoteMtu(1500);
|
||||
test.SetRemoteOptRcvBuf(100);
|
||||
test.SetLocalOptRcvBuf(100);
|
||||
test.TestTransfer(100000);
|
||||
test.setLocalMtu(1500);
|
||||
test.setRemoteMtu(1500);
|
||||
test.setRemoteOptRcvBuf(100);
|
||||
test.setLocalOptRcvBuf(100);
|
||||
test.doTestTransfer(100000);
|
||||
}
|
||||
}
|
||||
|
||||
@ -31,10 +31,10 @@ public class ByteFifoBufferTest
|
||||
{
|
||||
int expResult = 1000;
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(expResult);
|
||||
assertEquals(expResult, instance.Length());
|
||||
assertEquals(expResult, instance.length());
|
||||
int wSize = 100;
|
||||
instance.Write(getWData(wSize), wSize);
|
||||
int result = instance.Length();
|
||||
instance.write(getWData(wSize), wSize);
|
||||
int result = instance.length();
|
||||
assertEquals(expResult, result);
|
||||
}
|
||||
|
||||
@ -46,11 +46,11 @@ public class ByteFifoBufferTest
|
||||
int count = 1024;
|
||||
byte[] wData = getWData(count);
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(count);
|
||||
instance.Write(wData, count);
|
||||
instance.write(wData, count);
|
||||
|
||||
byte[] readBuff = new byte[count];
|
||||
int expResult = count;
|
||||
int result = instance.Read(readBuff, count);
|
||||
int result = instance.read(readBuff, count);
|
||||
assertEquals(expResult, result);
|
||||
assertArrayEquals(wData, readBuff);
|
||||
|
||||
@ -64,14 +64,14 @@ public class ByteFifoBufferTest
|
||||
int count = 1024;
|
||||
byte[] wData = getWData(count);
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(count);
|
||||
instance.Write(wData, count);
|
||||
instance.write(wData, count);
|
||||
|
||||
byte[] readBuff = new byte[count];
|
||||
int expResult = count / 2;
|
||||
int result = instance.Read(readBuff, count / 2);
|
||||
int result = instance.read(readBuff, count / 2);
|
||||
assertEquals(expResult, result);
|
||||
|
||||
result = instance.Read(readBuff, count / 2, count / 2);
|
||||
result = instance.read(readBuff, count / 2, count / 2);
|
||||
assertEquals(expResult, result);
|
||||
|
||||
assertArrayEquals(wData, readBuff);
|
||||
@ -100,15 +100,15 @@ public class ByteFifoBufferTest
|
||||
int len = 100;
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(len);
|
||||
int expResult = len;
|
||||
int result = instance.GetWriteRemaining();
|
||||
int result = instance.getWriteRemaining();
|
||||
assertEquals(expResult, result);
|
||||
|
||||
int w_size = 23;
|
||||
byte[] w_data = getWData(w_size);
|
||||
instance.Write(w_data, w_size);
|
||||
instance.write(w_data, w_size);
|
||||
|
||||
expResult = len - w_size;
|
||||
result = instance.GetWriteRemaining();
|
||||
result = instance.getWriteRemaining();
|
||||
assertEquals(expResult, result);
|
||||
}
|
||||
|
||||
@ -122,15 +122,15 @@ public class ByteFifoBufferTest
|
||||
int w_len = 100;
|
||||
byte[] w_data = getWData(w_len);
|
||||
|
||||
instance.Write(w_data, w_len);
|
||||
instance.write(w_data, w_len);
|
||||
|
||||
int expResult = w_len;
|
||||
int result = instance.GetBuffered();
|
||||
int result = instance.getBuffered();
|
||||
assertEquals(expResult, result);
|
||||
int consume = 5;
|
||||
expResult = w_len + consume;
|
||||
instance.ConsumeWriteBuffer(consume);
|
||||
result = instance.GetBuffered();
|
||||
instance.consumeWriteBuffer(consume);
|
||||
result = instance.getBuffered();
|
||||
assertEquals(expResult, result);
|
||||
}
|
||||
|
||||
@ -143,11 +143,11 @@ public class ByteFifoBufferTest
|
||||
byte[] data = getWData(len);
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(len);
|
||||
int expResult = len;
|
||||
int result = instance.Write(data, len);
|
||||
int result = instance.write(data, len);
|
||||
assertEquals(expResult, result);
|
||||
|
||||
byte[] read = new byte[len];
|
||||
int readCount = instance.Read(read, len);
|
||||
int readCount = instance.read(read, len);
|
||||
assertEquals(result, readCount);
|
||||
assertArrayEquals(data, read);
|
||||
}
|
||||
@ -158,13 +158,13 @@ public class ByteFifoBufferTest
|
||||
byte[] data = getWData(len);
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(len);
|
||||
int expResult = len / 2;
|
||||
int result = instance.Write(data, 0, len / 2);
|
||||
int result = instance.write(data, 0, len / 2);
|
||||
assertEquals(expResult, result);
|
||||
result = instance.Write(data, len / 2, len / 2);
|
||||
result = instance.write(data, len / 2, len / 2);
|
||||
assertEquals(expResult, result);
|
||||
|
||||
byte[] read = new byte[len];
|
||||
int readCount = instance.Read(read, len);
|
||||
int readCount = instance.read(read, len);
|
||||
assertEquals(len, readCount);
|
||||
assertArrayEquals(data, read);
|
||||
}
|
||||
@ -176,11 +176,11 @@ public class ByteFifoBufferTest
|
||||
{
|
||||
int len = 100;
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(len);
|
||||
instance.ConsumeWriteBuffer(len / 2);
|
||||
instance.ConsumeWriteBuffer(len / 2);
|
||||
instance.consumeWriteBuffer(len / 2);
|
||||
instance.consumeWriteBuffer(len / 2);
|
||||
try
|
||||
{
|
||||
instance.ConsumeWriteBuffer(1);
|
||||
instance.consumeWriteBuffer(1);
|
||||
fail();
|
||||
}
|
||||
catch (BufferOverflowException e)
|
||||
@ -188,9 +188,9 @@ public class ByteFifoBufferTest
|
||||
}
|
||||
|
||||
instance = new ByteFifoBuffer(len);
|
||||
instance.ConsumeWriteBuffer(95);
|
||||
instance.ConsumeReadData(40);
|
||||
instance.ConsumeWriteBuffer(20);
|
||||
instance.consumeWriteBuffer(95);
|
||||
instance.consumeReadData(40);
|
||||
instance.consumeWriteBuffer(20);
|
||||
|
||||
}
|
||||
|
||||
@ -203,14 +203,14 @@ public class ByteFifoBufferTest
|
||||
int new_size = 200;
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(old_size);
|
||||
boolean expResult = true;
|
||||
instance.Write(getWData(old_size), old_size);
|
||||
boolean result = instance.SetCapacity(new_size);
|
||||
instance.write(getWData(old_size), old_size);
|
||||
boolean result = instance.setCapacity(new_size);
|
||||
assertEquals(expResult, result);
|
||||
|
||||
expResult = false;
|
||||
instance.ResetWritePosition();
|
||||
instance.Write(getWData(new_size), new_size);
|
||||
result = instance.SetCapacity(old_size);
|
||||
instance.resetWritePosition();
|
||||
instance.write(getWData(new_size), new_size);
|
||||
result = instance.setCapacity(old_size);
|
||||
assertEquals(expResult, result);
|
||||
|
||||
}
|
||||
@ -222,12 +222,12 @@ public class ByteFifoBufferTest
|
||||
{
|
||||
int lCount = 100;
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(lCount);
|
||||
instance.Write(getWData(lCount), lCount);
|
||||
instance.ConsumeReadData(lCount / 2);
|
||||
instance.ConsumeReadData(lCount / 2);
|
||||
instance.write(getWData(lCount), lCount);
|
||||
instance.consumeReadData(lCount / 2);
|
||||
instance.consumeReadData(lCount / 2);
|
||||
try
|
||||
{
|
||||
instance.ConsumeReadData(1);
|
||||
instance.consumeReadData(1);
|
||||
fail();
|
||||
}
|
||||
catch (BufferUnderflowException e)
|
||||
@ -248,9 +248,9 @@ public class ByteFifoBufferTest
|
||||
int offset = 0;
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(len);
|
||||
int expResult = len;
|
||||
instance.Write(src_buff, len);
|
||||
instance.write(src_buff, len);
|
||||
int result =
|
||||
instance.ReadOffset(dst_buff, dst_buff_offset, len, offset);
|
||||
instance.readOffset(dst_buff, dst_buff_offset, len, offset);
|
||||
assertEquals(expResult, result);
|
||||
assertArrayEquals(dst_buff, src_buff);
|
||||
|
||||
@ -267,26 +267,26 @@ public class ByteFifoBufferTest
|
||||
byte[] data = new byte[dataLen];
|
||||
int nOffset = 10;
|
||||
ByteFifoBuffer instance = new ByteFifoBuffer(len);
|
||||
int result = instance.WriteOffset(srcData, dataLen, nOffset);
|
||||
int readCount = instance.ReadOffset(data, 0, dataLen, nOffset);
|
||||
int result = instance.writeOffset(srcData, dataLen, nOffset);
|
||||
int readCount = instance.readOffset(data, 0, dataLen, nOffset);
|
||||
assertEquals(result, readCount);
|
||||
assertArrayEquals(srcData, data);
|
||||
|
||||
byte[] halfFilled = new byte[dataLen * 2];
|
||||
System.arraycopy(srcData, 0, halfFilled, dataLen, dataLen);
|
||||
byte[] halfFilledRead = new byte[dataLen * 2];
|
||||
instance.ReadOffset(halfFilledRead, dataLen, dataLen, nOffset);
|
||||
instance.readOffset(halfFilledRead, dataLen, dataLen, nOffset);
|
||||
assertArrayEquals(halfFilled, halfFilledRead);
|
||||
|
||||
// case when w_pos+offset exceeds current backing array length
|
||||
instance = new ByteFifoBuffer(len);
|
||||
instance.Write(srcData, dataLen);
|
||||
instance.Write(srcData, dataLen / 2);// current writePos = 150
|
||||
instance.Read(data, dataLen);// curretn readPos = 100
|
||||
instance.WriteOffset(srcData, dataLen, 50);
|
||||
instance.write(srcData, dataLen);
|
||||
instance.write(srcData, dataLen / 2);// current writePos = 150
|
||||
instance.read(data, dataLen);// curretn readPos = 100
|
||||
instance.writeOffset(srcData, dataLen, 50);
|
||||
|
||||
instance = new ByteFifoBuffer(61440);
|
||||
instance.WriteOffset(getWData(1384), 1384, 31832);
|
||||
instance.writeOffset(getWData(1384), 1384, 31832);
|
||||
|
||||
}
|
||||
|
||||
@ -300,19 +300,19 @@ public class ByteFifoBufferTest
|
||||
int read = 0;
|
||||
do
|
||||
{
|
||||
int wrRemaining = instance.GetWriteRemaining();
|
||||
int wrRemaining = instance.getWriteRemaining();
|
||||
if (wrRemaining > 0 && written < wrData.length)
|
||||
{
|
||||
int wrCount = instance.WriteOffset(wrData, wrRemaining, 0);
|
||||
instance.ConsumeWriteBuffer(wrCount);
|
||||
int wrCount = instance.writeOffset(wrData, wrRemaining, 0);
|
||||
instance.consumeWriteBuffer(wrCount);
|
||||
written += wrCount;
|
||||
}
|
||||
int readAvailable = instance.GetBuffered();
|
||||
int readAvailable = instance.getBuffered();
|
||||
if (readAvailable > 0)
|
||||
{
|
||||
int rCount =
|
||||
instance.ReadOffset(readBuff, read, readAvailable, 0);
|
||||
instance.ConsumeReadData(rCount);
|
||||
instance.readOffset(readBuff, read, readAvailable, 0);
|
||||
instance.consumeReadData(rCount);
|
||||
read += rCount;
|
||||
}
|
||||
}
|
||||
@ -336,9 +336,9 @@ public class ByteFifoBufferTest
|
||||
byte[] Cread = getWData(Clen);
|
||||
byte[] Dread = getWData(Dlen);
|
||||
|
||||
fifo.WriteOffset(A, Alen, 0);
|
||||
fifo.ConsumeWriteBuffer(Alen);
|
||||
fifo.ReadOffset(Aread, 0, Alen, 0);
|
||||
fifo.writeOffset(A, Alen, 0);
|
||||
fifo.consumeWriteBuffer(Alen);
|
||||
fifo.readOffset(Aread, 0, Alen, 0);
|
||||
assertArrayEquals(A, Aread);
|
||||
}
|
||||
}
|
||||
|
||||
@ -284,7 +284,7 @@ public class IcePseudoTcp
|
||||
public static void main(String[] args) throws Throwable
|
||||
{
|
||||
startTime = System.currentTimeMillis();
|
||||
|
||||
|
||||
int localPort = 7999;
|
||||
int remotePort = 6000;
|
||||
|
||||
@ -376,12 +376,14 @@ public class IcePseudoTcp
|
||||
{
|
||||
logger.log(Level.INFO,
|
||||
"Local pseudotcp is using: "
|
||||
+ dgramSocket.getLocalSocketAddress());
|
||||
PseudoTcpSocketImpl socket = new PseudoTcpSocketImpl(
|
||||
1073741824, dgramSocket);
|
||||
+ dgramSocket.getLocalSocketAddress()+dgramSocket);
|
||||
|
||||
PseudoTcpSocket socket = new PseudoTcpSocketFactory().
|
||||
createSocket(dgramSocket);
|
||||
socket.setConversationID(1073741824);
|
||||
socket.setMTU(1500);
|
||||
socket.setDebugName("L");
|
||||
socket.Accept(5000);
|
||||
socket.accept(5000);
|
||||
byte[] buffer = new byte[TEST_BYTES_COUNT];
|
||||
int read = 0;
|
||||
while (read != TEST_BYTES_COUNT)
|
||||
@ -423,13 +425,14 @@ public class IcePseudoTcp
|
||||
"Remote pseudotcp is using: " +
|
||||
dgramSocket.getLocalSocketAddress()
|
||||
+" and will comunicate with: " + peerAddr);
|
||||
PseudoTcpSocketImpl socket = new PseudoTcpSocketImpl(
|
||||
1073741824, dgramSocket);
|
||||
PseudoTcpSocket socket = new PseudoTcpSocketFactory().
|
||||
createSocket(dgramSocket);
|
||||
socket.setConversationID(1073741824);
|
||||
socket.setMTU(1500);
|
||||
socket.setDebugName("R");
|
||||
long start, end;
|
||||
start = System.currentTimeMillis();
|
||||
socket.Connect(peerAddr, 5000);
|
||||
socket.connect(peerAddr, 5000);
|
||||
byte[] buffer = new byte[TEST_BYTES_COUNT];
|
||||
socket.getOutputStream().write(buffer);
|
||||
socket.getOutputStream().flush();
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user