public void run() {
while (true) {
LinkedList<PacketCallbackStruct> list = null;
try {
queuedPacketCallbacksLock.lock();
try {
queuedPacketCallbacksNotEmpty.await();
} catch (Exception e) {
Log.error(
"RDPServer.PacketCallbackThread: queuedPacketCallbacksNotEmpty.await() caught exception "
+ e.getMessage());
}
list = queuedPacketCallbacks;
queuedPacketCallbacks = new LinkedList<PacketCallbackStruct>();
} finally {
queuedPacketCallbacksLock.unlock();
}
if (Log.loggingNet)
Log.net("RDPServer.PacketCallbackThread: Got " + list.size() + " queued packets");
for (PacketCallbackStruct pcs : list) {
try {
callbackProcessPacket(pcs.cb, pcs.con, pcs.packet);
} catch (Exception e) {
Log.exception("RDPServer.PacketCallbackThread: ", e);
}
}
}
}
public void addFinishedTarget(Target target) {
// 向finishedTargets队列中加入一个任务
synchronized (finishedTargets) {
finishedTargets.notify();
finishedTargets.add(target);
}
}
public ShowComp() throws InterruptedException, IOException {
super("CONNECTED COMPUTERS");
int x = 0, d = 20;
mb = new JMenuBar();
File = new JMenu("File");
mb.add(File);
exit = new JMenuItem("Exit");
exit.addActionListener(this);
File.add(exit);
ta = new JTextArea();
ta.setBounds(20, 30, 315, 470);
ta.setEditable(false);
add(ta);
setJMenuBar(mb);
sel = new JLabel("The connected computers are..");
sel.setBounds(15, 5, 300, 30);
add(sel);
b1 = new JButton("<< BACK");
b1.setBounds(140, 510, 100, 30);
b1.setToolTipText("Back to main page");
b1.addActionListener(this);
add(b1);
setLayout(null);
while (x < 360) {
x = x + d;
setBounds(675, 50, x, 600);
this.show();
}
// setVisible(true);
String s = "192.168.0.", temp = null;
Printer printer = new Printer();
printer.start();
Connector connector = new Connector(printer);
connector.start();
LinkedList targets = new LinkedList();
for (int i = 1; i <= 255; i++) {
temp = s + Integer.toString(i);
Target t = new Target(temp);
targets.add(t);
connector.add(t);
}
Thread.sleep(2000);
connector.shutdown();
connector.join();
for (Iterator i = targets.iterator(); i.hasNext(); ) {
Target t = (Target) i.next();
if (!t.shown) t.show();
}
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
}
public void run() {
try {
for (; ; ) {
Target t = null;
synchronized (pending) {
while (pending.size() == 0) pending.wait();
t = (Target) pending.removeFirst();
}
t.show();
}
} catch (InterruptedException x) {
return;
}
}
public void printFinishedTargets() {
// 打印finisedTargets队列中的任务
try {
for (; ; ) {
Target target = null;
synchronized (finishedTargets) {
while (finishedTargets.size() == 0) finishedTargets.wait();
target = (Target) finishedTargets.removeFirst();
}
target.show();
}
} catch (InterruptedException x) {
return;
}
}
public void addTarget(Target target) {
// 向targets队列中加入一个任务
SocketChannel socketChannel = null;
try {
socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(target.address);
target.channel = socketChannel;
target.connectStart = System.currentTimeMillis();
synchronized (targets) {
targets.add(target);
}
selector.wakeup();
} catch (Exception x) {
if (socketChannel != null) {
try {
socketChannel.close();
} catch (IOException xx) {
}
}
target.failure = x;
addFinishedTarget(target);
}
}
void add(Target t) {
SocketChannel sc = null;
try {
sc = SocketChannel.open();
sc.configureBlocking(false);
boolean connected = sc.connect(t.address);
t.channel = sc;
t.connectStart = System.currentTimeMillis();
if (connected) {
t.connectFinish = t.connectStart;
sc.close();
printer.add(t);
} else {
synchronized (pending) {
pending.add(t);
}
sel.wakeup();
}
} catch (IOException x) {
if (sc != null) {
try {
sc.close();
} catch (IOException xx) {
}
}
t.failure = x;
printer.add(t);
}
}
void processPendingTargets() throws IOException {
synchronized (pending) {
while (pending.size() > 0) {
Target t = (Target) pending.removeFirst();
try {
t.channel.register(sel, SelectionKey.OP_CONNECT, t);
} catch (IOException x) {
t.channel.close();
t.failure = x;
printer.add(t);
}
}
}
}
public void sendMessage(Address address, byte[] message) throws java.io.IOException {
Socket s = null;
SocketEntry entry = (SocketEntry) sockets.get(address);
if (logger.isDebugEnabled()) {
logger.debug("Looking up connection for destination '" + address + "' returned: " + entry);
logger.debug(sockets.toString());
}
if (entry != null) {
s = entry.getSocket();
}
if ((s == null) || (s.isClosed())) {
if (logger.isDebugEnabled()) {
logger.debug("Socket for address '" + address + "' is closed, opening it...");
}
SocketChannel sc = null;
try {
// Open the channel, set it to non-blocking, initiate connect
sc = SocketChannel.open();
sc.configureBlocking(false);
sc.connect(
new InetSocketAddress(
((TcpAddress) address).getInetAddress(), ((TcpAddress) address).getPort()));
s = sc.socket();
entry = new SocketEntry((TcpAddress) address, s);
entry.addMessage(message);
sockets.put(address, entry);
synchronized (pending) {
pending.add(entry);
}
selector.wakeup();
logger.debug("Trying to connect to " + address);
} catch (IOException iox) {
logger.error(iox);
throw iox;
}
} else {
entry.addMessage(message);
synchronized (pending) {
pending.add(entry);
}
selector.wakeup();
}
}
public void registerTargets() {
// 取出targets队列中的任务，向Selector注册连接就绪事件
synchronized (targets) {
while (targets.size() > 0) {
Target target = (Target) targets.removeFirst();
try {
target.channel.register(selector, SelectionKey.OP_CONNECT, target);
} catch (IOException x) {
try {
target.channel.close();
} catch (IOException e) {
e.printStackTrace();
}
target.failure = x;
addFinishedTarget(target);
}
}
}
}
private void processPending() {
synchronized (pending) {
while (pending.size() > 0) {
SocketEntry entry = (SocketEntry) pending.removeFirst();
try {
// Register the channel with the selector, indicating
// interest in connection completion and attaching the
// target object so that we can get the target back
// after the key is added to the selector's
// selected-key set
if (entry.getSocket().isConnected()) {
entry.getSocket().getChannel().register(selector, SelectionKey.OP_WRITE, entry);
} else {
entry.getSocket().getChannel().register(selector, SelectionKey.OP_CONNECT, entry);
}
} catch (IOException iox) {
logger.error(iox);
// Something went wrong, so close the channel and
// record the failure
try {
entry.getSocket().getChannel().close();
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
entry.getPeerAddress(),
TransportStateEvent.STATE_CLOSED,
iox);
fireConnectionStateChanged(e);
} catch (IOException ex) {
logger.error(ex);
}
lastError = iox;
}
}
}
}
void add(Target t) {
synchronized (pending) {
pending.add(t);
pending.notify();
}
}