public static void main(String[] args) throws IOException, InterruptedException {
boolean running = true;
// udp protocol over a socket.
DatagramSocket socket = new DatagramSocket();
while (running) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
String[] inputs = line.split(" ");
if (inputs.length < 2) {
System.out.println("Usage: username command id");
socket.close();
return;
}
byte[] byteArr = (inputs[0] + " " + inputs[1] + " " + inputs[2]).getBytes();
// send request
byte[] buf = new byte[256];
InetAddress address = InetAddress.getByName("localhost");
DatagramPacket packet = new DatagramPacket(byteArr, byteArr.length, address, 4445);
socket.send(packet);
// get response
packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
// display response
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("From server: " + received);
}
// socket.close();
}
public void run() {
if (ServerSocket == null) return;
while (true) {
try {
InetAddress address;
int port;
DatagramPacket packet;
byte[] data = new byte[1460];
packet = new DatagramPacket(data, data.length);
ServerSocket.receive(packet);
//
//
address = packet.getAddress();
port = packet.getPort();
System.out.println("get the Client port is: " + port);
System.out.println("get the data length is: " + data.length);
FileWriter fw = new FileWriter("Fortunes.txt");
PrintWriter out = new PrintWriter(fw);
for (int i = 0; i < data.length; i++) {
out.print(data[i] + " ");
}
out.close();
System.out.println("Data has been writen to destination!");
packet = new DatagramPacket(data, data.length, address, port);
ServerSocket.send(packet);
System.out.println("Respond has been made!");
} catch (Exception e) {
System.err.println("Exception: " + e);
e.printStackTrace();
}
}
}
public static void main(String args[]) throws Exception {
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress = InetAddress.getByName("192.168.1.16");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = new String("HELLO");
sendData = sentence.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
clientSocket.send(sendPacket);
DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
clientSocket.receive(receivePacket);
sentence = new String(receivePacket.getData(), 0, receivePacket.getLength());
if (sentence.equals("##100##")) {
System.out.println(sentence + ": Waiting for Red.");
}
while (!sentence.equals("##200##")) {
try {
receivePacket = new DatagramPacket(receiveData, receiveData.length);
clientSocket.receive(receivePacket);
sentence = new String(receivePacket.getData(), 0, receivePacket.getLength());
} catch (Exception e) {
}
}
if (sentence.equals("##200##")) {
System.out.println(sentence + ": Red and Blue are connected");
}
while (true) {
receiveData = new byte[1024];
receivePacket = new DatagramPacket(receiveData, receiveData.length);
clientSocket.receive(receivePacket);
sentence = new String(receivePacket.getData(), 0, receivePacket.getLength());
if (sentence.equals("##300##")) {
break;
}
System.out.println("RED: " + sentence);
sentence = inFromUser.readLine();
sendData = sentence.getBytes();
sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
clientSocket.send(sendPacket);
}
System.out.println(sentence + ": Disconnected.");
clientSocket.close();
}
public static void wait(DatagramSocket skt, DatagramPacket request)
throws IOException, InterruptedException {
// stop till you receive
skt.receive(request);
System.out.println("request received");
Thread.sleep(2000);
}
public void run() {
System.out.println("ExeUDPServer开始监听..." + UDP_PORT);
DatagramSocket ds = null;
try {
ds = new DatagramSocket(UDP_PORT);
} catch (BindException e) {
System.out.println("UDP端口使用中...请重关闭程序启服务器");
} catch (SocketException e) {
e.printStackTrace();
}
while (ds != null) {
DatagramPacket dp = new DatagramPacket(buf, buf.length);
try {
ds.receive(dp);
// 得到把该数据包发来的端口和Ip
int rport = dp.getPort();
InetAddress addr = dp.getAddress();
String recvStr = new String(dp.getData(), 0, dp.getLength());
System.out.println("Server receive：" + recvStr + " from " + addr + " " + rport);
// 给客户端回应
String sendStr = "echo of " + recvStr;
byte[] sendBuf;
sendBuf = sendStr.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, addr, rport);
ds.send(sendPacket);
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void run() {
while (moreQuotes) {
try {
byte[] buf = new byte[256];
// receive request
DatagramPacket packet = new DatagramPacket(buf, buf.length);
socket.receive(packet); // containing IP ecc.
// figure out response
String dString = null;
if (in == null) dString = new Date().toString();
else dString = getNextQuote();
buf = dString.getBytes();
// send the response to the client at "address" and "port"
InetAddress address = packet.getAddress();
int port = packet.getPort();
packet = new DatagramPacket(buf, buf.length, address, port);
socket.send(packet);
} catch (IOException e) {
e.printStackTrace();
moreQuotes = false;
}
}
socket.close();
}
public static void main(String args[]) {
DatagramSocket skt = null;
try {
skt = new DatagramSocket(6789);
byte[] buffer = new byte[1000];
while (true) {
DatagramPacket request = new DatagramPacket(buffer, buffer.length);
skt.receive(request);
System.out.println("Data received from client");
System.out.println(new String(request.getData()));
Thread.sleep(15000);
String[] arrayMsg = (new String(request.getData())).split(" ");
System.out.println(arrayMsg[0] + "server processed");
byte[] sendMsg = (arrayMsg[0] + "server processed").getBytes();
DatagramPacket reply =
new DatagramPacket(sendMsg, sendMsg.length, request.getAddress(), request.getPort());
System.out.println("sending data from server to client");
Thread.sleep(15000);
;
skt.send(reply);
}
} catch (Exception e) {
}
}
public static void main(final String... args) throws Throwable {
final String remotehost = args[0];
final int remoteport = Integer.parseInt(args[1]);
final DatagramSocket socket = new DatagramSocket();
final byte buffer[] = new byte[512];
final InetSocketAddress remote = new InetSocketAddress(remotehost, remoteport);
buffer[0] = ENQUIRY;
buffer[1] = END_OF_TRANSMISSION;
socket.send(new DatagramPacket(buffer, 2, remote));
final DatagramPacket p = new DatagramPacket(buffer, buffer.length);
socket.receive(p);
if ((p.getLength() == 2) && (buffer[0] == ACKNOWLEDGE) && (buffer[1] == END_OF_TRANSMISSION))
System.out.println("Connection established");
else {
System.out.println("Connection failed");
return;
}
for (; ; ) {
int ptr = 0;
for (int d; (d = System.in.read()) != '\n'; ) buffer[ptr++] = (byte) d;
socket.send(new DatagramPacket(buffer, ptr, remote));
}
}
public static void main(String args[]) {
DatagramSocket aSocket = null;
try {
aSocket = new DatagramSocket();
String stringMsg = "0";
String prevReply = "0";
InetAddress aHost =
InetAddress.getByName("localhost"); // recieve a message from the same computer
int serverPort = 6789; // agreed port
while (true) {
stringMsg = "" + (Integer.parseInt(stringMsg) + 1);
byte[] message = stringMsg.getBytes();
DatagramPacket request = new DatagramPacket(message, message.length, aHost, serverPort);
System.out.printf("Producer: Sending: %s\n", stringMsg);
aSocket.send(request); // send a message
byte[] buffer = new byte[1000];
DatagramPacket reply = new DatagramPacket(buffer, buffer.length);
aSocket.receive(reply); // wait for a reply
try {
Thread.sleep(2000); // have a small waiting period
} catch (InterruptedException e) {
}
}
} catch (SocketException e) {
System.out.println("Socket: " + e.getMessage());
} catch (IOException e) {
System.out.println("IO: " + e.getMessage());
} finally {
if (aSocket != null) aSocket.close();
}
}
/**
* Attempts to log a client in using the authentication server. Authentication server needs to run
* on the same host as the file server.
*
* @throws IOException Error reading from socket.
*/
private void login() throws IOException {
// set up required variables
DatagramSocket clientSocket = new DatagramSocket();
InetAddress authServerIP =
InetAddress
.getLocalHost(); // because authentication server runs on same host as file server
byte[] dataToSend;
byte[] receivedData = new byte[BUFFER_SIZE];
// get username and password
String userName = inFromClient.readLine().trim(); // get username
String password = inFromClient.readLine().trim(); // get password
dataToSend = new String(userName + " " + password).getBytes();
// send the username and password for processing by authentication server
DatagramPacket packetToSend =
new DatagramPacket(dataToSend, dataToSend.length, authServerIP, AUTHENTICATION_PORT);
clientSocket.send(packetToSend);
// receive the response from the authentication server
DatagramPacket receivedPacket = new DatagramPacket(receivedData, receivedData.length);
clientSocket.receive(receivedPacket);
String receivedString = new String(receivedPacket.getData()).trim();
receivedData = receivedString.getBytes();
if (receivedString.equals("yes")) {
outToClient.writeBytes(receivedString); // successful login
} else {
outToClient.writeBytes("no"); // unsuccessful login
}
}
public static void doEcho(int port) throws IOException {
byte[] buf = new byte[BUF_SIZE];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
DatagramSocket sock = new DatagramSocket(port);
System.out.println(
"Starting UDP echo on"
+ sock.getLocalAddress().getHostAddress()
+ ":"
+ sock.getLocalPort());
while (true) {
try {
sock.receive(packet);
sock.send(packet);
System.out.print(
"UDP From: "
+ packet.getAddress().getHostAddress()
+ ":"
+ packet.getPort()
+ "\n"
+ new String(packet.getData(), 0, packet.getLength())
+ "\n");
System.out.flush();
packet.setLength(buf.length);
// packet = new DatagramPacket(buf,buf.length);
} catch (IOException io_ex) {
}
}
}
private void listen() throws Exception {
System.out.println("Listening on port: " + serverPort);
// Initialize socket
socket = new DatagramSocket(serverPort);
// While running
while (run) {
// Wait for handshake
packet = new DatagramPacket(response, response.length);
socket.receive(packet); // Blocking
// System.out.println("RT: got packet");
Packet p = new Packet(packet.getData());
if (p.isHandshake()) {
// System.out.println("RT: is handshake");
// Get client connection info
InetAddress IPAddress = packet.getAddress();
int port = packet.getPort();
// Process handshake
processHandshake(p, IPAddress, port);
// Get message
MyMessage message = getMessage();
if (message != null) {
rc.rreceive(message);
}
}
}
}
public void run() {
while (true) {
DatagramPacket msg = new DatagramPacket(new byte[1000], 1000);
try {
socket.receive(msg);
} catch (IOException e) {
}
;
String container = new String(msg.getData());
container = container.trim();
if (container.substring(0, container.indexOf(' ')).equals("vfd"))
CALM.box.mailAction(container.substring(container.indexOf(' ') + 1, container.length()));
else if (container.substring(0, container.indexOf(' ')).equals("dfv"))
CALM.box.mailAction2(container.substring(container.indexOf(' ') + 1, container.length()));
}
}
public static void main(String args[]) throws Exception {
String serverHostname = args[0];
int portNumber = Integer.parseInt(args[1]);
try {
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress = InetAddress.getByName(serverHostname);
System.out.println("Attempting to connect to " + IPAddress + ") via UDP port " + portNumber);
System.out.println("Enter \"Quit\" to exit program");
while (true) {
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
System.out.print("Enter Message: ");
String sentence = inFromUser.readLine();
if (sentence.equals("Quit")) break;
sendData = sentence.getBytes();
System.out.println("Sending data to " + sendData.length + " bytes to server.");
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, IPAddress, portNumber);
clientSocket.send(sendPacket);
DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
System.out.println("Waiting for return packet");
clientSocket.setSoTimeout(10000);
try {
clientSocket.receive(receivePacket);
String modifiedSentence = new String(receivePacket.getData());
InetAddress returnIPAddress = receivePacket.getAddress();
int port = receivePacket.getPort();
System.out.println("From server at: " + returnIPAddress + ":" + port);
System.out.println("Message: " + modifiedSentence);
} catch (SocketTimeoutException ste) {
System.out.println("Timeout Occurred: Packet assumed lost");
}
System.out.print("\n");
}
clientSocket.close();
} catch (UnknownHostException ex) {
System.err.println(ex);
} catch (IOException ex) {
System.err.println(ex);
}
}
public void run() {
while (listen) {
try {
byte[] buf = new byte[256];
byte[] buf2 = new byte[256];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
InetAddress address;
socket.receive(packet);
String in = new String(packet.getData(), 0, packet.getLength());
address = packet.getAddress();
int port = packet.getPort();
// newClient = findPort(port, address, newClient);
String name = findPerson(port, address);
// System.out.println(name);
if (in.startsWith("1")) {
String nama = new String(packet.getData(), 0, packet.getLength());
nama = nama.substring(1);
newClient = new Client(packet.getAddress(), packet.getPort(), nama);
threads.add(newClient);
String wel =
"\nWelcome "
+ newClient.nama
+ "\n "
+ "to quit type \"bye\" and to whisper use prefix @name : ";
buf = (wel).getBytes();
packet = new DatagramPacket(buf, buf.length, packet.getAddress(), packet.getPort());
socket.send(packet);
wel = " enters the room";
buf = (newClient.nama + wel).getBytes();
Broadcast(address, port, buf);
} else if (in.startsWith("@")) {
// findPort(port, address, newClient);
Whisper(newClient, packet.getData());
} else if (in.equals("bye")) {
String bye = name + " is leaving";
buf2 = bye.getBytes();
// packet = new DatagramPacket(buf,buf.length,newClient.address, newClient.port);
Broadcast(address, port, buf2);
} else {
byte[] buf3 = new byte[256];
String text =
name + "<broadcast> : " + new String(packet.getData(), 0, packet.getLength());
buf3 = text.getBytes();
Broadcast(packet.getAddress(), packet.getPort(), buf3);
}
} catch (IOException ex) {
Logger.getLogger(DatagramServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
socket.close();
}
public static void main(String[] args) {
try (DatagramSocket socket = new DatagramSocket(0)) {
socket.setSoTimeout(10000);
InetAddress host = InetAddress.getByName(HOSTNAME);
DatagramPacket request = new DatagramPacket(new byte[1], 1, host, PORT);
DatagramPacket response = new DatagramPacket(new byte[1024], 1024);
socket.send(request);
socket.receive(response);
String result = new String(response.getData(), 0, response.getLength(), "US-ASCII");
System.out.println(result);
} catch (IOException ex) {
ex.printStackTrace();
}
}
public void run() {
byte buffer[] = new byte[1024];
DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
String s;
boolean done = false;
try {
while (!done) {
ds.receive(dp);
s = new String(dp.getData(), 0, dp.getLength());
System.out.println("RCD MSG:" + s);
if (s == "-") done = true;
}
} catch (IOException e) {
}
}
public static void main(String args[]) throws Exception {
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress = InetAddress.getByName("62.38.242.7");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = inFromUser.readLine();
sendData = sentence.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9310);
clientSocket.send(sendPacket);
DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
clientSocket.receive(receivePacket);
String modifiedSentence = new String(receivePacket.getData());
System.out.println("FROM SERVER:" + modifiedSentence);
clientSocket.close();
}
/**
* Main method keeps waiting for request and do math operation accordingly
*
* @param args
*/
public static void main(String args[]) {
DatagramSocket aSocket = null;
try {
aSocket = new DatagramSocket(6789);
byte[] buffer = new byte[1000];
while (true) {
DatagramPacket request = new DatagramPacket(buffer, buffer.length);
aSocket.receive(request);
// receive byte array of equation and put it in string
String equation = new String(request.getData());
String answer = "";
String[] split = equation.split(" ");
// parse to integer and calculate
String op = split[1];
double var1 = Double.parseDouble(split[0]);
double var2 = Double.parseDouble(split[2]);
if (op.equals("+")) {
answer = Double.toString(var1 + var2);
} else if (op.equals("-")) {
answer = Double.toString(var1 - var2);
} else if (op.toLowerCase().equals("X") || op.toLowerCase().equals("x")) {
answer = Double.toString(var1 * var2);
} else if (op.equals("/")) {
answer = Double.toString(var1 / var2);
}
// send answer back
DatagramPacket reply =
new DatagramPacket(
answer.getBytes(),
(answer.getBytes()).length,
request.getAddress(),
request.getPort());
aSocket.send(reply);
}
} catch (SocketException e) {
System.out.println("Socket: " + e.getMessage());
} catch (IOException e) {
System.out.println("IO: " + e.getMessage());
} finally {
if (aSocket != null) {
aSocket.close();
}
}
}
private MyMessage getMessage() throws Exception {
int dataRecieved = 0;
String m = new String();
String t;
// FIXME needs to get multiple packets and messages
// System.out.println("RT: Now waiting for message data");
while (dataRecieved < totalDataSize) {
// Get message data
response = new byte[65000];
DatagramPacket packet = new DatagramPacket(response, response.length);
socket.receive(packet);
Packet p = new Packet(packet.getData());
// System.out.println("RT: Got message with seqnum: "+p.getSeqNum());
// If we have a handshake packet something broke
if (p.isHandshake()) {
return null;
}
// If next in-order packet grab data and is not corrupt
// XXX
if (p.getSeqNum() == seqNum + 1 && p.checkChecksum()) {
// Get the message ( part? )
// System.out.println("RT: Is correct seqnum");
t = p.getMessages().get(0).getMessageContents();
// System.out.println("RT: Got message packet: " + t);
m += t;
// Send ack
sendAck(p, packet);
// Increment counters
dataRecieved += t.length();
seqNum++;
} else {
System.out.println("RT: Is NOT correct seqnum");
}
}
MyMessage result = new MyMessage();
result.setMessageContents(m);
return result;
}
public void run() {
byte[] buf = new byte[BUF_SIZE];
DatagramPacket incomingData = new DatagramPacket(buf, buf.length);
try {
while (true) {
sock.receive(incomingData);
System.out.println(
"UDP From:"
+ incomingData.getAddress().getHostAddress()
+ ":"
+ incomingData.getPort());
System.out.println(new String(incomingData.getData(), 0, incomingData.getLength()));
System.out.flush();
incomingData.setLength(buf.length);
}
} catch (IOException io_ex) {
io_ex.printStackTrace();
}
}
// waits to receive packets
private DatagramPacket receive() {
byte data[] = new byte[100];
DatagramPacket receivePacket = new DatagramPacket(data, data.length);
System.out.println("Server: waiting for a packet...\n");
// Block until a datagram packet is received from receiveSocket.
try {
receiveSocket.receive(receivePacket);
} catch (IOException e) {
System.out.print("IO Exception: likely:");
System.out.println("Receive Socket Timed Out.\n" + e);
e.printStackTrace();
System.exit(1);
}
readReceivePacket(receivePacket);
return receivePacket;
}
public static void main(String args[]) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
DatagramSocket s = new DatagramSocket();
InetAddress ip = InetAddress.getByName("localhost");
byte[] send = new byte[1000];
byte[] rec = new byte[1000];
String ss = br.readLine();
send = ss.getBytes();
DatagramPacket sendpacket = new DatagramPacket(send, send.length, ip, 1200);
s.send(sendpacket);
DatagramPacket recpacket = new DatagramPacket(rec, rec.length);
s.receive(recpacket);
String sss = new String(recpacket.getData(), 0, recpacket.getLength());
System.out.println(sss);
}
public static void main(String args[]) throws Exception {
// Open socket loclahost:6000
DatagramSocket serverSocket = new DatagramSocket(6000, InetAddress.getByName("localhost"));
byte[] receiveData = new byte[1024];
byte[] sendData = new byte[1024];
// Hanging on
while (true) {
DatagramPacket readPacket = new DatagramPacket(receiveData, receiveData.length);
serverSocket.receive(readPacket);
String readData = new String(readPacket.getData());
System.out.println("UDP Server, " + readData);
InetAddress ip = readPacket.getAddress();
int port = readPacket.getPort();
String output = "Hello, " + readData;
sendData = output.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, ip, port);
serverSocket.send(sendPacket);
}
}
static byte[] sendReq(byte abyte0[], int i, String s, int j) throws Exception {
DatagramSocket datagramsocket = new DatagramSocket(i);
try {
datagramsocket.setSoTimeout(30000);
datagramsocket.send(new DatagramPacket(abyte0, abyte0.length, InetAddress.getByName(s), j));
byte abyte1[] = new byte[512];
DatagramPacket datagrampacket = new DatagramPacket(abyte1, abyte1.length);
datagramsocket.receive(datagrampacket);
byte abyte2[] = new byte[datagrampacket.getLength()];
System.arraycopy(datagrampacket.getData(), 0, abyte2, 0, datagrampacket.getLength());
datagramsocket.close();
return abyte2;
} catch (Exception exception) {
try {
datagramsocket.close();
} catch (Exception exception1) {
}
throw exception;
}
}
public void runClient() throws IOException {
try {
dataClient = new DatagramSocket();
dataOut = "1".getBytes();
dataSent = new DatagramPacket(dataOut, dataOut.length, getAddress(), getPort());
dataClient.send(dataSent);
Scanner input = new Scanner(System.in);
// setSocket(new Socket(getAddress(),getPort()));
// in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// out = new PrintWriter(socket.getOutputStream(),true);
while (true) {
/* Preparing Input from Server */
// serverResponse = in.readLine();
try {
dataReceived.setData(dataIn);
dataClient.receive(dataReceived);
serverResponse = new String(dataReceived.getData());
if (serverResponse.equals("1")) { // if key for getting client input is called
/* Outputting to Server */
clientResponse = input.nextLine(); // Get what the user types.
dataOut = clientResponse.getBytes();
dataSent = new DatagramPacket(dataOut, dataOut.length, getAddress(), getPort());
dataClient.send(dataSent);
// out.println(clientResponse);
} else {
System.out.println(serverResponse);
}
} catch (Exception e) {
}
}
} catch (Exception e) {
/**/
} finally {
/* socket.close(); */
}
}
private void listenToServer() throws IOException {
do {
Arrays.fill(rcvPacket.getData(), (byte) 0);
requestSocket.receive(rcvPacket);
message = new String(rcvPacket.getData());
System.out.println("server>" + message);
if (PACMANWINS.equals(message)) {
board.gameState = 1;
} else if (GHOSTWINS.equals(message)) {
board.gameState = 2;
} else {
// create new thread so that we keep listening to server as
// board is being updated
new Thread() {
public void run() {
board.changeClientsState(message);
}
}.start();
}
} while (board.gameState == 0);
}
public static void main(String[] args) {
if (args.length != 1) System.out.println("This program requires a command line argument.");
else {
int port = Integer.parseInt(args[0]);
final int MAX_LEN = 10;
// This is the assumed maximum byte length of the datagram to be received.
try {
DatagramSocket mySocket = new DatagramSocket(port);
// instantiates a datagram socket for receiving the data
byte[] buffer = new byte[MAX_LEN];
DatagramPacket datagram = new DatagramPacket(buffer, MAX_LEN);
mySocket.receive(datagram);
String message = new String(buffer);
System.out.println(message);
mySocket.close();
} // end try
catch (Exception ex) {
ex.printStackTrace();
}
} // end else
} // end main
public void run() {
System.out.println(" -----------------UDP Demo Server-----------------" + "\n\n");
while (true) {
try {
// Create a new socket connection bound to the defined port
DatagramSocket sock = new DatagramSocket(BROADCAST_PORT);
System.out.println("Waiting for data on local port: " + sock.getLocalPort());
// Create a packet to contain incoming data
byte[] buf = new byte[256];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
// Wait for incoming data (receive() is a blocking method)
sock.receive(packet);
// Retrieve data from packet and display
String data = new String(packet.getData());
int endIndex = data.indexOf(0);
data = data.substring(0, endIndex);
int remotePort = packet.getPort();
System.out.println("Received data from remote port " + remotePort + ":\n" + data);
// Determine origin of packet and display information
InetAddress remoteAddress = packet.getAddress();
System.out.println("Sent from address: " + remoteAddress.getHostAddress());
// Send back an acknowledgment
String ack = "RECEIVED " + new Date().toString();
sock.send(new DatagramPacket(ack.getBytes(), ack.length(), remoteAddress, remotePort));
sock.close();
} catch (IOException ioe) {
System.out.println("Error: IOException - " + ioe.toString());
}
}
}
static int Challenge(DatagramSocket datagramsocket, InetAddress inetaddress, int i)
throws Exception {
System.out.print("Sending the challenge request...");
byte abyte0[] = Cmd_Challenge();
datagramsocket.send(new DatagramPacket(abyte0, abyte0.length, inetaddress, i));
try {
Thread.sleep(50L);
} catch (Exception exception) {
}
abyte0 = new byte[256];
DatagramPacket datagrampacket = new DatagramPacket(abyte0, abyte0.length);
datagramsocket.receive(datagrampacket);
ReqAccept reqaccept = new ReqAccept(abyte0);
if (!((Req) (reqaccept)).legal) {
System.out.println("Connection rejected");
Print(datagrampacket);
throw new Exception();
} else {
System.out.println(" ok");
return reqaccept.Id;
}
}