// Test the connected case to see if PUE is thrown
public static void test2() throws Exception {
setup();
server.configureBlocking(true);
server.connect(isa);
server.configureBlocking(false);
outBuf.rewind();
server.write(outBuf);
server.receive(inBuf);
client.close();
Thread.sleep(2000);
outBuf.rewind();
try {
server.write(outBuf);
Thread.sleep(2000);
inBuf.clear();
server.read(inBuf);
if (onSolarisOrLinux()) throw new Exception("Expected PUE not thrown");
} catch (PortUnreachableException pue) {
System.err.println("received PUE");
}
server.close();
}
public long openUdpSocket(InetSocketAddress address) throws IOException {
// TODO, don't throw an exception out of here.
DatagramChannel dg = DatagramChannel.open();
dg.configureBlocking(false);
dg.socket().bind(address);
long b = createBinding();
EventableChannel ec = new EventableDatagramChannel(dg, b, mySelector);
dg.register(mySelector, SelectionKey.OP_READ, ec);
Connections.put(b, ec);
return b;
}
public static void main(String args[]) throws Exception {
final int ENOUGH_SIZE = 1024;
final int SMALL_SIZE = 4;
boolean isBlocked = true;
int size = ENOUGH_SIZE;
if (args.length > 0) {
int opt = Integer.parseInt(args[0]);
switch (opt) {
case 1:
isBlocked = true;
size = ENOUGH_SIZE;
break;
case 2:
isBlocked = true;
size = SMALL_SIZE;
break;
case 3:
isBlocked = false;
size = ENOUGH_SIZE;
break;
case 4:
isBlocked = false;
size = SMALL_SIZE;
break;
}
}
DatagramChannel channel = DatagramChannel.open();
channel.configureBlocking(isBlocked);
ByteBuffer buffer = ByteBuffer.allocate(size);
DatagramSocket socket = channel.socket();
SocketAddress localAddr = new InetSocketAddress(8000);
socket.bind(localAddr);
while (true) {
System.out.println("开始接收数据报");
SocketAddress remoteAddr = channel.receive(buffer);
if (remoteAddr == null) {
System.out.println("没有接收到数据报");
} else {
buffer.flip();
System.out.println("接收到的数据报的大小为" + buffer.remaining());
}
Thread.sleep(500);
}
}
private void init() throws IOException {
messageBuffer = new ArrayList();
receiveBuffer = ByteBuffer.allocate(CAPACITY);
sendBuffer = ByteBuffer.allocate(CAPACITY);
buf = new byte[CAPACITY];
channel = DatagramChannel.open();
channel.configureBlocking(false);
InetAddress host = null;
if (getAddress() != null) {
host = InetAddress.getByAddress(getAddress().getBytes());
}
channel.socket().bind(new InetSocketAddress(host, getPort()));
channel.socket().setReceiveBufferSize(CAPACITY);
certifier = new MessageCertifier(this);
extractor = new MessageExtractor(this);
}
public static void setup() throws Exception {
client = DatagramChannel.open();
server = DatagramChannel.open();
client.socket().bind((SocketAddress) null);
server.socket().bind((SocketAddress) null);
client.configureBlocking(false);
server.configureBlocking(false);
InetAddress address = InetAddress.getLocalHost();
int port = client.socket().getLocalPort();
isa = new InetSocketAddress(address, port);
}
// Since this is not connected no PortUnreachableException should be thrown
public static void test1() throws Exception {
setup();
server.send(outBuf, isa);
server.receive(inBuf);
client.close();
outBuf.rewind();
server.send(outBuf, isa);
server.receive(inBuf);
server.close();
}
protected synchronized Message receiveMessage() throws IOException {
if (messageBuffer.size() > 0) {
Message m = (Message) messageBuffer.get(0);
messageBuffer.remove(0);
return m;
}
try {
InetSocketAddress remoteAddress = (InetSocketAddress) channel.receive(receiveBuffer);
if (remoteAddress != null) {
int len = receiveBuffer.position();
receiveBuffer.rewind();
receiveBuffer.get(buf, 0, len);
try {
IP address = IP.fromInetAddress(remoteAddress.getAddress());
int port = remoteAddress.getPort();
extractor.appendData(buf, 0, len, new SocketDescriptor(address, port));
receiveBuffer.clear();
extractor.updateAvailableMessages();
return extractor.nextMessage();
} catch (EOFException exc) {
exc.printStackTrace();
System.err.println(buf.length + ", " + len);
} catch (InvocationTargetException exc) {
exc.printStackTrace();
} catch (IllegalAccessException exc) {
exc.printStackTrace();
} catch (InstantiationException exc) {
exc.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvalidCompressionMethodException e) {
e.printStackTrace();
}
}
} catch (ClosedChannelException exc) {
if (isKeepAlive()) {
throw exc;
}
}
return null;
}
public void resendMessage(Message message, IP remoteAddress, int remotePort) throws IOException {
if (remoteAddress == null) remoteAddress = IP.getLocalHost();
message.setSentStamp(getConvertedTime(remoteAddress, remotePort));
message.setMessageServer(this);
try {
sendBuffer.clear();
sendBuffer.put(extractor.convertMessage(message));
sendBuffer.flip();
channel.send(sendBuffer, new InetSocketAddress(remoteAddress.toString(), remotePort));
message.setRemoteAddress(remoteAddress);
message.setRemotePort(remotePort);
messageSent(message);
} catch (IllegalAccessException exc) {
throw new RuntimeException(exc);
} catch (IllegalArgumentException exc) {
throw new RuntimeException(exc);
} catch (InvocationTargetException exc) {
throw new RuntimeException(exc);
}
}
protected void closeChannel() {
try {
channel.close();
} catch (Exception exc) {
}
}
// Check if the datagramsocket adaptor can send with a packet
// that has not been initialized with an address; the legacy
// datagram socket will send in this case
private static void test2() throws Exception {
DatagramChannel sndChannel = DatagramChannel.open();
sndChannel.socket().bind(null);
InetSocketAddress sender =
new InetSocketAddress(InetAddress.getLocalHost(), sndChannel.socket().getLocalPort());
DatagramChannel rcvChannel = DatagramChannel.open();
rcvChannel.socket().bind(null);
InetSocketAddress receiver =
new InetSocketAddress(InetAddress.getLocalHost(), rcvChannel.socket().getLocalPort());
rcvChannel.connect(sender);
sndChannel.connect(receiver);
byte b[] = "hello".getBytes("UTF-8");
DatagramPacket pkt = new DatagramPacket(b, b.length);
sndChannel.socket().send(pkt);
ByteBuffer bb = ByteBuffer.allocate(256);
rcvChannel.receive(bb);
bb.flip();
CharBuffer cb = Charset.forName("US-ASCII").newDecoder().decode(bb);
if (!cb.toString().startsWith("h")) throw new RuntimeException("Test failed");
// Check that the pkt got set with the target address;
// This is legacy behavior
if (!pkt.getSocketAddress().equals(receiver)) throw new RuntimeException("Test failed");
rcvChannel.close();
sndChannel.close();
}
// Check if DatagramChannel.send while connected can include
// address without throwing
private static void test1() throws Exception {
DatagramChannel sndChannel = DatagramChannel.open();
sndChannel.socket().bind(null);
InetSocketAddress sender =
new InetSocketAddress(InetAddress.getLocalHost(), sndChannel.socket().getLocalPort());
DatagramChannel rcvChannel = DatagramChannel.open();
rcvChannel.socket().bind(null);
InetSocketAddress receiver =
new InetSocketAddress(InetAddress.getLocalHost(), rcvChannel.socket().getLocalPort());
rcvChannel.connect(sender);
sndChannel.connect(receiver);
ByteBuffer bb = ByteBuffer.allocate(256);
bb.put("hello".getBytes());
bb.flip();
int sent = sndChannel.send(bb, receiver);
bb.clear();
rcvChannel.receive(bb);
bb.flip();
CharBuffer cb = Charset.forName("US-ASCII").newDecoder().decode(bb);
if (!cb.toString().startsWith("h")) throw new RuntimeException("Test failed");
rcvChannel.close();
sndChannel.close();
}
