Hello i have a problem in my UDP implementation in java. I supose to make the program read two files which is itc-1 and itc-2 but my program only read the itc-1 and function right actully but when i run it and read itc-2 file it crached i don't know where is the problem!! here is my code below:
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class Client {
public static final String MESSAGETONODE = "message to node";
public static final String CHECK = "checking message";
public static final String ACK = "ACK message";
public static final String CHECKMESSAGE = "Are you alive?";
public static final String ACKMESSAGE = "I'm okay";
public static final String DEATHNOTE = "Death note";
public static final String BIRTHCERT = "Birth cert";
public static ArrayList<Node> linkNode = new ArrayList<Node>();
private static int sourceNode;
static int destPort;
static int destNode;
private int neighborCounts;
private static int sourcePort;
static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static BlockingQueue<QueueMessage> blockingQueue;
private static ArrayList<BlockingQueue<QueueMessage>> ACKQueue;
private static NetworkLayer networkLayer;
public Client(int nodeID, String itcFile) throws IOException {
blockingQueue = new ArrayBlockingQueue<>(100);
ACKQueue = new ArrayList<>();
assignFromFile(itcFile);
networkLayer = new NetworkLayer(itcFile, nodeID, linkNode);
neighborCounts = networkLayer.getNeighborsCount();
for (int i = 0; i < neighborCounts; ++i) ACKQueue.add(new ArrayBlockingQueue<>(100));
// networkLayer.displayRoutingTable();
System.out.println(nodeID + " " + itcFile);
sourceNode = nodeID;
// Gets the port number of the node you initially set
for (Node n : linkNode) {
if (n.getNodeID() == nodeID)
sourcePort = n.getPortNumber();
}
startServer(sourcePort);
startSender();
messagePrompt(reader, blockingQueue);
for (int i = 0; i < neighborCounts; ++i)
networkLayer.checkNeighbors(blockingQueue, ACKQueue.get(i), i);
}
public void messagePrompt(BufferedReader reader, BlockingQueue<QueueMessage> blockingQueue) {
(new Thread(() -> {
while (true) {
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter message: ");
String message = null;
try {
message = inFromUser.readLine();
} catch (IOException e) {
e.printStackTrace();
}
//prompts for dest node to set for later
System.out.print("Enter destination node: ");
int destNode = 0;
try {
destNode = Integer.parseInt(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
// TODO this is supposed to be wrapped in headers to avoid what I'm doing in this next line
message = MESSAGETONODE + " " + destNode + " " + sourceNode + " " + message;
blockingQueue.add(new QueueMessage(Client.MESSAGETONODE, message, destNode, sourceNode, getTimeInMS()));
}
})).start();
}
public static void assignFromFile(String itcFile) throws FileNotFoundException {
// reads from the file you initially set in the running prompt
Scanner docScan = new Scanner(new File(itcFile + ".txt"));
String data;
// final Node NODE;
// reads each line of the text files
while (docScan.hasNextLine()) {
data = docScan.nextLine();
// System.out.println(data);
String[] word = data.split(" ");
// sets each variable of the documents to a Node
final Node NODE = new Node(Integer.parseInt(word[0]), word[1], Integer.parseInt(word[2]),
Integer.parseInt(word[3]), Integer.parseInt(word[4]), Integer.parseInt(word[5]));
linkNode.add(NODE);
}
}
public static void startSender() {
(new Thread() {
@Override
public void run() {
try {
// Gets input from user
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
// Sets a socket that connects to the port of the nodeID you set in the beginning prompt
// Socket s = new Socket("localhost", sourcePort);
for (Node n : linkNode) {
if (destNode == n.getNodeID())
destPort = n.getPortNumber();
}
DatagramSocket socket = new DatagramSocket();
// System.out.println("PORT = " + socket.getLocalPort());
// linkNode.get(sourceNode).setSenderPortNumber(socket.getPort());
// System.out.println(destPort);
//creates a writer that writes out to the socket that you set
//BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
// gets input from user and sends it to the buffered reader
// System.out.print("Enter message: ");
// String message = inFromUser.readLine();
//prompts for dest node to set for later
// System.out.print("Enter destination node: ");
// int destNode = Integer.parseInt(reader.readLine());
// int destPort = 0;
// for (Node n : linkNode) {
// if (destNode == n.getNodeID()) {
// destPort = n.getPortNumber();
// }
// }
// System.out.println("PORT " + destPort);
DatagramPacket msg = new DatagramPacket(new byte[0], 0, InetAddress.getByName("localhost"), destPort);
// int length;
// message = message + "\n";
// length = message.length();
// byte[] bbuf = message.getBytes();
// msg.setData(bbuf);
// msg.setLength(length);
// try {
// socket.send(msg);
// } catch (IOException ioe) {
// System.err.println("send() failed");
// return;
// }
while (true) {
/// takes the next available message from blockingQueue
QueueMessage queueMessage = blockingQueue.take();
String type = queueMessage.getMessageType();
// System.out.println("TYPE TO BE SENT IS " + type);
// System.out.println(type + " " + queueMessage.getMessage());
// System.out.println("DEBUG");
// for (Node n : linkNode) System.out.println(n.getSenderPortNumber());
// TODO: this is the method that executes the function of transport layer, supposed to
// return bbuf array
// byte[] bbuf = transportLayer.process(queueMessage);
byte[] bbuf;
if (type != null) {
// String message = queueMessage.getMessage();
// System.out.println(message);
int destNode = queueMessage.getDestinationNID();
// System.out.println(destNode);
int destPort = networkLayer.routeMessage(queueMessage);
if (destPort == NetworkLayer.INF) continue;
// don't need the following piece of code since the above is present
// for (Node n : linkNode) {
// if (destNode == n.getNodeID()) {
// destPort = n.getPortNumber();
// }
// }
if (queueMessage.getMessage() == null) break;
// message = message + "\n";
// int length = message.length();
TransportLayer transportLayer = new TransportLayer(queueMessage.getSourceNID(),
networkLayer.getNodePort(queueMessage.getSourceNID()),
queueMessage.getDestinationNID(), destPort, queueMessage.getMessage());
// System.out.println("GET");
// System.out.println("BEFORE " + queueMessage.getMessage());
String message = transportLayer.sendData(queueMessage.getDestinationNID(),
queueMessage.getMessage());
// System.out.println("AFTER " + message);
transportLayer.setMessage(message);
bbuf = message.getBytes();
msg.setData(bbuf);
// System.out.println("HERE IS THE MESSAGE " + queueMessage.getMessage());
msg.setLength(message.length());
msg.setPort(destPort);
try {
socket.send(msg);
} catch (IOException ioe) {
// System.out.println(queueMessage.getMessage());
// System.out.println(queueMessage.getMessage().length());
// System.out.println("DESTPORT" + destPort);
// System.err.println(ioe);
// ioe.printStackTrace();
System.err.println("send() failed");
return;
}
}
// try {
// System.out.print("Enter message: ");
// message = inFromUser.readLine();
//
// //prompts for dest node to set for later
// System.out.print("Enter destination node: ");
// destNode = Integer.parseInt(reader.readLine());
//
// destPort = 0;
//
// for (Node n : linkNode) {
// if (destNode == n.getNodeID()) {
// destPort = n.getPortNumber();
// }
// }
// } catch (IOException ioe) {
// System.err.println("readline() failed");
// }
//
//
// if (message == null) break;
//
// message = message + "\n";
// length = message.length();
// bbuf = message.getBytes();
//
// msg.setData(bbuf);
// msg.setLength(length);
//
// try {
// socket.send(msg);
// } catch (IOException ioe) {
// System.err.println("send() failed");
// return;
// }
}
socket.close();
/*while (true) {
// Will write out your message and wait for input
out.write(message);
out.newLine();
out.flush();
Thread.sleep(200);
}*/
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
public static void startServer(int port) {
// creates a server on the port of the nodeID you set in the beginning prompt
//ss = new ServerSocket(port);
// System.out.println("MESSAGE RECEIVED IS " + str);
// TODO: Implement the function getSenderIDFromMsg that takes the DatagramaPakcet msg as an
// argument and gives back the node ID of the sender
// System.out.println("port = " + msg.getPort());
// System.out.println("ACKMESSAGE");
// System.out.println("STR LENGTH = " + str.length());
// System.out.println("RECEIVED ACKMESSAGE FROM NODE + " + senderNode + " INDEX " + neighborIndex);
// System.out.println("MESSAGE RECEIVED IS " + str);
// System.out.println("RECEIVED DEATHNOTE " + nodeID);
// networkLayer.displayRoutingTable();
// System.out.println("RECEIVED BIRTHCERT " + nodeID);
// networkLayer.displayRoutingTable();
// accepts that socket port and runs the server
//Socket s = ss.accept();
// gets input from the client
/*BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;
// Reads the input from the client
line = in.readLine();
//displays the client and the local IP/port for debugging purposes
System.out.println(line);
System.out.println(s.getLocalSocketAddress());
} catch (IOException e) {
e.printStackTrace();
}*/
new Thread() {
@Override
public void run() {
ServerSocket ss;
ServerSocket destSocket;
DatagramSocket dSocket;
int bufSize = 512;
try {
// creates a server on the port of the nodeID you set in the beginning prompt
//ss = new ServerSocket(port);
dSocket = new DatagramSocket(port);
} catch (SocketException se) {
System.err.println("cannot create socket with port: " + port);
return;
}
try {
dSocket.setSoTimeout(15000);
} catch (SocketException se) {
System.err.println("Socekt exception: timeout not set");
}
DatagramPacket msg = new DatagramPacket(new byte[bufSize], bufSize);
while (true) {
try {
msg.setLength(bufSize);
dSocket.receive(msg);
} catch (SocketTimeoutException ste) {
System.err.println("response timed out");
continue;
} catch (IOException ioe) {
System.err.println("Bad receive");
break;
}
String str = new String(msg.getData(), 0, msg.getLength());
// System.out.println("MESSAGE RECEIVED IS " + str);
// System.out.println(str);
TransportLayer transportLayer = new TransportLayer();
transportLayer.setMessage(str);
int checksum = transportLayer.receiveChecksum();
transportLayer.receiveHeaders();
str = transportLayer.getMessage();
// System.out.println("STr IS " + str);
if (str.startsWith(CHECKMESSAGE)) {
// TODO: Implement the function getSenderIDFromMsg that takes the DatagramaPakcet msg as an
// argument and gives back the node ID of the sender
int senderNode = Integer.parseInt(str.substring(CHECKMESSAGE.length() + 1));
blockingQueue.add(new QueueMessage(ACK, ACKMESSAGE + " " + sourceNode, senderNode,
sourceNode, getTimeInMS()));
// System.out.println("port = " + msg.getPort());
} else if (str.startsWith(ACKMESSAGE)) {
// System.out.println("ACKMESSAGE");
// System.out.println("STR LENGTH = " + str.length());
int senderNode = Integer.parseInt(str.substring(ACKMESSAGE.length() + 1));
int neighborIndex = networkLayer.getNeighborIndex(senderNode);
// System.out.println("RECEIVED ACKMESSAGE FROM NODE + " + senderNode + " INDEX " + neighborIndex);
ACKQueue.get(neighborIndex).add(new QueueMessage(ACK, ACKMESSAGE, 0, sourceNode,
getTimeInMS()));
} else {
if (str.startsWith(MESSAGETONODE)) {
Scanner stringstream = new Scanner(str);
String type, actualMessage;
int dest, src;
// System.out.println("MESSAGE RECEIVED IS " + str);
type = stringstream.next();
type = stringstream.next();
type = stringstream.next();
dest = stringstream.nextInt();
src = stringstream.nextInt();
actualMessage = stringstream.next();
if (dest != sourceNode)
blockingQueue.add(new QueueMessage(MESSAGETONODE, str, dest, src, getTimeInMS()));
else {
System.err.println("message from <" + msg.getAddress().getHostAddress() + ","
+ msg.getPort() + ">");
System.out.println(actualMessage);
System.out.println("Checksum received = " + checksum);
}
} else {
Scanner stringstream = new Scanner(str);
// System.out.println("STRING IS " + str);
String type = stringstream.next();
type = stringstream.next();
int nodeID = stringstream.nextInt();
int src = stringstream.nextInt();
int TTL = stringstream.nextInt();
int neighborIndex = networkLayer.getNeighborIndex(src);
if (str.startsWith(DEATHNOTE)) {
System.out.println("Node " + nodeID + " is dead");
// System.out.println("RECEIVED DEATHNOTE " + nodeID);
networkLayer.setNodeDead(nodeID);
// networkLayer.displayRoutingTable();
if (TTL > 1) {
for (int i = 0; i < networkLayer.getNeighborsCount(); ++i)
if (i != neighborIndex)
blockingQueue.add(new QueueMessage(DEATHNOTE, DEATHNOTE + " " +
nodeID + " " + src + " " + Integer.toString(TTL - 1),
networkLayer.getNeighborNID(i), sourceNode, getTimeInMS()));
}
} else {
System.out.println("Node " + nodeID + " is alive");
// System.out.println("RECEIVED BIRTHCERT " + nodeID);
networkLayer.setNodeAlive(nodeID);
// networkLayer.displayRoutingTable();
if (TTL > 1) {
for (int i = 0; i < networkLayer.getNeighborsCount(); ++i)
if (i != neighborIndex)
blockingQueue.add(new QueueMessage(BIRTHCERT, BIRTHCERT + " " +
nodeID + " " + src + " " + Integer.toString(TTL - 1),
networkLayer.getNeighborNID(i), sourceNode, getTimeInMS()));
}
}
}
}
}
// accepts that socket port and runs the server
//Socket s = ss.accept();
// gets input from the client
/*BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;
// Reads the input from the client
line = in.readLine();
//displays the client and the local IP/port for debugging purposes
System.out.println(line);
System.out.println(s.getLocalSocketAddress());
} catch (IOException e) {
e.printStackTrace();
}*/
}
}.start();
}
public static long getTimeInMS() {
return System.currentTimeMillis();
}
}
public class IPLayer {
String message;
int neighborOne, neighborTwo;
public IPLayer(String message, int neighborOne, int neighborTwo) {
super();
this.message = message;
this.neighborOne = neighborOne;
this.neighborTwo = neighborTwo;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public int getNeighborOne() {
return neighborOne;
}
public void setNeighborOne(int neighborOne) {
this.neighborOne = neighborOne;
}
public int getNeighborTwo() {
return neighborTwo;
}
public void setNeighborTwo(int neighborTwo) {
this.neighborTwo = neighborTwo;
}
// Need to rework these to add to a DatagramPacket to create for a UDP application
public void sendData(int destNode, int neighborOne, int neighborTwo, String message) {
message = neighborOne + " " + neighborTwo + " " + message;
System.out.println(message);
}
}
import java.io.*;
public class Main {
public static void main(String[] args) throws NumberFormatException, IOException {
Client client;
if(args.length != 2)
System.out.println("Usage: java Client host port");
else
client = new Client(Integer.parseInt(args[0]), args[1]); // run as java Main (nodeID) (itc-[number])
//java Main 1 itc-1
}
}
public class Neighbor {
private int ID;
private long lastCheckTime;
private boolean isAlive, sentMsg;
public Neighbor(int ID) {
this.ID = ID;
this.lastCheckTime = getTimeInMS();
this.isAlive = true;
this.sentMsg = false;
}
public long getTimeInMS() {
return System.currentTimeMillis();
}
public int getID() {
return ID;
}
public long getLastCheckTime() {
return lastCheckTime;
}
public void setLastCheckTime(long lastCheckTime) {
this.lastCheckTime = lastCheckTime;
}
public boolean getIsAlive() {
return isAlive;
}
public void setIsAlive(boolean isAlive) {
this.isAlive = isAlive;
}
public boolean getSentMsg() {
return sentMsg;
}
public void setSentMsg(boolean sentMsg) {
this.sentMsg = sentMsg;
}
}
import java.io.*;
import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class NetworkLayer {
private final int threshold = 5000;
private final int waitingTime = 2000;
public static final int INF = (int) 1e9;
private String itcFile;
private int nNodes;
private int nodeID;
private ArrayList<Node> linkNode;
private int[] nextHop;
private int[] shortestPath;
private List<List<Neighbor>> adjList;
private int aliveMsk = 4095;
private int tmpMsk = 4095;
public NetworkLayer(String itcFile, int nodeID, ArrayList<Node> linkNode) throws FileNotFoundException {
this.itcFile = itcFile;
this.nNodes = 0;
this.nodeID = nodeID;
this.linkNode = linkNode;
init();
nextHop = new int[nNodes + 1];
shortestPath = new int[nNodes + 1];
setupRoutingTable();
}
private void init() throws FileNotFoundException {
this.nNodes = 0;
Scanner scanner = new Scanner(new File(itcFile + ".txt"));
while (scanner.hasNextInt()) {
this.nNodes++;
int ID = scanner.nextInt();
String name = scanner.next();
int port = scanner.nextInt();
int n1 = scanner.nextInt();
int n2 = scanner.nextInt();
int mtu = scanner.nextInt();
}
linkNode.add(new Node(0, "", 0, 0, 0, 0));
Collections.sort(linkNode, (lhs, rhs) -> lhs.getNodeID() < rhs.getNodeID() ? -1 : 1);
fillAdjList();
}
private boolean notPresentInAdjList(int x, int y) {
for (Neighbor n : adjList.get(x)) if (n.getID() == y) return false;
return true;
}
private void addToAdjList(int x, int y) {
if (notPresentInAdjList(x, y)) adjList.get(x).add(new Neighbor(y));
}
private void fillAdjList() {
adjList = new ArrayList<>();
for (int i = 0; i < nNodes + 5; ++i) adjList.add(new ArrayList<>());
// System.out.println(adjList.size());
for (Node n : linkNode) {
addToAdjList(n.getNodeID(), n.getNodeOne());
addToAdjList(n.getNodeOne(), n.getNodeID());
addToAdjList(n.getNodeID(), n.getNodeTwo());
addToAdjList(n.getNodeTwo(), n.getNodeID());
}
// printAdjList();
}
private void printAdjList() {
System.out.println("\nSTARTED PRINTING");
for (Neighbor i : adjList.get(nodeID)) System.out.print(i.getID() + " ");
System.out.println("\nENDED PRINTING");
}
public void setupRoutingTable() {
Arrays.fill(nextHop, INF);
Arrays.fill(shortestPath, INF);
dijkstra(nodeID);
// System.out.println("BACK ");
displayRoutingTable();
}
private void dijkstra(int src) {
PriorityQueue<pqNode> pq = new PriorityQueue<>(1, Comparator.comparingInt(pqNode::getCost));
nextHop[src] = src;
shortestPath[src] = 0;
pq.add(new pqNode(0, src));
while (!pq.isEmpty()) {
int top = pq.peek().getCurNode();
pq.poll();
for (Neighbor n : adjList.get(top)) {
int node = n.getID();
if (isNodeAlive(node) && shortestPath[top] + 1 < shortestPath[node]) {
shortestPath[node] = shortestPath[top] + 1;
if (nextHop[top] == src) nextHop[node] = node;
else nextHop[node] = nextHop[top];
pq.add(new pqNode(shortestPath[node], node));
}
}
}
}
public void displayRoutingTable() {
for (int x : shortestPath) System.out.print(x + " ");
System.out.println();
System.out.println("\n----------------\n");
for (int x : nextHop) System.out.print(x + " ");
System.out.println();
System.out.println();
}
public void checkNeighbors(BlockingQueue<QueueMessage> blockingQueue, BlockingQueue<QueueMessage> ACKQueue,
int neighborIndex) {
(new Thread(() -> {
Neighbor neighbor = adjList.get(nodeID).get(neighborIndex);
while (true) {
// boolean changes = false;
long curTime = getTimeInMS();
if (neighbor.getSentMsg()) {
if (curTime - neighbor.getLastCheckTime() > waitingTime) {
neighbor.setSentMsg(false);
// sentMsg1 = false;
if (neighbor.getIsAlive()) {
System.out.println("Node " + neighbor.getID() + " is dead");
neighbor.setIsAlive(false);
// changes = true;
setNodeDead(neighbor.getID());
// eg: Death note 2(node ID) 4(TTL)
for (Neighbor n : adjList.get(nodeID))
if (neighbor.getID() != n.getID()) {
blockingQueue.add(new QueueMessage(Client.DEATHNOTE, Client.DEATHNOTE + " "
+ neighbor.getID() + " " + nodeID + " 4", n.getID(), nodeID,
getTimeInMS()));
}
}
} else {
try {
QueueMessage message = ACKQueue.poll(100, TimeUnit.MILLISECONDS);
if (message != null) {
if (message.getOriginatingTime() < neighbor.getLastCheckTime()) continue;
neighbor.setSentMsg(false);
if (!neighbor.getIsAlive()) {
System.out.println("Node " + neighbor.getID() + " is alive");
neighbor.setIsAlive(true);
// changes = true;
setNodeAlive(neighbor.getID());
// eg: Birth cert 2(node ID) 4(TTL)
for (Neighbor n : adjList.get(nodeID))
if (neighbor.getID() != n.getID()) {
blockingQueue.add(new QueueMessage(Client.BIRTHCERT,
Client.BIRTHCERT + " " + neighbor.getID() + " " + nodeID
+ " 4", n.getID(), nodeID, getTimeInMS()));
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} else {
if (curTime - neighbor.getLastCheckTime() > threshold) {
neighbor.setSentMsg(true);
neighbor.setLastCheckTime(curTime);
blockingQueue.add(new QueueMessage(Client.CHECK, Client.CHECKMESSAGE + " " + nodeID,
neighbor.getID(), nodeID, getTimeInMS()));
}
}
}
})).start();
}
public void setNodeAlive(int NID) {
this.tmpMsk |= (1 << NID);
}
public void setNodeDead(int NID) {
this.tmpMsk &= ~(1 << NID);
}
public int getNeighborNID(int neighbor) {
return adjList.get(nodeID).get(neighbor).getID();
}
public long getTimeInMS() {
return System.currentTimeMillis();
}
public boolean isNodeAlive(int NID) {
return ((tmpMsk >>> NID) & 1) == 1;
}
public int routeMessage(QueueMessage queueMessage) {
if (aliveMsk != tmpMsk) {
// System.out.println("ALIVE MSK " + aliveMsk);
// System.out.println("TMP MSK " + tmpMsk);
aliveMsk = tmpMsk;
setupRoutingTable();
}
int destNode = queueMessage.getDestinationNID();
if (queueMessage.getMessageType() == Client.MESSAGETONODE) {
if (nextHop[destNode] == INF) return INF;
return getPort(nextHop[destNode]);
}
// System.out.println(destNode + " " + getPort(destNode));
return getPort(destNode);
}
private int getPort(int i) {
return linkNode.get(i).getPortNumber();
}
public int getNeighborsCount() {
return adjList.get(nodeID).size();
}
public int getNeighborIndex(int senderNode) {
for (int i = 0; i < getNeighborsCount(); i++)
if (adjList.get(nodeID).get(i).getID() == senderNode) return i;
return 0;
}
public int getNodePort(int sourceNID) {
return linkNode.get(sourceNID).getPortNumber();
}
}
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;
public class Node {
private String hostName;
private int nodeID, portNumber, nodeOne, nodeTwo, mtuBytes, senderPortNumber;
public Node() {
}
public Node(int nodeID, String hostName, int portNumber, int nodeOne, int nodeTwo, int mtuBytes) {
super();
this.nodeID = nodeID;
this.hostName = hostName;
this.portNumber = portNumber;
this.nodeOne = nodeOne;
this.nodeTwo = nodeTwo;
this.mtuBytes = mtuBytes;
}
public int getNodeID() {
return nodeID;
}
public void setNodeID(int nodeID) {
this.nodeID = nodeID;
}
public String getHostName() {
return hostName;
}
public void setHostName(String hostName) {
this.hostName = hostName;
}
public int getPortNumber() {
return portNumber;
}
public void setPortNumber(int portNumber) {
this.portNumber = portNumber;
}
public int getNodeOne() {
return nodeOne;
}
public void setNodeOne(int nodeOne) {
this.nodeOne = nodeOne;
}
public int getNodeTwo() {
return nodeTwo;
}
public void setNodeTwo(int nodeTwo) {
this.nodeTwo = nodeTwo;
}
public int getMtuBytes() {
return mtuBytes;
}
public void setMtuBytes(int mtuBytes) {
this.mtuBytes = mtuBytes;
}
@Override
public String toString() {
return "ReadData [nodeID=" + nodeID + ", hostName=" + hostName + ", portNumber=" + portNumber + ", nodeOne=" + nodeOne
+ ", nodeTwo=" + nodeTwo + ", mtuBytes=" + mtuBytes + "]";
}
}
public class pqNode {
private int cost;
private int curNode;
public pqNode(int _cost, int _curNode) {
cost = _cost;
curNode = _curNode;
}
public int getCost() {
return this.cost;
}
public int getCurNode() {
return this.curNode;
}
}
public class QueueMessage {
private String messageType, message;
private int destinationNID, sourceNID;
private long originatingTime;
public QueueMessage(String messageType, String message, int destinationNID, int sourceNID, long originatingTime) {
this.messageType = messageType;
this.message = message;
this.destinationNID = destinationNID;
this.sourceNID = sourceNID;
this.originatingTime = originatingTime;
}
public String getMessageType() {
return messageType;
}
public String getMessage() {
return message;
}
public int getDestinationNID() {
return destinationNID;
}
public int getSourceNID() {
return sourceNID;
}
public long getOriginatingTime() {
return originatingTime;
}
}
import java.io.*;
import java.net.InetAddress;
import java.util.Scanner;
import java.util.zip.Adler32;
public class TransportLayer {
int destPort, sourcePort, sourceNode, destNode, transmissionBytes;
String message;
public TransportLayer() {
}
public TransportLayer(int sourceNode, int sourcePort, int destNode, int destPort, String message) {
super();
this.sourceNode = sourceNode;
this.sourcePort = sourcePort;
this.destNode = destNode;
this.destPort = destPort;
this.message = message;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
private String createHeader(String message) throws FileNotFoundException {
byte srcPort;
byte dPort;
byte[] ports = new byte[2];
srcPort = (byte) sourcePort;
dPort = (byte) destPort;
ports[0] = srcPort;
ports[1] = dPort;
message = ports[0] + " " + ports[1] + " " + message;
// calls the method to create the checksum
message = createChecksum(message);
return message;
}
// Need to rework these to add to a DatagramPacket to create for a UDP application
public String sendData(int destNode, String message) throws IOException {
// Create header for transport layer: sourceport, destport, length, checksum, message
int length;
length = message.length();
return createHeader(message);
}
public String createChecksum(String message) throws FileNotFoundException {
int maxSize = 0;
int length = message.length();
// set the maximum size of the data with the MTU's from the file
for (Node node : Client.linkNode) {
if (sourceNode == node.getNodeID()) {
maxSize = node.getMtuBytes();
transmissionBytes = maxSize;
}
}
// array to hold the max size for the data being sent
int data[] = new int[maxSize];
// array to hold the max size for the compliment of the data
int complimentData[] = new int[maxSize];
int numBits = 0;
int checkSum = 0, i;
// creating the checksum for the length of data in the message
for (i = 0; i < length; i++) {
numBits = (int) (Math.floor(Math.log(data[i]) / Math.log(2))) + 1;
// compliments the checksum
complimentData[i] = ((1 << numBits) - 1) ^ data[i];
// adding the complimented data
checkSum += complimentData[i];
}
// creates the sum of the checksum
data[i] = checkSum;
length += 1;
// adds the checksum to the "header"
message = checkSum + " " + message;
// NetworkLayer nl = new NetworkLayer(sourceNode, destNode, transmissionBytes, message);
// nl.routingTable();
return message;
}
public int receiveChecksum() {
Scanner stringstream = new Scanner(message);
int checksum = stringstream.nextInt();
String tmp = "";
boolean b = false;
while (stringstream.hasNext()) {
if (b) tmp += " ";
tmp += stringstream.next();
b = true;
}
message = tmp;
// System.out.println(message);
return checksum;
}
public byte[] receiveHeaders() {
byte[] ports = new byte[2];
Scanner stringstream = new Scanner(message);
for (int i = 0; i < 2; ++i) ports[i] = (byte) stringstream.nextInt();
String tmp = "";
boolean b = false;
while (stringstream.hasNext()) {
if (b) tmp += " ";
tmp += stringstream.next();
b = true;
}
message = tmp;
return ports;
}
}and here is the two files:
itc-1
1 u-02.sm201.iuk.edu 17870 2 4 600
2 u-03.sm201.iuk.edu 17871 1 3 1000
3 u-03.sm201.iuk.edu 17872 2 4 500
4 u-05.sm201.iuk.edu 17873 1 3 700
itc-2
1 u-01.sm201.iuk.edu 17870 2 3 500
2 u-02.sm201.iuk.edu 17871 1 3 1500
3 u-03.sm201.iuk.edu 17872 1 2 300
4 u-04.sm201.iuk.edu 17873 1 5 1000
5 u-05.sm201.iuk.edu 17874 1 4 500
6 u-06.sm201.iuk.edu 17875 2 7 700
7 u-07.sm201.iuk.edu 17876 2 6 500
8 u-08.sm201.iuk.edu 17877 3 9 500
9 u-09.sm201.iuk.edu 17878 3 8 400as i said the program read itc-1 and function right the way that i want but it is not reading itc-2 can someone please help me fix my problem?!
